From b8e758c1624a163a988aa868fbf3da19e2612f6c Mon Sep 17 00:00:00 2001 From: Kibum Kim Date: Mon, 27 Feb 2012 21:15:48 +0900 Subject: [PATCH 1/1] tizen beta release --- LICENSE | 206 +++ Makefile.am | 74 ++ audiotest/avsys-audio-test.c | 308 +++++ audiotest/avsys-audio-volume-dump.c | 104 ++ autogen.sh | 6 + avsys-audio-alsa.c | 175 +++ avsys-audio-ascenario.c | 273 ++++ avsys-audio-handle.c | 1160 +++++++++++++++++ avsys-audio-initializer.c | 242 ++++ avsys-audio-logical-volume.c | 365 ++++++ avsys-audio-pactrl.c | 426 ++++++ avsys-audio-pasimple.c | 475 +++++++ avsys-audio-path.c | 2318 +++++++++++++++++++++++++++++++++ avsys-audio-shm.c | 72 + avsys-audio-sync.c | 244 ++++ avsys-audio.c | 908 +++++++++++++ avsys-common.c | 368 ++++++ configure.ac | 102 ++ debian/changelog | 7 + debian/compat | 1 + debian/control | 33 + debian/copyright | 16 + debian/dirs | 2 + debian/docs | 0 debian/libavsystem-0.install.in | 5 + debian/libavsystem-dev.install.in | 3 + debian/libavsystem-sdk-dev.install.in | 5 + debian/rules | 138 ++ depcomp | 589 +++++++++ include/avsys-audio-alsa.h | 51 + include/avsys-audio-ascenario.h | 96 ++ include/avsys-audio-handle.h | 117 ++ include/avsys-audio-logical-volume.h | 87 ++ include/avsys-audio-pactrl.h | 72 + include/avsys-audio-pasimple.h | 57 + include/avsys-audio-path.h | 232 ++++ include/avsys-audio-shm.h | 44 + include/avsys-audio-sync.h | 47 + include/avsys-audio.h | 600 +++++++++ include/avsys-common.h | 80 ++ include/avsys-debug.h | 91 ++ include/avsys-error.h | 130 ++ include/avsys-types.h | 41 + include/avsystem.h | 37 + init/Makefile.am | 2 + init/snd_init | 10 + install-sh | 519 ++++++++ missing | 367 ++++++ packaging/avsystem.spec | 73 ++ pkgconfig-arm/Makefile.am | 16 + pkgconfig-arm/avsysaudio.pc.in | 11 + pkgconfig-arm/avsystem.pc.in | 11 + pkgconfig-arm/avsystem.pc.in.all | 11 + pkgconfig-i386/Makefile.am | 15 + pkgconfig-i386/avsysaudio.pc.in | 11 + pkgconfig-i386/avsystem.pc.in | 11 + pkgconfig-i386/avsystem.pc.in.all | 11 + 57 files changed, 11475 insertions(+) create mode 100644 LICENSE create mode 100644 Makefile.am create mode 100644 audiotest/avsys-audio-test.c create mode 100644 audiotest/avsys-audio-volume-dump.c create mode 100755 autogen.sh create mode 100644 avsys-audio-alsa.c create mode 100644 avsys-audio-ascenario.c create mode 100644 avsys-audio-handle.c create mode 100644 avsys-audio-initializer.c create mode 100644 avsys-audio-logical-volume.c create mode 100644 avsys-audio-pactrl.c create mode 100644 avsys-audio-pasimple.c create mode 100644 avsys-audio-path.c create mode 100644 avsys-audio-shm.c create mode 100644 avsys-audio-sync.c create mode 100644 avsys-audio.c create mode 100644 avsys-common.c create mode 100644 configure.ac create mode 100644 debian/changelog create mode 100644 debian/compat create mode 100644 debian/control create mode 100644 debian/copyright create mode 100644 debian/dirs create mode 100644 debian/docs create mode 100644 debian/libavsystem-0.install.in create mode 100644 debian/libavsystem-dev.install.in create mode 100644 debian/libavsystem-sdk-dev.install.in create mode 100755 debian/rules create mode 100755 depcomp create mode 100644 include/avsys-audio-alsa.h create mode 100644 include/avsys-audio-ascenario.h create mode 100644 include/avsys-audio-handle.h create mode 100644 include/avsys-audio-logical-volume.h create mode 100644 include/avsys-audio-pactrl.h create mode 100644 include/avsys-audio-pasimple.h create mode 100644 include/avsys-audio-path.h create mode 100644 include/avsys-audio-shm.h create mode 100644 include/avsys-audio-sync.h create mode 100644 include/avsys-audio.h create mode 100644 include/avsys-common.h create mode 100644 include/avsys-debug.h create mode 100644 include/avsys-error.h create mode 100644 include/avsys-types.h create mode 100644 include/avsystem.h create mode 100644 init/Makefile.am create mode 100755 init/snd_init create mode 100755 install-sh create mode 100755 missing create mode 100644 packaging/avsystem.spec create mode 100644 pkgconfig-arm/Makefile.am create mode 100644 pkgconfig-arm/avsysaudio.pc.in create mode 100755 pkgconfig-arm/avsystem.pc.in create mode 100644 pkgconfig-arm/avsystem.pc.in.all create mode 100644 pkgconfig-i386/Makefile.am create mode 100644 pkgconfig-i386/avsysaudio.pc.in create mode 100755 pkgconfig-i386/avsystem.pc.in create mode 100644 pkgconfig-i386/avsystem.pc.in.all diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..bbe9d02 --- /dev/null +++ b/LICENSE @@ -0,0 +1,206 @@ +Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. + + + diff --git a/Makefile.am b/Makefile.am new file mode 100644 index 0000000..1fba2b0 --- /dev/null +++ b/Makefile.am @@ -0,0 +1,74 @@ +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 diff --git a/audiotest/avsys-audio-test.c b/audiotest/avsys-audio-test.c new file mode 100644 index 0000000..c6a53d5 --- /dev/null +++ b/audiotest/avsys-audio-test.c @@ -0,0 +1,308 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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; +} diff --git a/audiotest/avsys-audio-volume-dump.c b/audiotest/avsys-audio-volume-dump.c new file mode 100644 index 0000000..76a97a5 --- /dev/null +++ b/audiotest/avsys-audio-volume-dump.c @@ -0,0 +1,104 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include +#include +#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 + * + * 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 + +#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 +} diff --git a/avsys-audio-ascenario.c b/avsys-audio-ascenario.c new file mode 100644 index 0000000..c78f155 --- /dev/null +++ b/avsys-audio-ascenario.c @@ -0,0 +1,273 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#endif +#include + +#include "avsys-audio-ascenario.h" +#include "avsys-types.h" +#include "avsys-error.h" +#include "avsys-debug.h" +#if defined(TIME_CHECK) +#include +#include +#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; +} diff --git a/avsys-audio-handle.c b/avsys-audio-handle.c new file mode 100644 index 0000000..fbfa441 --- /dev/null +++ b/avsys-audio-handle.c @@ -0,0 +1,1160 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include +#include +#include + +#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; +} diff --git a/avsys-audio-initializer.c b/avsys-audio-initializer.c new file mode 100644 index 0000000..31b92cc --- /dev/null +++ b/avsys-audio-initializer.c @@ -0,0 +1,242 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include +#include +#include + +#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; +} + diff --git a/avsys-audio-logical-volume.c b/avsys-audio-logical-volume.c new file mode 100644 index 0000000..c9bf544 --- /dev/null +++ b/avsys-audio-logical-volume.c @@ -0,0 +1,365 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include +#include +#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; +} diff --git a/avsys-audio-pactrl.c b/avsys-audio-pactrl.c new file mode 100644 index 0000000..eff8d89 --- /dev/null +++ b/avsys-audio-pactrl.c @@ -0,0 +1,426 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include + +#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; +} diff --git a/avsys-audio-pasimple.c b/avsys-audio-pasimple.c new file mode 100644 index 0000000..29c4593 --- /dev/null +++ b/avsys-audio-pasimple.c @@ -0,0 +1,475 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include + +#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; +} + diff --git a/avsys-audio-path.c b/avsys-audio-path.c new file mode 100644 index 0000000..7967842 --- /dev/null +++ b/avsys-audio-path.c @@ -0,0 +1,2318 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include +#include +#include +#include +#include +#include +#include + +#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; +} diff --git a/avsys-audio-shm.c b/avsys-audio-shm.c new file mode 100644 index 0000000..850f59f --- /dev/null +++ b/avsys-audio-shm.c @@ -0,0 +1,72 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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; +} diff --git a/avsys-audio-sync.c b/avsys-audio-sync.c new file mode 100644 index 0000000..dac16db --- /dev/null +++ b/avsys-audio-sync.c @@ -0,0 +1,244 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include +#include +#include +#include + +#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; +} diff --git a/avsys-audio.c b/avsys-audio.c new file mode 100644 index 0000000..8ce7538 --- /dev/null +++ b/avsys-audio.c @@ -0,0 +1,908 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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) +{ +} diff --git a/avsys-common.c b/avsys-common.c new file mode 100644 index 0000000..91f080e --- /dev/null +++ b/avsys-common.c @@ -0,0 +1,368 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include + +#define RETRY_EINTR +#include +#include + +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; +} diff --git a/configure.ac b/configure.ac new file mode 100644 index 0000000..cd205b4 --- /dev/null +++ b/configure.ac @@ -0,0 +1,102 @@ +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 diff --git a/debian/changelog b/debian/changelog new file mode 100644 index 0000000..62ad286 --- /dev/null +++ b/debian/changelog @@ -0,0 +1,7 @@ +avsystem (0.4.13-1) unstable; urgency=low + + * Initial release + * Git: slp/pkgs/a/avsystem + * Tag: avsystem_0.4.13-1 + + -- Hyunseok Lee Wed, 08 Feb 2012 09:56:41 +0900 \ No newline at end of file diff --git a/debian/compat b/debian/compat new file mode 100644 index 0000000..7ed6ff8 --- /dev/null +++ b/debian/compat @@ -0,0 +1 @@ +5 diff --git a/debian/control b/debian/control new file mode 100644 index 0000000..096b56b --- /dev/null +++ b/debian/control @@ -0,0 +1,33 @@ +Source: avsystem +Priority: optional +Maintainer: Seungbae Shin , Jeongmo Yang , JongHyuk Choi +Uploaders: YoungHwan Ahn +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) diff --git a/debian/copyright b/debian/copyright new file mode 100644 index 0000000..5ff3972 --- /dev/null +++ b/debian/copyright @@ -0,0 +1,16 @@ +Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + +Contact: Jonghyuk Choi + +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. + diff --git a/debian/dirs b/debian/dirs new file mode 100644 index 0000000..ca882bb --- /dev/null +++ b/debian/dirs @@ -0,0 +1,2 @@ +usr/bin +usr/sbin diff --git a/debian/docs b/debian/docs new file mode 100644 index 0000000..e69de29 diff --git a/debian/libavsystem-0.install.in b/debian/libavsystem-0.install.in new file mode 100644 index 0000000..23fff44 --- /dev/null +++ b/debian/libavsystem-0.install.in @@ -0,0 +1,5 @@ +# if your module, creates shared libraries +@PREFIX@/lib/*.so* +@PREFIX@/bin/* +/etc/rc.d/* + diff --git a/debian/libavsystem-dev.install.in b/debian/libavsystem-dev.install.in new file mode 100644 index 0000000..93c1cf5 --- /dev/null +++ b/debian/libavsystem-dev.install.in @@ -0,0 +1,3 @@ +# if your module creates shared libraries +@PREFIX@/include/* + diff --git a/debian/libavsystem-sdk-dev.install.in b/debian/libavsystem-sdk-dev.install.in new file mode 100644 index 0000000..35f395e --- /dev/null +++ b/debian/libavsystem-sdk-dev.install.in @@ -0,0 +1,5 @@ +# if your module creates shared libraries +@PREFIX@/lib/*.la +@PREFIX@/lib/*.a +@PREFIX@/lib/pkgconfig/* + diff --git a/debian/rules b/debian/rules new file mode 100755 index 0000000..7e1bbe7 --- /dev/null +++ b/debian/rules @@ -0,0 +1,138 @@ +#!/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 diff --git a/depcomp b/depcomp new file mode 100755 index 0000000..e5f9736 --- /dev/null +++ b/depcomp @@ -0,0 +1,589 @@ +#! /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 . + +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 . +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: diff --git a/include/avsys-audio-alsa.h b/include/avsys-audio-alsa.h new file mode 100644 index 0000000..1711f84 --- /dev/null +++ b/include/avsys-audio-alsa.h @@ -0,0 +1,51 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 + +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__ */ diff --git a/include/avsys-audio-ascenario.h b/include/avsys-audio-ascenario.h new file mode 100644 index 0000000..a5f8c24 --- /dev/null +++ b/include/avsys-audio-ascenario.h @@ -0,0 +1,96 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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_ASCENARIO_H__ +#define __AVSYS_AUDIO_ASCENARIO_H__ + +typedef enum { + ASCN_RESET_NONE = 0, + ASCN_RESET_ALL, + ASCN_RESET_PLAYBACK, + ASCN_RESET_CAPTURE, + ASCN_RESET_MODEM, +}AscnResetType; + +#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) + +/* function prototype */ +int avsys_audio_ascn_bulk_set(int * bulk, int bulk_cnt, AscnResetType clear); +int avsys_audio_ascn_single_set(char * str); + +#endif /* __AVSYS_AUDIO_ASCENARIO_H__ */ diff --git a/include/avsys-audio-handle.h b/include/avsys-audio-handle.h new file mode 100644 index 0000000..b05c099 --- /dev/null +++ b/include/avsys-audio-handle.h @@ -0,0 +1,117 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#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__ */ diff --git a/include/avsys-audio-logical-volume.h b/include/avsys-audio-logical-volume.h new file mode 100644 index 0000000..1b4ad52 --- /dev/null +++ b/include/avsys-audio-logical-volume.h @@ -0,0 +1,87 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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__ */ diff --git a/include/avsys-audio-pactrl.h b/include/avsys-audio-pactrl.h new file mode 100644 index 0000000..e446c40 --- /dev/null +++ b/include/avsys-audio-pactrl.h @@ -0,0 +1,72 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include +#include +#include +#include +#include + +/* + * 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__ */ diff --git a/include/avsys-audio-pasimple.h b/include/avsys-audio-pasimple.h new file mode 100644 index 0000000..06fec34 --- /dev/null +++ b/include/avsys-audio-pasimple.h @@ -0,0 +1,57 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include +#include +#include +#include + +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__ */ diff --git a/include/avsys-audio-path.h b/include/avsys-audio-path.h new file mode 100644 index 0000000..2f20b46 --- /dev/null +++ b/include/avsys-audio-path.h @@ -0,0 +1,232 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include + +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__ */ diff --git a/include/avsys-audio-shm.h b/include/avsys-audio-shm.h new file mode 100644 index 0000000..9edde57 --- /dev/null +++ b/include/avsys-audio-shm.h @@ -0,0 +1,44 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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__ */ diff --git a/include/avsys-audio-sync.h b/include/avsys-audio-sync.h new file mode 100644 index 0000000..d55d5a1 --- /dev/null +++ b/include/avsys-audio-sync.h @@ -0,0 +1,47 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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__ */ diff --git a/include/avsys-audio.h b/include/avsys-audio.h new file mode 100644 index 0000000..3853f46 --- /dev/null +++ b/include/avsys-audio.h @@ -0,0 +1,600 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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__ */ diff --git a/include/avsys-common.h b/include/avsys-common.h new file mode 100644 index 0000000..b7ad027 --- /dev/null +++ b/include/avsys-common.h @@ -0,0 +1,80 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include + +#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__ */ diff --git a/include/avsys-debug.h b/include/avsys-debug.h new file mode 100644 index 0000000..6f19daa --- /dev/null +++ b/include/avsys-debug.h @@ -0,0 +1,91 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 +#include +#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__ */ diff --git a/include/avsys-error.h b/include/avsys-error.h new file mode 100644 index 0000000..1be188c --- /dev/null +++ b/include/avsys-error.h @@ -0,0 +1,130 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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__ */ diff --git a/include/avsys-types.h b/include/avsys-types.h new file mode 100644 index 0000000..7e0066d --- /dev/null +++ b/include/avsys-types.h @@ -0,0 +1,41 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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__ */ diff --git a/include/avsystem.h b/include/avsystem.h new file mode 100644 index 0000000..ca1195a --- /dev/null +++ b/include/avsystem.h @@ -0,0 +1,37 @@ +/* + * avsystem + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jonghyuk Choi + * + * 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 __AVSYSTEM_H__ +#define __AVSYSTEM_H__ + +#include +#include +#include + +/** + @mainpage AV System + + @par + This document provides necessary information for developers who are going + to use audio/video functionality. +*/ + +#endif /* __AVSYSTEM_H__ */ diff --git a/init/Makefile.am b/init/Makefile.am new file mode 100644 index 0000000..993ef30 --- /dev/null +++ b/init/Makefile.am @@ -0,0 +1,2 @@ +installinitscriptdir = /etc/rc.d/init.d +installinitscript_SCRIPTS = $(srcdir)/snd_init diff --git a/init/snd_init b/init/snd_init new file mode 100755 index 0000000..f8e75aa --- /dev/null +++ b/init/snd_init @@ -0,0 +1,10 @@ +#!/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 diff --git a/install-sh b/install-sh new file mode 100755 index 0000000..a5897de --- /dev/null +++ b/install-sh @@ -0,0 +1,519 @@ +#!/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: diff --git a/missing b/missing new file mode 100755 index 0000000..1c8ff70 --- /dev/null +++ b/missing @@ -0,0 +1,367 @@ +#! /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 , 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 ." + 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: diff --git a/packaging/avsystem.spec b/packaging/avsystem.spec new file mode 100644 index 0000000..8118229 --- /dev/null +++ b/packaging/avsystem.spec @@ -0,0 +1,73 @@ + +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 diff --git a/pkgconfig-arm/Makefile.am b/pkgconfig-arm/Makefile.am new file mode 100644 index 0000000..e86350a --- /dev/null +++ b/pkgconfig-arm/Makefile.am @@ -0,0 +1,16 @@ +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) + diff --git a/pkgconfig-arm/avsysaudio.pc.in b/pkgconfig-arm/avsysaudio.pc.in new file mode 100644 index 0000000..286d6e7 --- /dev/null +++ b/pkgconfig-arm/avsysaudio.pc.in @@ -0,0 +1,11 @@ +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 diff --git a/pkgconfig-arm/avsystem.pc.in b/pkgconfig-arm/avsystem.pc.in new file mode 100755 index 0000000..d92c42c --- /dev/null +++ b/pkgconfig-arm/avsystem.pc.in @@ -0,0 +1,11 @@ +prefix = @prefix@ +exec_prefix= @exec_prefix@ +libdir = @libdir@ +includedir = @includedir@ + +Name : avsystem +Description : Multimedia Framework AV system Library +Requires : avsysaudio +Version : @VERSION@ +Libs : +Cflags : diff --git a/pkgconfig-arm/avsystem.pc.in.all b/pkgconfig-arm/avsystem.pc.in.all new file mode 100644 index 0000000..56de5e1 --- /dev/null +++ b/pkgconfig-arm/avsystem.pc.in.all @@ -0,0 +1,11 @@ +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 diff --git a/pkgconfig-i386/Makefile.am b/pkgconfig-i386/Makefile.am new file mode 100644 index 0000000..858fb48 --- /dev/null +++ b/pkgconfig-i386/Makefile.am @@ -0,0 +1,15 @@ +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) + diff --git a/pkgconfig-i386/avsysaudio.pc.in b/pkgconfig-i386/avsysaudio.pc.in new file mode 100644 index 0000000..7a5fc6b --- /dev/null +++ b/pkgconfig-i386/avsysaudio.pc.in @@ -0,0 +1,11 @@ +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 diff --git a/pkgconfig-i386/avsystem.pc.in b/pkgconfig-i386/avsystem.pc.in new file mode 100755 index 0000000..d92c42c --- /dev/null +++ b/pkgconfig-i386/avsystem.pc.in @@ -0,0 +1,11 @@ +prefix = @prefix@ +exec_prefix= @exec_prefix@ +libdir = @libdir@ +includedir = @includedir@ + +Name : avsystem +Description : Multimedia Framework AV system Library +Requires : avsysaudio +Version : @VERSION@ +Libs : +Cflags : diff --git a/pkgconfig-i386/avsystem.pc.in.all b/pkgconfig-i386/avsystem.pc.in.all new file mode 100644 index 0000000..56de5e1 --- /dev/null +++ b/pkgconfig-i386/avsystem.pc.in.all @@ -0,0 +1,11 @@ +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 -- 2.7.4