pax_global_header00006660000000000000000000000064132041515440014511gustar00rootroot0000000000000052 comment=f80bced11a0eb6d3726a36274ad4157426239519 adplay-unix-1.8/000077500000000000000000000000001320415154400136145ustar00rootroot00000000000000adplay-unix-1.8/.gitignore000066400000000000000000000003711320415154400156050ustar00rootroot00000000000000aclocal.m4 config.cache config.guess config.log config.status config.sub configure depcomp install-sh Makefile Makefile.in missing mkinstalldirs INSTALL autom4te.cache libtool ltmain.sh *.o stamp-h1 .deps compile src/adplay src/config.h* src/.libs/ adplay-unix-1.8/AUTHORS000066400000000000000000000006611320415154400146670ustar00rootroot00000000000000Main Development: ----------------- Simon Peter Additional Credits: ------------------- Goetz Waschk : - Mandrake Linux packages - Red Hat RPM spec file Mike Gorchak : - QNX Sound Architecture (QSA) output driver - Simple Directmedia Layer (SDL) output driver - QNX packages - QNX qpg file Michael Guntsche : - libao output driver adplay-unix-1.8/COPYING000066400000000000000000000431101320415154400146460ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. adplay-unix-1.8/ChangeLog000066400000000000000000000000711320415154400153640ustar00rootroot00000000000000See https://github.com/adplug/adplay-unix/commits/master adplay-unix-1.8/Makefile.am000066400000000000000000000001261320415154400156470ustar00rootroot00000000000000SUBDIRS = src doc EXTRA_DIST = adplay.spec adplay.qpg AUTOMAKE_OPTIONS = dist-bzip2 adplay-unix-1.8/NEWS000066400000000000000000000027211320415154400143150ustar00rootroot00000000000000This is a brief overview of user-visible changes in adplay. Changes for version 1.8: ------------------------ - Tie in with AdPlug 2.3 release - Support for NukedOPL emulator - Various bug fixes Changes for version 1.7: ------------------------ - Changed default subsong to default subsong of file. - ALSA playback works better with recent ALSA releases - Surround/harmonic synth is now default (use --mono for old behaviour) Changes for version 1.6: ------------------------ - Added the following output mechanisms: - libao: libao driver Changes for version 1.5: ------------------------ - Made compatible with AdPlug 2.0. Changes for version 1.4: ------------------------ - Added the following output mechanisms: - alsa: Advanced Linux Sound Architecture (ALSA) driver Changes for version 1.3: ------------------------ - Disk writer now writes proper files on big endian machines. - AdPlug Database support. - Added verbosity level options. - Added the following output mechanisms: - esound: EsounD (ESD) driver - qsa: QNX Sound Architecture (QSA) driver - sdl: Simple Directmedia Layer (SDL) driver Changes for version 1.2: ------------------------ - Updated man page. - Many build fixes. - Modularized output system. - Added the following output mechanisms: - oss: Open Sound System (OSS) driver - null: Null (silent) output - disk: Disk writer Changes for version 1.1: ------------------------ - Rewrote using GNU autotools. - Wrote man page. - FreeBSD fixes. adplay-unix-1.8/README000066400000000000000000000021751320415154400145010ustar00rootroot00000000000000AdPlay/UNIX - UNIX console-based OPL2 audio player Copyright (C) 2001 - 2017 Simon Peter Description ----------- AdPlay/UNIX is AdPlug's UNIX console-based frontend. AdPlug is a free, universal OPL2 audio playback library. AdPlay/UNIX supports the full range of AdPlug's file format playback features. Despite this, at the moment, only emulated OPL2 output is supported by AdPlay/UNIX, but this on a wide range of output devices. Prerequisites ------------- The following libraries are needed in order to compile this program: Library Version ------- ------- AdPlug >= 1.4, or >= 2.2 for full feature support git --- If you checked out from git, first run: autoreconf --install to generate the build cruft and get the configure script. You need recent versions of autoconf, automake and libtool to do this. Usage ----- Start AdPlay/UNIX with at least one file to be played as parameter. Additional commandline parameters are explained by typing: adplay --help Or by reading the man page. A more detailed doc will follow when i get the time to write one. Any help is greatly appreciated! - Simon Peter adplay-unix-1.8/RELEASE000066400000000000000000000011361320415154400146200ustar00rootroot00000000000000Release procedure ----------------- Before release: * Ensure version numbers are correct in configure.ac, adplay.qpg, doc/adplay.1. They should already be set to the version number of the next release, but may need altering e.g. if an unplanned bugfix release is made. * Update file list in adplug.qpg * Update NEWS with changes since last release * Create new tag: `git tag v1.2.3` and `git push v1.2.3 origin/master` After release: * Update version numbers as above to match the "next" release. This means the git code will always compile as the version number of the next release. adplay-unix-1.8/TODO000066400000000000000000000002261320415154400143040ustar00rootroot00000000000000AdPlay/UNIX To Do List: ----------------------- - Remove warning about Ken's synth not working in surround mode once it has been fixed in AdPlug. adplay-unix-1.8/acinclude.m4000066400000000000000000000453561320415154400160220ustar00rootroot00000000000000# Configure paths for ESD # Manish Singh 98-9-30 # stolen back from Frank Belew # stolen from Manish Singh # Shamelessly stolen from Owen Taylor dnl AM_PATH_ESD([MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]]) dnl Test for ESD, and define ESD_CFLAGS and ESD_LIBS dnl AC_DEFUN([AM_PATH_ESD], [dnl dnl Get the cflags and libraries from the esd-config script dnl AC_ARG_WITH(esd-prefix,[ --with-esd-prefix=PFX Prefix where ESD is installed (optional)], esd_prefix="$withval", esd_prefix="") AC_ARG_WITH(esd-exec-prefix,[ --with-esd-exec-prefix=PFX Exec prefix where ESD is installed (optional)], esd_exec_prefix="$withval", esd_exec_prefix="") AC_ARG_ENABLE(esdtest, [ --disable-esdtest Do not try to compile and run a test ESD program], , enable_esdtest=yes) if test x$esd_exec_prefix != x ; then esd_args="$esd_args --exec-prefix=$esd_exec_prefix" if test x${ESD_CONFIG+set} != xset ; then ESD_CONFIG=$esd_exec_prefix/bin/esd-config fi fi if test x$esd_prefix != x ; then esd_args="$esd_args --prefix=$esd_prefix" if test x${ESD_CONFIG+set} != xset ; then ESD_CONFIG=$esd_prefix/bin/esd-config fi fi AC_PATH_PROG(ESD_CONFIG, esd-config, no) min_esd_version=ifelse([$1], ,0.2.7,$1) AC_MSG_CHECKING(for ESD - version >= $min_esd_version) no_esd="" if test "$ESD_CONFIG" = "no" ; then no_esd=yes else AC_LANG_SAVE AC_LANG_C ESD_CFLAGS=`$ESD_CONFIG $esdconf_args --cflags` ESD_LIBS=`$ESD_CONFIG $esdconf_args --libs` esd_major_version=`$ESD_CONFIG $esd_args --version | \ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'` esd_minor_version=`$ESD_CONFIG $esd_args --version | \ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'` esd_micro_version=`$ESD_CONFIG $esd_config_args --version | \ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'` if test "x$enable_esdtest" = "xyes" ; then ac_save_CFLAGS="$CFLAGS" ac_save_LIBS="$LIBS" CFLAGS="$CFLAGS $ESD_CFLAGS" LIBS="$LIBS $ESD_LIBS" dnl dnl Now check if the installed ESD is sufficiently new. (Also sanity dnl checks the results of esd-config to some extent dnl rm -f conf.esdtest AC_TRY_RUN([ #include #include #include #include char* my_strdup (char *str) { char *new_str; if (str) { new_str = malloc ((strlen (str) + 1) * sizeof(char)); strcpy (new_str, str); } else new_str = NULL; return new_str; } int main () { int major, minor, micro; char *tmp_version; system ("touch conf.esdtest"); /* HP/UX 9 (%@#!) writes to sscanf strings */ tmp_version = my_strdup("$min_esd_version"); if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, µ) != 3) { printf("%s, bad version string\n", "$min_esd_version"); exit(1); } if (($esd_major_version > major) || (($esd_major_version == major) && ($esd_minor_version > minor)) || (($esd_major_version == major) && ($esd_minor_version == minor) && ($esd_micro_version >= micro))) { return 0; } else { printf("\n*** 'esd-config --version' returned %d.%d.%d, but the minimum version\n", $esd_major_version, $esd_minor_version, $esd_micro_version); printf("*** of ESD required is %d.%d.%d. If esd-config is correct, then it is\n", major, minor, micro); printf("*** best to upgrade to the required version.\n"); printf("*** If esd-config was wrong, set the environment variable ESD_CONFIG\n"); printf("*** to point to the correct copy of esd-config, and remove the file\n"); printf("*** config.cache before re-running configure\n"); return 1; } } ],, no_esd=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"]) CFLAGS="$ac_save_CFLAGS" LIBS="$ac_save_LIBS" AC_LANG_RESTORE fi fi if test "x$no_esd" = x ; then AC_MSG_RESULT(yes) ifelse([$2], , :, [$2]) else AC_MSG_RESULT(no) if test "$ESD_CONFIG" = "no" ; then echo "*** The esd-config script installed by ESD could not be found" echo "*** If ESD was installed in PREFIX, make sure PREFIX/bin is in" echo "*** your path, or set the ESD_CONFIG environment variable to the" echo "*** full path to esd-config." else if test -f conf.esdtest ; then : else echo "*** Could not run ESD test program, checking why..." CFLAGS="$CFLAGS $ESD_CFLAGS" LIBS="$LIBS $ESD_LIBS" AC_LANG_SAVE AC_LANG_C AC_TRY_LINK([ #include #include ], [ return 0; ], [ echo "*** The test program compiled, but did not run. This usually means" echo "*** that the run-time linker is not finding ESD or finding the wrong" echo "*** version of ESD. If it is not finding ESD, you'll need to set your" echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point" echo "*** to the installed location Also, make sure you have run ldconfig if that" echo "*** is required on your system" echo "***" echo "*** If you have an old version installed, it is best to remove it, although" echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH"], [ echo "*** The test program failed to compile or link. See the file config.log for the" echo "*** exact error that occured. This usually means ESD was incorrectly installed" echo "*** or that you have moved ESD since it was installed. In the latter case, you" echo "*** may want to edit the esd-config script: $ESD_CONFIG" ]) CFLAGS="$ac_save_CFLAGS" LIBS="$ac_save_LIBS" AC_LANG_RESTORE fi fi ESD_CFLAGS="" ESD_LIBS="" ifelse([$3], , :, [$3]) fi AC_SUBST(ESD_CFLAGS) AC_SUBST(ESD_LIBS) rm -f conf.esdtest ]) dnl AM_ESD_SUPPORTS_MULTIPLE_RECORD([ACTION-IF-SUPPORTS [, ACTION-IF-NOT-SUPPORTS]]) dnl Test, whether esd supports multiple recording clients (version >=0.2.21) dnl AC_DEFUN([AM_ESD_SUPPORTS_MULTIPLE_RECORD], [dnl AC_MSG_NOTICE([whether installed esd version supports multiple recording clients]) ac_save_ESD_CFLAGS="$ESD_CFLAGS" ac_save_ESD_LIBS="$ESD_LIBS" AM_PATH_ESD(0.2.21, ifelse([$1], , [ AM_CONDITIONAL(ESD_SUPPORTS_MULTIPLE_RECORD, true) AC_DEFINE(ESD_SUPPORTS_MULTIPLE_RECORD, 1, [Define if you have esound with support of multiple recording clients.])], [$1]), ifelse([$2], , [AM_CONDITIONAL(ESD_SUPPORTS_MULTIPLE_RECORD, false)], [$2]) if test "x$ac_save_ESD_CFLAGS" != x ; then ESD_CFLAGS="$ac_save_ESD_CFLAGS" fi if test "x$ac_save_ESD_LIBS" != x ; then ESD_LIBS="$ac_save_ESD_LIBS" fi ) ]) dnl Check if we have SDL (sdl-config, header and library) version >= 1.2.0 dnl Extra options: --with-sdl-prefix=PATH and --with-sdl={sdl12,sdl2} dnl Output: dnl SDL_CFLAGS and SDL_LIBS are set and AC_SUBST-ed dnl HAVE_SDL_H is AC_DEFINE-d AC_DEFUN([EXULT_CHECK_SDL],[ exult_backupcppflags="$CPPFLAGS" exult_backupldflags="$LDFLAGS" exult_backuplibs="$LIBS" exult_sdlok=yes AC_ARG_WITH(sdl-prefix,[ --with-sdl-prefix=PFX Prefix where SDL is installed (optional)], sdl_prefix="$withval", sdl_prefix="") AC_ARG_WITH(sdl-exec-prefix,[ --with-sdl-exec-prefix=PFX Exec prefix where SDL is installed (optional)], sdl_exec_prefix="$withval", sdl_exec_prefix="") AC_ARG_WITH(sdl, [ --with-sdl=sdl12,sdl2 Select a specific version of SDL to use (optional)], sdl_ver="$withval", sdl_ver="") dnl First: find sdl-config or sdl2-config exult_extra_path=$prefix/bin:$prefix/usr/bin sdl_args="" if test x$sdl_exec_prefix != x ; then sdl_args="$sdl_args --exec-prefix=$sdl_exec_prefix" exult_extra_path=$sdl_exec_prefix/bin fi if test x$sdl_prefix != x ; then sdl_args="$sdl_args --prefix=$sdl_prefix" exult_extra_path=$sdl_prefix/bin fi if test x"$sdl_ver" = xsdl12 ; then exult_sdl_progs=sdl-config elif test x"$sdl_ver" = xsdl2 ; then exult_sdl_progs=sdl2-config else dnl NB: This line implies we prefer SDL 1.2 to SDL 2.0 exult_sdl_progs="sdl-config sdl2-config" fi AC_PATH_PROGS(SDL_CONFIG, $exult_sdl_progs, no, [$exult_extra_path:$PATH]) if test "$SDL_CONFIG" = "no" ; then exult_sdlok=no else SDL_CFLAGS=`$SDL_CONFIG $sdl_args --cflags` SDL_LIBS=`$SDL_CONFIG $sdl_args --libs` sdl_major_version=`$SDL_CONFIG $sdl_args --version | \ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'` sdl_minor_version=`$SDL_CONFIG $sdl_args --version | \ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'` sdl_patchlevel=`$SDL_CONFIG $sdl_args --version | \ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'` if test $sdl_major_version -eq 1 ; then sdl_ver=sdl12 else sdl_ver=sdl2 fi fi if test x"$sdl_ver" = xsdl2 ; then REQ_MAJOR=2 REQ_MINOR=0 REQ_PATCHLEVEL=0 else REQ_MAJOR=1 REQ_MINOR=2 REQ_PATCHLEVEL=0 fi REQ_VERSION=$REQ_MAJOR.$REQ_MINOR.$REQ_PATCHLEVEL AC_MSG_CHECKING([for SDL - version >= $REQ_VERSION]) dnl Second: include "SDL.h" if test x$exult_sdlok = xyes ; then CPPFLAGS="$CPPFLAGS $SDL_CFLAGS" AC_COMPILE_IFELSE([AC_LANG_SOURCE([[ #include "SDL.h" int main(int argc, char *argv[]) { return 0; } ]],)],sdlh_found=yes,sdlh_found=no) if test x$sdlh_found = xno; then exult_sdlok=no else AC_DEFINE(HAVE_SDL_H, 1, [Define to 1 if you have the "SDL.h" header file]) fi fi dnl Next: version check (cross-compile-friendly idea borrowed from autoconf) dnl (First check version reported by sdl-config, then confirm dnl the version in SDL.h matches it) if test x$exult_sdlok = xyes ; then if test ! \( \( $sdl_major_version -gt $REQ_MAJOR \) -o \( \( $sdl_major_version -eq $REQ_MAJOR \) -a \( \( $sdl_minor_version -gt $REQ_MINOR \) -o \( \( $sdl_minor_version -eq $REQ_MINOR \) -a \( $sdl_patchlevel -gt $REQ_PATCHLEVEL \) \) \) \) \); then exult_sdlok="no, version < $REQ_VERSION found" else AC_COMPILE_IFELSE([AC_LANG_SOURCE([[ #include "SDL.h" int main(int argc, char *argv[]) { static int test_array[1-2*!(SDL_MAJOR_VERSION==$sdl_major_version&&SDL_MINOR_VERSION==$sdl_minor_version&&SDL_PATCHLEVEL==$sdl_patchlevel)]; test_array[0] = 0; return 0; } ]])],,[[exult_sdlok="no, version of SDL.h doesn't match that of sdl-config"]]) fi fi dnl Next: try linking if test "x$exult_sdlok" = xyes; then LIBS="$LIBS $SDL_LIBS" AC_LINK_IFELSE([AC_LANG_SOURCE([[ #include "SDL.h" int main(int argc, char* argv[]) { SDL_Init(0); return 0; } ]])],sdllinkok=yes,sdllinkok=no) if test x$sdllinkok = xno; then exult_sdlok=no fi fi AC_MSG_RESULT($exult_sdlok) LDFLAGS="$exult_backupldflags" CPPFLAGS="$exult_backupcppflags" LIBS="$exult_backuplibs" if test "x$exult_sdlok" = xyes; then AC_SUBST(SDL_CFLAGS) AC_SUBST(SDL_LIBS) ifelse([$1], , :, [$1]) else ifelse([$2], , :, [$2]) fi ]); dnl Configure Paths for Alsa dnl Some modifications by Richard Boulton dnl Christopher Lansdown dnl Jaroslav Kysela dnl Last modification: alsa.m4,v 1.24 2004/09/15 18:48:07 tiwai Exp dnl AM_PATH_ALSA([MINIMUM-VERSION [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]]) dnl Test for libasound, and define ALSA_CFLAGS and ALSA_LIBS as appropriate. dnl enables arguments --with-alsa-prefix= dnl --with-alsa-enc-prefix= dnl --disable-alsatest dnl dnl For backwards compatibility, if ACTION_IF_NOT_FOUND is not specified, dnl and the alsa libraries are not found, a fatal AC_MSG_ERROR() will result. dnl AC_DEFUN([AM_PATH_ALSA], [dnl Save the original CFLAGS, LDFLAGS, and LIBS alsa_save_CFLAGS="$CFLAGS" alsa_save_LDFLAGS="$LDFLAGS" alsa_save_LIBS="$LIBS" alsa_found=yes dnl dnl Get the cflags and libraries for alsa dnl AC_ARG_WITH(alsa-prefix, [ --with-alsa-prefix=PFX Prefix where Alsa library is installed(optional)], [alsa_prefix="$withval"], [alsa_prefix=""]) AC_ARG_WITH(alsa-inc-prefix, [ --with-alsa-inc-prefix=PFX Prefix where include libraries are (optional)], [alsa_inc_prefix="$withval"], [alsa_inc_prefix=""]) dnl FIXME: this is not yet implemented AC_ARG_ENABLE(alsatest, [ --disable-alsatest Do not try to compile and run a test Alsa program], [enable_alsatest="$enableval"], [enable_alsatest=yes]) dnl Add any special include directories AC_MSG_CHECKING(for ALSA CFLAGS) if test "$alsa_inc_prefix" != "" ; then ALSA_CFLAGS="$ALSA_CFLAGS -I$alsa_inc_prefix" CFLAGS="$CFLAGS -I$alsa_inc_prefix" fi AC_MSG_RESULT($ALSA_CFLAGS) CFLAGS="$alsa_save_CFLAGS" dnl add any special lib dirs AC_MSG_CHECKING(for ALSA LDFLAGS) if test "$alsa_prefix" != "" ; then ALSA_LIBS="$ALSA_LIBS -L$alsa_prefix" LDFLAGS="$LDFLAGS $ALSA_LIBS" fi dnl add the alsa library ALSA_LIBS="$ALSA_LIBS -lasound -lm -ldl -lpthread" LIBS="$ALSA_LIBS $LIBS" AC_MSG_RESULT($ALSA_LIBS) dnl Check for a working version of libasound that is of the right version. min_alsa_version=ifelse([$1], ,0.1.1,$1) AC_MSG_CHECKING(for libasound headers version >= $min_alsa_version) no_alsa="" alsa_min_major_version=`echo $min_alsa_version | \ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'` alsa_min_minor_version=`echo $min_alsa_version | \ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'` alsa_min_micro_version=`echo $min_alsa_version | \ sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'` AC_LANG_SAVE AC_LANG_C AC_TRY_COMPILE([ #include ], [ /* ensure backward compatibility */ #if !defined(SND_LIB_MAJOR) && defined(SOUNDLIB_VERSION_MAJOR) #define SND_LIB_MAJOR SOUNDLIB_VERSION_MAJOR #endif #if !defined(SND_LIB_MINOR) && defined(SOUNDLIB_VERSION_MINOR) #define SND_LIB_MINOR SOUNDLIB_VERSION_MINOR #endif #if !defined(SND_LIB_SUBMINOR) && defined(SOUNDLIB_VERSION_SUBMINOR) #define SND_LIB_SUBMINOR SOUNDLIB_VERSION_SUBMINOR #endif # if(SND_LIB_MAJOR > $alsa_min_major_version) exit(0); # else # if(SND_LIB_MAJOR < $alsa_min_major_version) # error not present # endif # if(SND_LIB_MINOR > $alsa_min_minor_version) exit(0); # else # if(SND_LIB_MINOR < $alsa_min_minor_version) # error not present # endif # if(SND_LIB_SUBMINOR < $alsa_min_micro_version) # error not present # endif # endif # endif exit(0); ], [AC_MSG_RESULT(found.)], [AC_MSG_RESULT(not present.) ifelse([$3], , [AC_MSG_ERROR(Sufficiently new version of libasound not found.)]) alsa_found=no] ) AC_LANG_RESTORE dnl Now that we know that we have the right version, let's see if we have the library and not just the headers. if test "x$enable_alsatest" = "xyes"; then AC_CHECK_LIB([asound], [snd_ctl_open],, [ifelse([$3], , [AC_MSG_ERROR(No linkable libasound was found.)]) alsa_found=no] ) fi LDFLAGS="$alsa_save_LDFLAGS" LIBS="$alsa_save_LIBS" if test "x$alsa_found" = "xyes" ; then ifelse([$2], , :, [$2]) else ALSA_CFLAGS="" ALSA_LIBS="" ifelse([$3], , :, [$3]) fi dnl That should be it. Now just export out symbols: AC_SUBST(ALSA_CFLAGS) AC_SUBST(ALSA_LIBS) ]) # ao.m4 # Configure paths for libao # Jack Moffitt 10-21-2000 # Shamelessly stolen from Owen Taylor and Manish Singh dnl XIPH_PATH_AO([ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]) dnl Test for libao, and define AO_CFLAGS and AO_LIBS dnl AC_DEFUN([XIPH_PATH_AO], [dnl dnl Get the cflags and libraries dnl AC_ARG_WITH(ao,[ --with-ao=PFX Prefix where libao is installed (optional)], ao_prefix="$withval", ao_prefix="") AC_ARG_WITH(ao-libraries,[ --with-ao-libraries=DIR Directory where libao library is installed (optional)], ao_libraries="$withval", ao_libraries="") AC_ARG_WITH(ao-includes,[ --with-ao-includes=DIR Directory where libao header files are installed (optional)], ao_includes="$withval", ao_includes="") AC_ARG_ENABLE(aotest, [ --disable-aotest Do not try to compile and run a test ao program],, enable_aotest=yes) if test "x$ao_libraries" != "x" ; then AO_LIBS="-L$ao_libraries" elif test "x$ao_prefix" != "x"; then AO_LIBS="-L$ao_prefix/lib" elif test "x$prefix" != "xNONE"; then AO_LIBS="-L$prefix/lib" fi if test "x$ao_includes" != "x" ; then AO_CFLAGS="-I$ao_includes" elif test "x$ao_prefix" != "x"; then AO_CFLAGS="-I$ao_prefix/include" elif test "x$prefix" != "xNONE"; then AO_CFLAGS="-I$prefix/include" fi # see where dl* and friends live AC_CHECK_FUNCS(dlopen, [AO_DL_LIBS=""], [ AC_CHECK_LIB(dl, dlopen, [AO_DL_LIBS="-ldl"], [ AC_MSG_WARN([could not find dlopen() needed by libao sound drivers your system may not be supported.]) ]) ]) AO_LIBS="$AO_LIBS -lao $AO_DL_LIBS" AC_MSG_CHECKING(for ao) no_ao="" if test "x$enable_aotest" = "xyes" ; then ac_save_CFLAGS="$CFLAGS" ac_save_LIBS="$LIBS" CFLAGS="$CFLAGS $AO_CFLAGS" LIBS="$LIBS $AO_LIBS" dnl dnl Now check if the installed ao is sufficiently new. dnl rm -f conf.aotest AC_TRY_RUN([ #include #include #include #include int main () { system("touch conf.aotest"); return 0; } ],, no_ao=yes,[echo $ac_n "cross compiling; assumed OK... $ac_c"]) CFLAGS="$ac_save_CFLAGS" LIBS="$ac_save_LIBS" fi if test "x$no_ao" = "x" ; then AC_MSG_RESULT(yes) ifelse([$1], , :, [$1]) else AC_MSG_RESULT(no) if test -f conf.aotest ; then : else echo "*** Could not run ao test program, checking why..." CFLAGS="$CFLAGS $AO_CFLAGS" LIBS="$LIBS $AO_LIBS" AC_TRY_LINK([ #include #include ], [ return 0; ], [ echo "*** The test program compiled, but did not run. This usually means" echo "*** that the run-time linker is not finding ao or finding the wrong" echo "*** version of ao. If it is not finding ao, you'll need to set your" echo "*** LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf to point" echo "*** to the installed location Also, make sure you have run ldconfig if that" echo "*** is required on your system" echo "***" echo "*** If you have an old version installed, it is best to remove it, although" echo "*** you may also be able to get things to work by modifying LD_LIBRARY_PATH"], [ echo "*** The test program failed to compile or link. See the file config.log for the" echo "*** exact error that occured. This usually means ao was incorrectly installed" echo "*** or that you have moved ao since it was installed." ]) CFLAGS="$ac_save_CFLAGS" LIBS="$ac_save_LIBS" fi AO_CFLAGS="" AO_LIBS="" ifelse([$2], , :, [$2]) fi AC_SUBST(AO_CFLAGS) AC_SUBST(AO_LIBS) rm -f conf.aotest ]) adplay-unix-1.8/adplay.qpg000066400000000000000000000116061320415154400156030ustar00rootroot00000000000000 QNX.ORG.RU Community QNX.ORG.RU Team Mike Gorchak mike@malva.ua Application adplay 1 http://qnx.org.ru/repository 1.01 adplay adplay dn.tlp@gmx.net Public public http://adplug.github.io dn.tlp@gmx.net Simon Peter http://adplug.github.io dn.tlp@gmx.net AdPlay/UNIX is AdPlug's UNIX console-based frontend. AdPlug is a free, universal OPL2 audio playback library. AdPlay/UNIX supports the full range of AdPlug's file format playback features. AdPlay/UNIX is AdPlug's UNIX console-based frontend. AdPlug is a free, universal OPL2 audio playback library. AdPlay/UNIX supports the full range of AdPlug's file format playback features. Despite this, at the moment, only emulated OPL2 output is supported by AdPlay/UNIX, but this on a wide range of output devices. http://adplug.github.io 1.8 Medium Stable 1 GNU General Public License Multimedia/Music and Audio/Audio Media Players FM, Tracker, Music, Adlib, OPL2, Player Console User repdata://LicenseUrl/COPYING adplay-unix-1.8/adplay.spec000066400000000000000000000022371320415154400157460ustar00rootroot00000000000000%define name adplay %define version 1.7 %define release 1 Summary: AdLib music player for the command line Name: %{name} Version: %{version} Release: %{release} Source0: %{name}-%{version}.tar.bz2 License: GPL Group: Applications/Multimedia URL: http://adplug.github.io BuildRoot: %{_tmppath}/%{name}-buildroot Prefix: %{_prefix} BuildRequires: adplug-devel >= 1.4 Requires: adplug >= 1.4 %description AdPlay/UNIX is AdPlug's UNIX console-based frontend. AdPlug is a free, universal OPL2 audio playback library. AdPlay/UNIX supports the full range of AdPlug's file format playback features. Despite this, at the moment, only emulated OPL2 output is supported by AdPlay/UNIX, but this on a wide range of output devices. %prep %setup -q %build %configure make %install rm -rf $RPM_BUILD_ROOT %makeinstall %clean rm -rf $RPM_BUILD_ROOT %files %defattr(-,root,root) %doc README NEWS TODO AUTHORS ChangeLog %_bindir/adplay %_mandir/man1/adplay.1* %changelog * Tue Mar 4 2003 Götz Waschk 1.3-1 - requires new adplug libraries - fix group for RH standard - new version * Tue Nov 26 2002 Götz Waschk 1.2-1 - initial package adplay-unix-1.8/configure.ac000066400000000000000000000166321320415154400161120ustar00rootroot00000000000000# Tell autoconf we're compiling a C++ program using automake and libtool. AC_INIT(adplay,1.8) AC_CONFIG_SRCDIR(src/adplay.cc) AC_CONFIG_FILES(Makefile src/Makefile doc/Makefile) AC_CANONICAL_TARGET AM_INIT_AUTOMAKE AM_CONFIG_HEADER(src/config.h) AM_PROG_LIBTOOL AC_LANG(C++) # Check if we got a sane C/C++ compilation environment. AC_PROG_INSTALL AC_PROG_CC AC_PROG_CXX AC_PROG_CPP AC_PROG_CXXCPP # Nothing works without these libraries... AC_CHECK_LIB(stdc++,main,,AC_MSG_ERROR([libstdc++ not installed])) PKG_CHECK_MODULES([adplug], [adplug >= 2.0],,[ AC_MSG_WARN([You seem to be using a version of AdPlug prior to 2.0. \ I will try to do the old-style library search for which i cannot check \ versions. Please bear in mind that i am requiring at least version 1.4.]) AC_CHECK_LIB(adplug,main,,AC_MSG_ERROR([*** AdPlug not installed ***]))]) # Check if getopt header is installed on this system AC_CHECK_HEADERS([getopt.h], , AC_SUBST(GETOPT_SOURCES, [getopt.c getopt1.c getopt.h])) # Save compiler flags and set up for compiling test programs oldlibs="$LIBS" oldcppflags="$CPPFLAGS" LIBS="$LDFLAGS $adplug_LIBS" CPPFLAGS="$CPPFLAGS $adplug_CFLAGS" # Check if AdPlug is installed and linked correctly AC_MSG_CHECKING([whether AdPlug is linked correctly]) AC_LINK_IFELSE([AC_LANG_PROGRAM([#include class Testplayer: public CPlayer { public: Testplayer(): CPlayer(NULL) {} bool load(const std::string &f, const CFileProvider &fp) { return false; } bool update() { return false; } float getrefresh() { return 0; } std::string gettype() { return std::string(); } void rewind(int s) {} }; Testplayer p;], [p.getrefresh();])], AC_MSG_RESULT([yes]), AC_MSG_RESULT([no]); AC_MSG_ERROR([Unable to compile a program using AdPlug. Please check to ensure AdPlug is installed correctly.]) ) # Check if AdPlug supports the new getsubsong() method AC_MSG_CHECKING([whether AdPlug supports the getsubsong() method]) AC_LINK_IFELSE([AC_LANG_PROGRAM([#include class Testplayer: public CPlayer { public: Testplayer(): CPlayer(NULL) {} bool load(const std::string &f, const CFileProvider &fp) { return false; } bool update() { return false; } float getrefresh() { return 0; } std::string gettype() { return std::string(); } void rewind(int s) {} }; Testplayer p;], [p.getsubsong();])], AC_DEFINE(HAVE_ADPLUG_GETSUBSONG,, [Defined if AdPlug supports the getsubsong() method]) AC_MSG_RESULT([yes]), AC_MSG_RESULT([no])) # Check if AdPlug supports the new surround/harmonic synth AC_MSG_CHECKING([whether AdPlug supports the surround/harmonic synth]) AC_LINK_IFELSE([AC_LANG_PROGRAM([#include ], [CSurroundopl *dummy;])], AC_DEFINE(HAVE_ADPLUG_SURROUND,, [Defined if AdPlug supports the surround/harmonic synth]) AC_MSG_RESULT([yes]), AC_MSG_RESULT([no - AdPlug >= 2.2 required])) # Check if AdPlug supports NukedOPL AC_MSG_CHECKING([whether AdPlug supports the NukedOPL synth]) AC_LINK_IFELSE([AC_LANG_PROGRAM([#include ], [CNemuopl *dummy;])], AC_DEFINE(HAVE_ADPLUG_NUKEDOPL,, [Defined if AdPlug supports the NukedOPL synth]) AC_MSG_RESULT([yes]), AC_MSG_RESULT([no - AdPlug >= 2.3 required])) # Restore flags after compiling test programs LIBS="$oldlibs" CPPFLAGS="$oldcppflags" ##### Output mechanism checks ##### # These checks enable or disable certain output mechanisms, # depending on system facilities and user requests. # Define user option arguments AC_ARG_ENABLE([output-oss],AC_HELP_STRING([--disable-output-oss],[Disable OSS output])) AC_ARG_ENABLE([output-null],AC_HELP_STRING([--disable-output-null],[Disable null output])) AC_ARG_ENABLE([output-disk],AC_HELP_STRING([--disable-output-disk],[Disable disk writer])) AC_ARG_ENABLE([output-esound],AC_HELP_STRING([--disable-output-esound],[Disable EsounD output])) AC_ARG_ENABLE([output-qsa],AC_HELP_STRING([--disable-output-qsa],[Disable QSA output])) AC_ARG_ENABLE([output-sdl],AC_HELP_STRING([--disable-output-sdl],[Disable SDL output])) AC_ARG_ENABLE([output-alsa],AC_HELP_STRING([--disable-output-alsa],[Disable ALSA output])) AC_ARG_ENABLE([output-ao],AC_HELP_STRING([--disable-output-ao],[Disable AO output])) # Check if we can compile the enabled drivers: # OSS driver if test ${enable_output_oss:=yes} = yes; then AC_MSG_CHECKING([for OSS headers]) AC_TRY_CPP([ #include #include #include ],[ AC_DEFINE(DRIVER_OSS,1,[Build OSS driver]) drivers=$drivers' oss.$(OBJEXT)' AC_MSG_RESULT([found]) ],[ enable_output_oss=no AC_MSG_RESULT([not found -- OSS output disabled]) ]) fi # AO output if test ${enable_output_ao:=yes} = yes; then XIPH_PATH_AO(AC_DEFINE(DRIVER_AO,1,[Build AO output]) drivers=$drivers' ao.${OBJEXT}', enable_output_ao=no AC_MSG_RESULT([*** AO (libao) not installed ***])) fi # Null output if test ${enable_output_null:=yes} = yes; then AC_DEFINE(DRIVER_NULL,1,[Build null output]) fi # Disk writer if test ${enable_output_disk:=yes} = yes; then AC_DEFINE(DRIVER_DISK,1,[Build disk writer]) drivers=$drivers' disk.$(OBJEXT)' fi # EsounD output if test ${enable_output_esound:=yes} = yes; then AM_PATH_ESD(0.2.8, AC_DEFINE(DRIVER_ESOUND,1,[Build EsounD output]) drivers=$drivers' esound.$(OBJEXT)', enable_output_esound=no AC_MSG_RESULT([*** EsounD (libesd) >= 0.2.8 not installed ***])) fi # QSA driver if test ${enable_output_qsa:=yes} = yes; then AC_MSG_CHECKING([for QSA headers]) AC_TRY_COMPILE([ #include #include ],[ int arg=snd_pcm_open_preferred(NULL, NULL, NULL, 0); ],[ have_qsa=yes ]) if test x$have_qsa = xyes; then AC_DEFINE(DRIVER_QSA,1,[Build QSA driver]) drivers=$drivers' qsa.$(OBJEXT)' QSA_LIBS=-lasound AC_SUBST(QSA_LIBS) AC_MSG_RESULT([found]) else enable_output_qsa=no QSA_LIBS="" AC_SUBST(QSA_LIBS) AC_MSG_RESULT([not found -- QSA output disabled]) fi fi # SDL output if test ${enable_output_sdl:=yes} = yes; then AC_LANG_PUSH(C) EXULT_CHECK_SDL( AC_DEFINE(DRIVER_SDL,1,[Build SDL output]) drivers=$drivers' sdl.$(OBJEXT)', enable_output_sdl=no AC_MSG_RESULT([*** SDL (libsdl) >= 1.2.0 not installed ***])) AC_LANG_POP(C) fi # ALSA output if test ${enable_output_alsa:=yes} = yes; then AM_PATH_ALSA(0.9.1, AC_DEFINE(DRIVER_ALSA,1,[Build ALSA output]) drivers=$drivers' alsa.${OBJEXT}', enable_output_alsa=no AC_MSG_RESULT([*** ALSA (libasound) >= 0.9.1 not installed ***])) fi AC_SUBST([drivers]) AC_OUTPUT # Display user informative configuration output echo "" echo "Configuration:" echo "Install path: ${prefix}" echo "" echo "Build output mechanisms:" echo "OSS output (oss): ${enable_output_oss}" echo "Null output (null): ${enable_output_null}" echo "Disk writer (disk): ${enable_output_disk}" echo "EsounD output (esound): ${enable_output_esound}" echo "QSA output (qsa): ${enable_output_qsa}" echo "SDL output (sdl): ${enable_output_sdl}" echo "ALSA output (alsa): ${enable_output_alsa}" echo "Libao output (ao): ${enable_output_ao}" if test "x$exult_sdlok" = xyes; then echo "" echo "SDL version: `$SDL_CONFIG $sdl_args --version`" fi adplay-unix-1.8/doc/000077500000000000000000000000001320415154400143615ustar00rootroot00000000000000adplay-unix-1.8/doc/Makefile.am000066400000000000000000000000561320415154400164160ustar00rootroot00000000000000man_MANS = adplay.1 EXTRA_DIST = $(man_MANS) adplay-unix-1.8/doc/adplay.1000066400000000000000000000141341320415154400157200ustar00rootroot00000000000000.\" -*- nroff -*- .\" adplay 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 of the License, 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; see the file COPYING. If not, write to .\" the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. .\" .TH ADPLAY 1 "November 19, 2017" "AdPlay/UNIX 1.8" "User Commands" .SH NAME adplay \- AdPlay/UNIX console-based OPL2 audio player .SH SYNOPSIS .B adplay .RI "[OPTION]... FILE..." .SH DESCRIPTION AdPlay/UNIX is AdPlug's UNIX console-based frontend. It tries to play back all given FILEs, using one of many available output mechanisms. .PP AdPlay/UNIX plays endlessly, if only one file is given. With multiple files, it plays them in a sequence and exits after the last file. The same can also be accomplished with only one file, by using the \fB-o\fP option. When using the disk writer, \fB-o\fP is implied. .SH EXIT STATUS \fBadplay\fP returns 0 on successful operation. 1 is returned otherwise. .SH OUTPUT MECHANISMS .PP AdPlay/UNIX can play back using many different output mechanisms, which can be selected with the \fB-O\fP argument. The availability of a method depends on compile-time settings. Available methods are printed out after the help text, displayed with \fB--help\fP. .PP Next is a brief description of all output mechanisms, following their abbreviations: .SS oss -- Open Sound System (OSS) driver .PP This output method is available on most Linux and other UNIX systems. .SS null -- Total silence .PP Discards anything sent to it. It can be useful for testing purposes. .SS disk -- Disk writer .PP Writes its output to a file in Microsoft RIFF WAVE format. .SS esound -- EsounD output .PP Creates a socket connection to an EsounD server and streams the audio to it. .SS qsa -- QNX Sound Architecture (QSA) driver .PP Uses the QNX system's standard output method. .SS sdl -- Simple Directmedia Layer (SDL) driver .PP Uses the SDL library for sound output. The library has a broader platform support than any of the other output methods. Thus, it could be useful on some exotic systems. .SS alsa -- Advanced Linux Sound Architecture (ALSA) driver .PP Uses the standard output method on newer Linux systems. .SS ao -- libao driver .PP Libao is a cross-platform audio library with very broad platform support. Might be useful on systems, where SDL is not available, and generally to do tricky things. .SH OPTIONS .PP The order of the option commandline parameters is not important, except for the \fB-d\fP option, which always has to be specified after an \fB-O\fP option. .SS "Output selection:" .TP .B -O, --output=OUTPUT Specify output mechanism. Available mechanisms depend on compilation settings and are printed on \fB--help\fP output. A reasonable default is automatically selected, based on the availability of the output mechanisms. .SS "OSS driver (oss) specific:" .TP .B -d --device=FILE Set sound output device file to FILE. This is \fB/dev/dsp\fP by default. .SS "Disk writer (disk) specific:" .TP .B -d --device=FILE Write sound data to FILE. The data is written in Microsoft RIFF WAVE format (little-endian). You can specify a single '-' to write to stdout instead. This option has no default and must be specified when the disk writer is to be used! .SS "EsounD output (esound) specific:" .TP .B -d --device=URL Connect to "hostname:port" combination in URL. Example: "myhost.sound.net:1234". The default is "localhost:16001". .SS "ALSA driver (alsa) specific:" .TP .B -d --device=DEVICE Set sound output device to DEVICE. This is \fBplughw:0,0\fP by default. .SS "Playback quality:" .TP .B -8, --8bit Use only 8-bit samples for playback. .TP .B --16bit Use only 16-bit samples for playback (default). .TP .B -f, --freq=FREQ Set playback frequency to FREQ, in Hz. This is 44100Hz by default. .TP .B --stereo Use only stereo samples for playback. The sound stream is just doubled, no further audio processing is done. This option is pretty useless unless you have very obscure audio hardware that only accepts stereo streams. AdPlug only generates mono streams because the OPL2 only generates mono sound. .TP .B --mono Use only mono samples for playback (default if AdPlug <= 2.1.) .TP .B --surround Use only stereo samples for playback, but generate them from two mono OPL2 chips. One OPL2 chip is very slightly transposed to produce a pleasant harmonic/surround sound effect (default if AdPlug >= 2.2.) .TP .B -b --buffer=SIZE Set sound buffer size to SIZE samples. If you notice sound skipping with the default setting, try a greater buffer size. Note that this is measured in samples, not bytes! This is 2048 samples by default. Only the OSS, SDL, ALSA and libao output drivers support this option. .SS "Informative output:" .TP .B -i --instruments Display instrument names (if available). .TP .B -r --realtime Display realtime playback information, while playing. This will display a one-line status bar, containing essential playback information. .TP .B -m --message Display the song message (if available). .SS "Playback:" .TP .B -s --subsong=N Play subsong number N, instead of the default subsong of the file. Only useful for file formats that support multiple subsongs. .TP .B -o --once Play just once, don't loop. This will exit \fBadplay\fP after the song ended. This is the default when multiple \fBFILEs\fP are given. .SS "Miscellaneous:" .TP .B -D, --database=FILE Additionally use database file FILE. This option may be specified multiple times. Each database file is additionally merged with the others, creating one large database on the fly. .TP .B -q, --quiet Be more quiet. .TP .B -v, --verbose Be more verbose. .TP .B -h, --help Show summary of options. .TP .B -V, --version Show version of program. .SH AUTHOR Simon Peter adplay-unix-1.8/src/000077500000000000000000000000001320415154400144035ustar00rootroot00000000000000adplay-unix-1.8/src/Makefile.am000066400000000000000000000011061320415154400164350ustar00rootroot00000000000000bin_PROGRAMS = adplay adplay_SOURCES = adplay.cc output.cc output.h players.h defines.h EXTRA_adplay_SOURCES = oss.cc oss.h null.h disk.cc disk.h esound.cc esound.h \ qsa.cc qsa.h sdl.cc sdl.h alsa.cc alsa.h ao.cc ao.h getopt.c \ getopt1.c getopt.h adplay_LDADD = $(drivers) $(adplug_LIBS) @ESD_LIBS@ @QSA_LIBS@ @SDL_LIBS@ \ @ALSA_LIBS@ @AO_LIBS@ $(GETOPT_SOURCES) adplay_DEPENDENCIES = $(drivers) $(GETOPT_SOURCES) adplug_data_dir = $(sharedstatedir)/adplug AM_CPPFLAGS = $(adplug_CFLAGS) @ESD_CFLAGS@ @SDL_CFLAGS@ @ALSA_CFLAGS@ \ -DADPLUG_DATA_DIR=\"$(adplug_data_dir)\" adplay-unix-1.8/src/adplay.cc000066400000000000000000000377251320415154400162020ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001 - 2017 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include #include #include #include #include #include /* * Apple (OS X) and Sun systems declare getopt in unistd.h, other systems * (Linux) use getopt.h. */ #if defined (__APPLE__) || (defined(__SVR4) && defined(__sun)) # include #else # ifdef HAVE_GETOPT_H # include # else # include "getopt.h" // ALSA now includes the system-wide getopt under Linux, so stop this # define _GETOPT_POSIX_H 1 # endif #endif #include "defines.h" #ifdef HAVE_ADPLUG_NUKEDOPL #include #endif #ifdef HAVE_ADPLUG_SURROUND #include #endif #include "output.h" #include "players.h" /***** Defines *****/ // Default file name of AdPlug's database file #define ADPLUGDB_FILE "adplug.db" // Default AdPlug user's configuration subdirectory #define ADPLUG_CONFDIR ".adplug" // Default path to AdPlug's system-wide database file #ifdef ADPLUG_DATA_DIR # define ADPLUGDB_PATH ADPLUG_DATA_DIR "/" ADPLUGDB_FILE #else # define ADPLUGDB_PATH ADPLUGDB_FILE #endif /***** Typedefs *****/ typedef enum { Emu_Satoh, Emu_Ken, Emu_Woody, #ifdef HAVE_ADPLUG_NUKEDOPL Emu_Nuked, #endif } EmuType; /***** Global variables *****/ static const char *program_name; static Player *player = 0; // global player object static CAdPlugDatabase mydb; static Copl *opl = 0; /***** Configuration (and defaults) *****/ static struct { int buf_size, freq, channels, bits, harmonic, message_level; unsigned int subsong; const char *device; char *userdb; bool endless, showinsts, songinfo, songmessage; EmuType emutype; Outputs output; } cfg = { 2048, 44100, #ifdef HAVE_ADPLUG_SURROUND 2, 16, 1, // Default to surround if available #else 1, 16, 0, // Else default to mono (until stereo w/ single OPL is fixed) #endif MSG_NOTE, (unsigned int)-1, NULL, NULL, true, false, false, false, Emu_Woody, DEFAULT_DRIVER }; /***** Global functions *****/ void message(int level, const char *fmt, ...) { va_list argptr; if(cfg.message_level < level) return; fprintf(stderr, "%s: ", program_name); va_start(argptr, fmt); vfprintf(stderr, fmt, argptr); va_end(argptr); fprintf(stderr, "\n"); } /***** Local functions *****/ static void usage() /* Print usage information. */ { printf("Usage: %s [OPTION]... FILE...\n\n" "Output selection:\n" " -e, --emulator=EMULATOR specify emulator to use\n" " -O, --output=OUTPUT specify output mechanism\n\n" "OSS driver (oss) specific:\n" " -d, --device=FILE set sound device file to FILE\n" " -b, --buffer=SIZE set output buffer size to SIZE\n\n" "Disk writer (disk) specific:\n" " -d, --device=FILE output to FILE ('-' is stdout)\n\n" "EsounD driver (esound) specific:\n" " -d, --device=URL URL to EsounD server host (hostname:port)\n\n" "SDL driver (sdl) specific:\n" " -b, --buffer=SIZE set output buffer size to SIZE\n\n" "ALSA driver (alsa) specific:\n" " -d, --device=DEVICE set sound device to DEVICE\n" " -b, --buffer=SIZE set output buffer size to SIZE\n\n" "Playback quality:\n" " -8, --8bit 8-bit sample quality\n" " --16bit 16-bit sample quality\n" " -f, --freq=FREQ set sample frequency to FREQ\n" " --surround stereo/surround stream\n" " --stereo stereo stream\n" " --mono mono stream\n\n" "Informative output:\n" " -i, --instruments display instrument names\n" " -r, --realtime display realtime song info\n" " -m, --message display song message\n\n" "Playback:\n" " -s, --subsong=N play subsong number N\n" " -o, --once play only once, don't loop\n\n" "Generic:\n" " -D, --database=FILE additionally use database file FILE\n" " -q, --quiet be more quiet\n" " -v, --verbose be more verbose\n" " -h, --help display this help and exit\n" " -V, --version output version information and exit\n\n", program_name); // Print list of available output mechanisms printf("Available emulators: satoh ken woody "); #ifdef HAVE_ADPLUG_NUKEDOPL printf("nuked"); #endif printf("\n"); printf("Available output mechanisms: " #ifdef DRIVER_OSS "oss " #endif #ifdef DRIVER_NULL "null " #endif #ifdef DRIVER_DISK "disk " #endif #ifdef DRIVER_ESOUND "esound " #endif #ifdef DRIVER_QSA "qsa " #endif #ifdef DRIVER_SDL "sdl " #endif #ifdef DRIVER_AO "ao " #endif #ifdef DRIVER_ALSA "alsa " #endif "\n"); } static int decode_switches(int argc, char **argv) /* * Set all the option flags according to the switches specified. * Return the index of the first non-option argument. */ { int c; struct option const long_options[] = { {"8bit", no_argument, NULL, '8'}, // 8-bit replay {"16bit", no_argument, NULL, '1'}, // 16-bit replay {"freq", required_argument, NULL, 'f'}, // set frequency {"surround", no_argument, NULL, '4'}, // stereo/harmonic replay {"stereo", no_argument, NULL, '3'}, // stereo replay {"mono", no_argument, NULL, '2'}, // mono replay {"buffer", required_argument, NULL, 'b'}, // buffer size {"device", required_argument, NULL, 'd'}, // device file {"instruments", no_argument, NULL, 'i'}, // show instruments {"realtime", no_argument, NULL, 'r'}, // realtime song info {"message", no_argument, NULL, 'm'}, // song message {"subsong", no_argument, NULL, 's'}, // play subsong {"once", no_argument, NULL, 'o'}, // don't loop {"help", no_argument, NULL, 'h'}, // display help {"version", no_argument, NULL, 'V'}, // version information {"emulator", required_argument, NULL, 'e'}, // emulator to use {"output", required_argument, NULL, 'O'}, // output mechanism {"database", required_argument, NULL, 'D'}, // different database {"quiet", no_argument, NULL, 'q'}, // be more quiet {"verbose", no_argument, NULL, 'v'}, // be more verbose {NULL, 0, NULL, 0} // end of options }; while ((c = getopt_long(argc, argv, "8f:b:d:irms:ohVe:O:D:qv", long_options, (int *)0)) != EOF) { switch (c) { case '8': cfg.bits = 8; break; case '1': cfg.bits = 16; break; case 'f': cfg.freq = atoi(optarg); break; case '4': cfg.channels = 2; cfg.harmonic = 1; break; case '3': cfg.channels = 2; cfg.harmonic = 0; break; case '2': cfg.channels = 1; cfg.harmonic = 0; break; case 'b': cfg.buf_size = atoi(optarg); break; case 'd': cfg.device = optarg; break; case 'i': cfg.showinsts = true; break; case 'r': cfg.songinfo = true; break; case 'm': cfg.songmessage = true; break; case 's': cfg.subsong = atoi(optarg); break; case 'o': cfg.endless = false; break; case 'V': puts(ADPLAY_VERSION); exit(EXIT_SUCCESS); case 'h': usage(); exit(EXIT_SUCCESS); break; case 'D': if(!mydb.load(optarg)) message(MSG_WARN, "could not open database -- %s", optarg); break; case 'O': if(!strcmp(optarg,"oss")) cfg.output = oss; else if(!strcmp(optarg,"null")) cfg.output = null; else if(!strcmp(optarg,"disk")) { cfg.output = disk; cfg.endless = false; // endless output is almost never desired here } else if(!strcmp(optarg,"esound")) cfg.output = esound; else if(!strcmp(optarg,"qsa")) cfg.output = qsa; else if(!strcmp(optarg,"alsa")) cfg.output = alsa; else if(!strcmp(optarg,"sdl")) cfg.output = sdl; else if(!strcmp(optarg,"ao")) cfg.output = ao; else { message(MSG_ERROR, "unknown output method -- %s", optarg); exit(EXIT_FAILURE); } break; case 'e': if(!strcmp(optarg, "satoh")) cfg.emutype = Emu_Satoh; else if(!strcmp(optarg, "ken")) cfg.emutype = Emu_Ken; else if(!strcmp(optarg, "woody")) cfg.emutype = Emu_Woody; #ifdef HAVE_ADPLUG_NUKEDOPL else if(!strcmp(optarg, "nuked")) cfg.emutype = Emu_Nuked; #endif else { message(MSG_ERROR, "unknown emulator -- %s", optarg); exit(EXIT_FAILURE); } case 'q': if(cfg.message_level) cfg.message_level--; break; case 'v': cfg.message_level++; break; } } return optind; } static void play(const char *fn, Player *pl, int subsong = -1) /* * Start playback of subsong 'subsong' of file 'fn', using player * 'player'. If 'subsong' is not given or -1, start playback of * default subsong of file. */ { unsigned long i; // initialize output & player pl->get_opl()->init(); pl->p = CAdPlug::factory(fn,pl->get_opl()); if(!pl->p) { message(MSG_WARN, "unknown filetype -- %s", fn); return; } if(subsong != -1) pl->p->rewind(subsong); #ifdef HAVE_ADPLUG_GETSUBSONG else subsong = pl->p->getsubsong(); #endif fprintf(stderr, "Playing '%s'...\n" "Type : %s\n" "Title : %s\n" "Author: %s\n\n", fn, pl->p->gettype().c_str(), pl->p->gettitle().c_str(), pl->p->getauthor().c_str()); if(cfg.showinsts) { // display instruments fprintf(stderr, "Instrument names:\n"); for(i = 0;i < pl->p->getinstruments(); i++) fprintf(stderr, "%2lu: %s\n", i, pl->p->getinstrument(i).c_str()); fprintf(stderr, "\n"); } if(cfg.songmessage) // display song message fprintf(stderr, "Song message:\n%s\n\n", pl->p->getdesc().c_str()); // play loop do { if(cfg.songinfo) // display song info fprintf(stderr, "Subsong: %d/%d, Order: %d/%d, Pattern: %d/%d, Row: %d, " "Speed: %d, Timer: %.2fHz \r", subsong, pl->p->getsubsongs()-1, pl->p->getorder(), pl->p->getorders(), pl->p->getpattern(), pl->p->getpatterns(), pl->p->getrow(), pl->p->getspeed(), pl->p->getrefresh()); pl->frame(); } while(pl->playing || cfg.endless); } static void shutdown(void) /* General deinitialization handler. */ { if(player) delete player; if(opl) delete opl; // Try to properly reposition terminal cursor, if Ctrl+C is used to exit. printf("\n\n"); } static void sighandler(int signal) /* Handles all kinds of signals. */ { switch(signal) { case SIGINT: case SIGTERM: exit(EXIT_SUCCESS); } } /***** Main program *****/ int main(int argc, char **argv) { int optind, i; const char *homedir; char *userdb; // init program_name = argv[0]; atexit(shutdown); signal(SIGINT, sighandler); signal(SIGTERM, sighandler); // Try user's home directory first, before trying the default location. homedir = getenv("HOME"); if(homedir) { userdb = (char *)malloc(strlen(homedir) + strlen(ADPLUG_CONFDIR) + strlen(ADPLUGDB_FILE) + 3); strcpy(userdb, homedir); strcat(userdb, "/" ADPLUG_CONFDIR "/"); strcat(userdb, ADPLUGDB_FILE); } // parse commandline optind = decode_switches(argc,argv); if(optind == argc) { // no filename given fprintf(stderr, "%s: need at least one file for playback\n", program_name); fprintf(stderr, "Try '%s --help' for more information.\n", program_name); if(userdb) free(userdb); exit(EXIT_FAILURE); } if(argc - optind > 1) cfg.endless = false; // more than 1 file given // init emulator switch(cfg.emutype) { case Emu_Satoh: if (cfg.harmonic) { #ifdef HAVE_ADPLUG_SURROUND Copl *a = new CEmuopl(cfg.freq, cfg.bits == 16, false); Copl *b = new CEmuopl(cfg.freq, cfg.bits == 16, false); opl = new CSurroundopl(a, b, cfg.bits == 16); // CSurroundopl now owns a and b and will free upon destruction #else fprintf(stderr, "Surround requires AdPlug v2.2 or newer. Use --mono " "or upgrade and recompile AdPlay.\n"); if(userdb) free(userdb); exit(EXIT_FAILURE); #endif } else { opl = new CEmuopl(cfg.freq, cfg.bits == 16, cfg.channels == 2); } break; case Emu_Ken: if (cfg.harmonic) { #ifdef HAVE_ADPLUG_SURROUND fprintf(stderr, "%s: Sorry, Ken's emulator only supports one instance " "so does not work properly in surround mode.\n", program_name); // Leave the code though for future use (once Ken's emu is wrapped up // in a class or something. It works, it just sounds really bad.) Copl *a = new CKemuopl(cfg.freq, cfg.bits == 16, false); Copl *b = new CKemuopl(cfg.freq, cfg.bits == 16, false); opl = new CSurroundopl(a, b, cfg.bits == 16); // CSurroundopl now owns a and b and will free upon destruction #else fprintf(stderr, "Surround requires AdPlug v2.2 or newer. Use --mono " "or upgrade and recompile AdPlay.\n"); if(userdb) free(userdb); exit(EXIT_FAILURE); #endif } else { opl = new CKemuopl(cfg.freq, cfg.bits == 16, cfg.channels == 2); } break; case Emu_Woody: if (cfg.harmonic) { #ifdef HAVE_ADPLUG_SURROUND Copl *a = new CWemuopl(cfg.freq, cfg.bits == 16, false); Copl *b = new CWemuopl(cfg.freq, cfg.bits == 16, false); opl = new CSurroundopl(a, b, cfg.bits == 16); // CSurroundopl now owns a and b and will free upon destruction #else fprintf(stderr, "Surround requires AdPlug v2.2 or newer. Use --mono " "or upgrade and recompile AdPlay.\n"); if(userdb) free(userdb); exit(EXIT_FAILURE); #endif } else { opl = new CWemuopl(cfg.freq, cfg.bits == 16, cfg.channels == 2); } break; #ifdef HAVE_ADPLUG_NUKEDOPL case Emu_Nuked: if (cfg.harmonic) { fprintf(stderr, "Nuked OPL3 emulator doesn't work in surround mode. " "Use --stereo and --16bit options.\n"); if(userdb) free(userdb); exit(EXIT_FAILURE); } else { if(cfg.bits != 16 || cfg.channels != 2) { fprintf(stderr, "Sorry, Nuked OPL3 emulator only works in stereo 16 bits. " "Use --stereo and --16bit options.\n"); if(userdb) free(userdb); exit(EXIT_FAILURE); } else { opl = new CNemuopl(cfg.freq); } } break; #endif } // init player switch(cfg.output) { case none: message(MSG_PANIC, "no output methods compiled in"); exit(EXIT_FAILURE); #ifdef DRIVER_OSS case oss: player = new OSSPlayer(opl, cfg.device, cfg.bits, cfg.channels, cfg.freq, cfg.buf_size); break; #endif #ifdef DRIVER_NULL case null: player = new NullOutput(); break; #endif #ifdef DRIVER_DISK case disk: player = new DiskWriter(opl, cfg.device, cfg.bits, cfg.channels, cfg.freq); break; #endif #ifdef DRIVER_ESOUND case esound: player = new EsoundPlayer(opl, cfg.bits, cfg.channels, cfg.freq, cfg.device); break; #endif #ifdef DRIVER_QSA case qsa: player = new QSAPlayer(opl, cfg.bits, cfg.channels, cfg.freq); break; #endif #ifdef DRIVER_AO case ao: player = new AOPlayer(opl, cfg.device, cfg.bits, cfg.channels, cfg.freq, cfg.buf_size); break; #endif # #ifdef DRIVER_SDL case sdl: player = new SDLPlayer(opl, cfg.bits, cfg.channels, cfg.freq, cfg.buf_size); break; #endif #ifdef DRIVER_ALSA case alsa: player = new ALSAPlayer(opl, cfg.device, cfg.bits, cfg.channels, cfg.freq, cfg.buf_size); break; #endif default: message(MSG_ERROR, "output method not available"); exit(EXIT_FAILURE); } // load database if(userdb) { mydb.load(userdb); free(userdb); } mydb.load(ADPLUGDB_PATH); CAdPlug::set_database(&mydb); // play all files from commandline for(i=optind;i * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "defines.h" #include "alsa.h" #define DEFAULT_DEVICE "default" // Default ALSA output device ALSAPlayer::ALSAPlayer(Copl *nopl, const char *device, unsigned char bits, int channels, int freq, unsigned long bufsize) : EmuPlayer(nopl, bits, channels, freq, bufsize) { snd_pcm_hw_params_t *hwparams; unsigned int nfreq = freq; unsigned long nbufsize; if(!device) device = DEFAULT_DEVICE; snd_pcm_hw_params_malloc(&hwparams); // Try to open audio device if(snd_pcm_open(&pcm_handle, device, SND_PCM_STREAM_PLAYBACK, 0) < 0) { message(MSG_ERROR, "error opening PCM device -- %s", device); exit(EXIT_FAILURE); } // Init hwparams with full configuration space if(snd_pcm_hw_params_any(pcm_handle, hwparams) < 0) { message(MSG_ERROR, "cannot configure this PCM device -- %s", device); exit(EXIT_FAILURE); } // Set access type if(snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) { message(MSG_ERROR, "error setting access type"); exit(EXIT_FAILURE); } // Set sample format if (snd_pcm_hw_params_set_format(pcm_handle, hwparams, bits == 16 ? SND_PCM_FORMAT_S16 : SND_PCM_FORMAT_U8) < 0) { message(MSG_ERROR, "error setting format"); exit(EXIT_FAILURE); } // Set sample rate (nearest possible) if(snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, &nfreq, 0) < 0) { message(MSG_ERROR, "error setting sample rate"); exit(EXIT_FAILURE); } if(nfreq != (unsigned int)freq) message(MSG_NOTE, "%d Hz sample rate not supported by your hardware, using " "%d Hz instead", freq, nfreq); // Set number of channels if(snd_pcm_hw_params_set_channels(pcm_handle, hwparams, channels) < 0) { message(MSG_ERROR, "error setting channels"); exit(EXIT_FAILURE); } // Set number of periods if(snd_pcm_hw_params_set_periods(pcm_handle, hwparams, 4, 0) < 0) { message(MSG_ERROR, "error setting periods"); exit(EXIT_FAILURE); } // Set the preferred buffer size (in samples) if(snd_pcm_hw_params_set_buffer_size(pcm_handle, hwparams, bufsize / getsampsize()) < 0) { if (snd_pcm_hw_params_get_buffer_size(hwparams, &nbufsize) < 0) { message(MSG_ERROR, "error setting and getting buffer size"); exit(EXIT_FAILURE); } setbufsize(nbufsize); message(MSG_NOTE, "couldn't set buffersize to %ld, using default of %ld instead", bufsize, nbufsize); } // Apply HW parameter settings to PCM device and prepare device if(snd_pcm_hw_params(pcm_handle, hwparams) < 0) { message(MSG_ERROR, "error setting HW params"); exit(EXIT_FAILURE); } snd_pcm_hw_params_free(hwparams); } ALSAPlayer::~ALSAPlayer() { // stop playback immediately snd_pcm_drop(pcm_handle); snd_pcm_close(pcm_handle); } void ALSAPlayer::output(const void *buf, unsigned long size) { if(snd_pcm_writei(pcm_handle, buf, size / getsampsize()) < 0) snd_pcm_prepare(pcm_handle); } adplay-unix-1.8/src/alsa.h000066400000000000000000000023151320415154400154750ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001 - 2003 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef H_ALSA #define H_ALSA #define ALSA_PCM_NEW_HW_PARAMS_API #include #include "output.h" class ALSAPlayer: public EmuPlayer { public: ALSAPlayer(Copl *nopl, const char *device, unsigned char bits, int channels, int freq, unsigned long bufsize); virtual ~ALSAPlayer(); protected: virtual void output(const void *buf, unsigned long size); private: snd_pcm_t *pcm_handle; }; #endif adplay-unix-1.8/src/ao.cc000066400000000000000000000031221320415154400153070ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001 - 2003 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include #include #include #include #include "ao.h" AOPlayer::AOPlayer(Copl *nopl, const char *device, unsigned char bits, int channels, int freq, unsigned long bufsize) : EmuPlayer(nopl, bits, channels, freq, bufsize) { ao_sample_format format; int default_driver; ao_initialize(); default_driver = ao_default_driver_id(); format.bits = bits; format.channels = channels; format.rate = freq; format.byte_format = AO_FMT_NATIVE; aodevice = ao_open_live(default_driver, &format, NULL); } AOPlayer::~AOPlayer() { if (aodevice != NULL) { ao_close(aodevice); } } void AOPlayer::output(const void *buf, unsigned long size) { ao_play(aodevice, (char *)buf, (uint_32) size); } adplay-unix-1.8/src/ao.h000066400000000000000000000022221320415154400151510ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001 - 2003 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef H_AO_ #define H_AO #include "output.h" #include class AOPlayer: public EmuPlayer { public: AOPlayer(Copl *nopl, const char *device, unsigned char bits, int channels, int freq, unsigned long bufsize); virtual ~AOPlayer(); protected: virtual void output(const void *buf, unsigned long size); private: ao_device *aodevice; }; #endif adplay-unix-1.8/src/defines.h000066400000000000000000000024451320415154400161760ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001, 2002 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef H_DEFINES #define H_DEFINES #include "config.h" /***** Defines *****/ // AdPlay/UNIX version string #define ADPLAY_VERSION "AdPlay/UNIX " VERSION // Message urgency levels #define MSG_PANIC 0 // Unmaskable #define MSG_ERROR 1 #define MSG_WARN 2 #define MSG_NOTE 3 #define MSG_DEBUG 4 #ifndef min # define min(a,b) (((a) < (b)) ? (a) : (b)) #endif #ifndef max # define max(a,b) (((a) > (b)) ? (a) : (b)) #endif /***** Global functions *****/ void message(int level, const char *fmt, ...); #endif adplay-unix-1.8/src/disk.cc000066400000000000000000000053301320415154400156450ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001 - 2003 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include #include #include #include "defines.h" #include "disk.h" #define BUFSIZE 512 DiskWriter::DiskWriter(Copl *nopl, const char *filename, unsigned char nbits, unsigned char nchannels, unsigned long nfreq) : EmuPlayer(nopl, nbits, nchannels, nfreq, BUFSIZE), f(0), samplesize(0) { if(!filename) { message(MSG_ERROR, "no output filename specified"); exit(EXIT_FAILURE); } // If filename is '-', output to stdout if(strcmp(filename, "-")) f = new binofstream(filename); else f = new binowstream(&std::cout); // not very good to mix cout with stdout if(!f || f->error()) { message(MSG_ERROR, "cannot open file for output -- %s", filename); if(f) delete f; exit(EXIT_FAILURE); } f->setFlag(binio::BigEndian, false); // Write Microsoft RIFF WAVE header f->writeString("RIFF", 4); f->writeInt(36, 4); f->writeString("WAVEfmt ", 8); f->writeInt(16, 4); f->writeInt(1, 2); f->writeInt(nchannels, 2); f->writeInt(nfreq, 4); f->writeInt(nfreq * getsampsize(), 4); f->writeInt(getsampsize(), 2); f->writeInt(nbits, 2); f->writeString("data", 4); f->writeInt(0, 4); } DiskWriter::~DiskWriter() { if(!f) return; if(samplesize % 2) { // Wave data must end on an even byte boundary f->writeInt(0, 1); samplesize++; } // Write file sizes f->seek(40); f->writeInt(samplesize, 4); samplesize += 36; // make absolute filesize (add header size) f->seek(4); f->writeInt(samplesize, 4); // end disk writing delete f; } void DiskWriter::output(const void *buf, unsigned long size) { char *b = (char *)buf; unsigned long i, ssize = getsampsize(); for(i = 0; i < size; i += ssize) switch(ssize) { case 1: f->writeInt(*(b + i), 1); break; case 2: f->writeInt(*(short *)(b + i), 2); break; case 4: f->writeInt(*(long *)(b + i), 4); break; } samplesize += size; } adplay-unix-1.8/src/disk.h000066400000000000000000000022651320415154400155130ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001, 2002 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef H_DISK #define H_DISK #include #include "output.h" class DiskWriter: public EmuPlayer { public: DiskWriter(Copl *nopl, const char *filename, unsigned char nbits, unsigned char nchannels, unsigned long nfreq); virtual ~DiskWriter(); protected: virtual void output(const void *buf, unsigned long size); private: binostream *f; unsigned long samplesize; }; #endif adplay-unix-1.8/src/esound.cc000066400000000000000000000027341320415154400162150ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001, 2002 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include "defines.h" #include "esound.h" EsoundPlayer::EsoundPlayer(Copl *nopl, unsigned char bits, int channels, int freq, const char *url) : EmuPlayer(nopl, bits, channels, freq, ESD_BUF_SIZE) { socket = esd_play_stream((bits == 16 ? ESD_BITS16 : ESD_BITS8) | (channels == 2 ? ESD_STEREO : ESD_MONO) | ESD_STREAM | ESD_PLAY, freq, url, ADPLAY_VERSION); // on error, just exit here. esd_play_stream() does perror() already... if(socket < 0) exit(EXIT_FAILURE); } EsoundPlayer::~EsoundPlayer() { close(socket); } void EsoundPlayer::output(const void *buf, unsigned long size) { write(socket, buf, size); } adplay-unix-1.8/src/esound.h000066400000000000000000000021661320415154400160560ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001, 2002 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef H_ESOUND #define H_ESOUND #include "output.h" class EsoundPlayer: public EmuPlayer { public: EsoundPlayer(Copl *nopl, unsigned char bits, int channels, int freq, const char *url = 0); virtual ~EsoundPlayer(); protected: virtual void output(const void *buf, unsigned long size); private: int socket; }; #endif adplay-unix-1.8/src/getopt.c000066400000000000000000000730041320415154400160550ustar00rootroot00000000000000/* Getopt for GNU. NOTE: getopt is now part of the C library, so if you don't know what "Keep this file name-space clean" means, talk to drepper@gnu.org before changing it! Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000 Free Software Foundation, Inc. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The GNU C Library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* This tells Alpha OSF/1 not to define a getopt prototype in . Ditto for AIX 3.2 and . */ #ifndef _NO_PROTO # define _NO_PROTO #endif #ifdef HAVE_CONFIG_H # include #endif #if !defined __STDC__ || !__STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ # ifndef const # define const # endif #endif #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #define GETOPT_INTERFACE_VERSION 2 #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2 # include # if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION # define ELIDE_CODE # endif #endif #ifndef ELIDE_CODE /* This needs to come after some library #include to get __GNU_LIBRARY__ defined. */ #ifdef __GNU_LIBRARY__ /* Don't include stdlib.h for non-GNU C libraries because some of them contain conflicting prototypes for getopt. */ # include # include #endif /* GNU C library. */ #ifdef VMS # include # if HAVE_STRING_H - 0 # include # endif #endif #ifndef _ /* This is for other GNU distributions with internationalized messages. When compiling libc, the _ macro is predefined. */ # ifdef HAVE_LIBINTL_H # include # define _(msgid) gettext (msgid) # else # define _(msgid) (msgid) # endif #endif /* This version of `getopt' appears to the caller like standard Unix `getopt' but it behaves differently for the user, since it allows the user to intersperse the options with the other arguments. As `getopt' works, it permutes the elements of ARGV so that, when it is done, all the options precede everything else. Thus all application programs are extended to handle flexible argument order. Setting the environment variable POSIXLY_CORRECT disables permutation. Then the behavior is completely standard. GNU application programs can use a third alternative mode in which they can distinguish the relative order of options and other arguments. */ #include "getopt.h" /* For communication from `getopt' to the caller. When `getopt' finds an option that takes an argument, the argument value is returned here. Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ char *optarg; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to `getopt'. On entry to `getopt', zero means this is the first call; initialize. When `getopt' returns -1, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ /* 1003.2 says this must be 1 before any call. */ int optind = 1; /* Formerly, initialization of getopt depended on optind==0, which causes problems with re-calling getopt as programs generally don't know that. */ int __getopt_initialized; /* The next char to be scanned in the option-element in which the last option character we returned was found. This allows us to pick up the scan where we left off. If this is zero, or a null string, it means resume the scan by advancing to the next ARGV-element. */ static char *nextchar; /* Callers store zero here to inhibit the error message for unrecognized options. */ int opterr = 1; /* Set to an option character which was unrecognized. This must be initialized on some systems to avoid linking in the system's own getopt implementation. */ int optopt = '?'; /* Describe how to deal with options that follow non-option ARGV-elements. If the caller did not specify anything, the default is REQUIRE_ORDER if the environment variable POSIXLY_CORRECT is defined, PERMUTE otherwise. REQUIRE_ORDER means don't recognize them as options; stop option processing when the first non-option is seen. This is what Unix does. This mode of operation is selected by either setting the environment variable POSIXLY_CORRECT, or using `+' as the first character of the list of option characters. PERMUTE is the default. We permute the contents of ARGV as we scan, so that eventually all the non-options are at the end. This allows options to be given in any order, even with programs that were not written to expect this. RETURN_IN_ORDER is an option available to programs that were written to expect options and other ARGV-elements in any order and that care about the ordering of the two. We describe each non-option ARGV-element as if it were the argument of an option with character code 1. Using `-' as the first character of the list of option characters selects this mode of operation. The special argument `--' forces an end of option-scanning regardless of the value of `ordering'. In the case of RETURN_IN_ORDER, only `--' can cause `getopt' to return -1 with `optind' != ARGC. */ static enum { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER } ordering; /* Value of POSIXLY_CORRECT environment variable. */ static char *posixly_correct; #ifdef __GNU_LIBRARY__ /* We want to avoid inclusion of string.h with non-GNU libraries because there are many ways it can cause trouble. On some systems, it contains special magic macros that don't work in GCC. */ # include # define my_index strchr #else # if HAVE_STRING_H # include # else # include # endif /* Avoid depending on library functions or files whose names are inconsistent. */ #ifndef getenv extern char *getenv (); #endif static char * my_index (str, chr) const char *str; int chr; { while (*str) { if (*str == chr) return (char *) str; str++; } return 0; } /* If using GCC, we can safely declare strlen this way. If not using GCC, it is ok not to declare it. */ #ifdef __GNUC__ /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h. That was relevant to code that was here before. */ # if (!defined __STDC__ || !__STDC__) && !defined strlen /* gcc with -traditional declares the built-in strlen to return int, and has done so at least since version 2.4.5. -- rms. */ extern int strlen (const char *); # endif /* not __STDC__ */ #endif /* __GNUC__ */ #endif /* not __GNU_LIBRARY__ */ /* Handle permutation of arguments. */ /* Describe the part of ARGV that contains non-options that have been skipped. `first_nonopt' is the index in ARGV of the first of them; `last_nonopt' is the index after the last of them. */ static int first_nonopt; static int last_nonopt; #ifdef _LIBC /* Bash 2.0 gives us an environment variable containing flags indicating ARGV elements that should not be considered arguments. */ /* Defined in getopt_init.c */ extern char *__getopt_nonoption_flags; static int nonoption_flags_max_len; static int nonoption_flags_len; static int original_argc; static char *const *original_argv; /* Make sure the environment variable bash 2.0 puts in the environment is valid for the getopt call we must make sure that the ARGV passed to getopt is that one passed to the process. */ static void __attribute__ ((unused)) store_args_and_env (int argc, char *const *argv) { /* XXX This is no good solution. We should rather copy the args so that we can compare them later. But we must not use malloc(3). */ original_argc = argc; original_argv = argv; } # ifdef text_set_element text_set_element (__libc_subinit, store_args_and_env); # endif /* text_set_element */ # define SWAP_FLAGS(ch1, ch2) \ if (nonoption_flags_len > 0) \ { \ char __tmp = __getopt_nonoption_flags[ch1]; \ __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \ __getopt_nonoption_flags[ch2] = __tmp; \ } #else /* !_LIBC */ # define SWAP_FLAGS(ch1, ch2) #endif /* _LIBC */ /* Exchange two adjacent subsequences of ARGV. One subsequence is elements [first_nonopt,last_nonopt) which contains all the non-options that have been skipped so far. The other is elements [last_nonopt,optind), which contains all the options processed since those non-options were skipped. `first_nonopt' and `last_nonopt' are relocated so that they describe the new indices of the non-options in ARGV after they are moved. */ #if defined __STDC__ && __STDC__ static void exchange (char **); #endif static void exchange (argv) char **argv; { int bottom = first_nonopt; int middle = last_nonopt; int top = optind; char *tem; /* Exchange the shorter segment with the far end of the longer segment. That puts the shorter segment into the right place. It leaves the longer segment in the right place overall, but it consists of two parts that need to be swapped next. */ #ifdef _LIBC /* First make sure the handling of the `__getopt_nonoption_flags' string can work normally. Our top argument must be in the range of the string. */ if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len) { /* We must extend the array. The user plays games with us and presents new arguments. */ char *new_str = malloc (top + 1); if (new_str == NULL) nonoption_flags_len = nonoption_flags_max_len = 0; else { memset (__mempcpy (new_str, __getopt_nonoption_flags, nonoption_flags_max_len), '\0', top + 1 - nonoption_flags_max_len); nonoption_flags_max_len = top + 1; __getopt_nonoption_flags = new_str; } } #endif while (top > middle && middle > bottom) { if (top - middle > middle - bottom) { /* Bottom segment is the short one. */ int len = middle - bottom; register int i; /* Swap it with the top part of the top segment. */ for (i = 0; i < len; i++) { tem = argv[bottom + i]; argv[bottom + i] = argv[top - (middle - bottom) + i]; argv[top - (middle - bottom) + i] = tem; SWAP_FLAGS (bottom + i, top - (middle - bottom) + i); } /* Exclude the moved bottom segment from further swapping. */ top -= len; } else { /* Top segment is the short one. */ int len = top - middle; register int i; /* Swap it with the bottom part of the bottom segment. */ for (i = 0; i < len; i++) { tem = argv[bottom + i]; argv[bottom + i] = argv[middle + i]; argv[middle + i] = tem; SWAP_FLAGS (bottom + i, middle + i); } /* Exclude the moved top segment from further swapping. */ bottom += len; } } /* Update records for the slots the non-options now occupy. */ first_nonopt += (optind - last_nonopt); last_nonopt = optind; } /* Initialize the internal data when the first call is made. */ #if defined __STDC__ && __STDC__ static const char *_getopt_initialize (int, char *const *, const char *); #endif static const char * _getopt_initialize (argc, argv, optstring) int argc; char *const *argv; const char *optstring; { /* Start processing options with ARGV-element 1 (since ARGV-element 0 is the program name); the sequence of previously skipped non-option ARGV-elements is empty. */ first_nonopt = last_nonopt = optind; nextchar = NULL; posixly_correct = getenv ("POSIXLY_CORRECT"); /* Determine how to handle the ordering of options and nonoptions. */ if (optstring[0] == '-') { ordering = RETURN_IN_ORDER; ++optstring; } else if (optstring[0] == '+') { ordering = REQUIRE_ORDER; ++optstring; } else if (posixly_correct != NULL) ordering = REQUIRE_ORDER; else ordering = PERMUTE; #ifdef _LIBC if (posixly_correct == NULL && argc == original_argc && argv == original_argv) { if (nonoption_flags_max_len == 0) { if (__getopt_nonoption_flags == NULL || __getopt_nonoption_flags[0] == '\0') nonoption_flags_max_len = -1; else { const char *orig_str = __getopt_nonoption_flags; int len = nonoption_flags_max_len = strlen (orig_str); if (nonoption_flags_max_len < argc) nonoption_flags_max_len = argc; __getopt_nonoption_flags = (char *) malloc (nonoption_flags_max_len); if (__getopt_nonoption_flags == NULL) nonoption_flags_max_len = -1; else memset (__mempcpy (__getopt_nonoption_flags, orig_str, len), '\0', nonoption_flags_max_len - len); } } nonoption_flags_len = nonoption_flags_max_len; } else nonoption_flags_len = 0; #endif return optstring; } /* Scan elements of ARGV (whose length is ARGC) for option characters given in OPTSTRING. If an element of ARGV starts with '-', and is not exactly "-" or "--", then it is an option element. The characters of this element (aside from the initial '-') are option characters. If `getopt' is called repeatedly, it returns successively each of the option characters from each of the option elements. If `getopt' finds another option character, it returns that character, updating `optind' and `nextchar' so that the next call to `getopt' can resume the scan with the following option character or ARGV-element. If there are no more option characters, `getopt' returns -1. Then `optind' is the index in ARGV of the first ARGV-element that is not an option. (The ARGV-elements have been permuted so that those that are not options now come last.) OPTSTRING is a string containing the legitimate option characters. If an option character is seen that is not listed in OPTSTRING, return '?' after printing an error message. If you set `opterr' to zero, the error message is suppressed but we still return '?'. If a char in OPTSTRING is followed by a colon, that means it wants an arg, so the following text in the same ARGV-element, or the text of the following ARGV-element, is returned in `optarg'. Two colons mean an option that wants an optional arg; if there is text in the current ARGV-element, it is returned in `optarg', otherwise `optarg' is set to zero. If OPTSTRING starts with `-' or `+', it requests different methods of handling the non-option ARGV-elements. See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. Long-named options begin with `--' instead of `-'. Their names may be abbreviated as long as the abbreviation is unique or is an exact match for some defined option. If they have an argument, it follows the option name in the same ARGV-element, separated from the option name by a `=', or else the in next ARGV-element. When `getopt' finds a long-named option, it returns 0 if that option's `flag' field is nonzero, the value of the option's `val' field if the `flag' field is zero. The elements of ARGV aren't really const, because we permute them. But we pretend they're const in the prototype to be compatible with other systems. LONGOPTS is a vector of `struct option' terminated by an element containing a name which is zero. LONGIND returns the index in LONGOPT of the long-named option found. It is only valid when a long-named option has been found by the most recent call. If LONG_ONLY is nonzero, '-' as well as '--' can introduce long-named options. */ int _getopt_internal (argc, argv, optstring, longopts, longind, long_only) int argc; char *const *argv; const char *optstring; const struct option *longopts; int *longind; int long_only; { int print_errors = opterr; if (optstring[0] == ':') print_errors = 0; optarg = NULL; if (optind == 0 || !__getopt_initialized) { if (optind == 0) optind = 1; /* Don't scan ARGV[0], the program name. */ optstring = _getopt_initialize (argc, argv, optstring); __getopt_initialized = 1; } /* Test whether ARGV[optind] points to a non-option argument. Either it does not have option syntax, or there is an environment flag from the shell indicating it is not an option. The later information is only used when the used in the GNU libc. */ #ifdef _LIBC # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \ || (optind < nonoption_flags_len \ && __getopt_nonoption_flags[optind] == '1')) #else # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0') #endif if (nextchar == NULL || *nextchar == '\0') { /* Advance to the next ARGV-element. */ /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been moved back by the user (who may also have changed the arguments). */ if (last_nonopt > optind) last_nonopt = optind; if (first_nonopt > optind) first_nonopt = optind; if (ordering == PERMUTE) { /* If we have just processed some options following some non-options, exchange them so that the options come first. */ if (first_nonopt != last_nonopt && last_nonopt != optind) exchange ((char **) argv); else if (last_nonopt != optind) first_nonopt = optind; /* Skip any additional non-options and extend the range of non-options previously skipped. */ while (optind < argc && NONOPTION_P) optind++; last_nonopt = optind; } /* The special ARGV-element `--' means premature end of options. Skip it like a null option, then exchange with previous non-options as if it were an option, then skip everything else like a non-option. */ if (optind != argc && !strcmp (argv[optind], "--")) { optind++; if (first_nonopt != last_nonopt && last_nonopt != optind) exchange ((char **) argv); else if (first_nonopt == last_nonopt) first_nonopt = optind; last_nonopt = argc; optind = argc; } /* If we have done all the ARGV-elements, stop the scan and back over any non-options that we skipped and permuted. */ if (optind == argc) { /* Set the next-arg-index to point at the non-options that we previously skipped, so the caller will digest them. */ if (first_nonopt != last_nonopt) optind = first_nonopt; return -1; } /* If we have come to a non-option and did not permute it, either stop the scan or describe it to the caller and pass it by. */ if (NONOPTION_P) { if (ordering == REQUIRE_ORDER) return -1; optarg = argv[optind++]; return 1; } /* We have found another option-ARGV-element. Skip the initial punctuation. */ nextchar = (argv[optind] + 1 + (longopts != NULL && argv[optind][1] == '-')); } /* Decode the current option-ARGV-element. */ /* Check whether the ARGV-element is a long option. If long_only and the ARGV-element has the form "-f", where f is a valid short option, don't consider it an abbreviated form of a long option that starts with f. Otherwise there would be no way to give the -f short option. On the other hand, if there's a long option "fubar" and the ARGV-element is "-fu", do consider that an abbreviation of the long option, just like "--fu", and not "-f" with arg "u". This distinction seems to be the most useful approach. */ if (longopts != NULL && (argv[optind][1] == '-' || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1]))))) { char *nameend; const struct option *p; const struct option *pfound = NULL; int exact = 0; int ambig = 0; int indfound = -1; int option_index; for (nameend = nextchar; *nameend && *nameend != '='; nameend++) /* Do nothing. */ ; /* Test all long options for either exact match or abbreviated matches. */ for (p = longopts, option_index = 0; p->name; p++, option_index++) if (!strncmp (p->name, nextchar, nameend - nextchar)) { if ((unsigned int) (nameend - nextchar) == (unsigned int) strlen (p->name)) { /* Exact match found. */ pfound = p; indfound = option_index; exact = 1; break; } else if (pfound == NULL) { /* First nonexact match found. */ pfound = p; indfound = option_index; } else /* Second or later nonexact match found. */ ambig = 1; } if (ambig && !exact) { if (print_errors) fprintf (stderr, _("%s: option `%s' is ambiguous\n"), argv[0], argv[optind]); nextchar += strlen (nextchar); optind++; optopt = 0; return '?'; } if (pfound != NULL) { option_index = indfound; optind++; if (*nameend) { /* Don't test has_arg with >, because some C compilers don't allow it to be used on enums. */ if (pfound->has_arg) optarg = nameend + 1; else { if (print_errors) { if (argv[optind - 1][1] == '-') /* --option */ fprintf (stderr, _("%s: option `--%s' doesn't allow an argument\n"), argv[0], pfound->name); else /* +option or -option */ fprintf (stderr, _("%s: option `%c%s' doesn't allow an argument\n"), argv[0], argv[optind - 1][0], pfound->name); } nextchar += strlen (nextchar); optopt = pfound->val; return '?'; } } else if (pfound->has_arg == 1) { if (optind < argc) optarg = argv[optind++]; else { if (print_errors) fprintf (stderr, _("%s: option `%s' requires an argument\n"), argv[0], argv[optind - 1]); nextchar += strlen (nextchar); optopt = pfound->val; return optstring[0] == ':' ? ':' : '?'; } } nextchar += strlen (nextchar); if (longind != NULL) *longind = option_index; if (pfound->flag) { *(pfound->flag) = pfound->val; return 0; } return pfound->val; } /* Can't find it as a long option. If this is not getopt_long_only, or the option starts with '--' or is not a valid short option, then it's an error. Otherwise interpret it as a short option. */ if (!long_only || argv[optind][1] == '-' || my_index (optstring, *nextchar) == NULL) { if (print_errors) { if (argv[optind][1] == '-') /* --option */ fprintf (stderr, _("%s: unrecognized option `--%s'\n"), argv[0], nextchar); else /* +option or -option */ fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), argv[0], argv[optind][0], nextchar); } nextchar = (char *) ""; optind++; optopt = 0; return '?'; } } /* Look at and handle the next short option-character. */ { char c = *nextchar++; char *temp = my_index (optstring, c); /* Increment `optind' when we start to process its last character. */ if (*nextchar == '\0') ++optind; if (temp == NULL || c == ':') { if (print_errors) { if (posixly_correct) /* 1003.2 specifies the format of this message. */ fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], c); else fprintf (stderr, _("%s: invalid option -- %c\n"), argv[0], c); } optopt = c; return '?'; } /* Convenience. Treat POSIX -W foo same as long option --foo */ if (temp[0] == 'W' && temp[1] == ';') { char *nameend; const struct option *p; const struct option *pfound = NULL; int exact = 0; int ambig = 0; int indfound = 0; int option_index; /* This is an option that requires an argument. */ if (*nextchar != '\0') { optarg = nextchar; /* If we end this ARGV-element by taking the rest as an arg, we must advance to the next element now. */ optind++; } else if (optind == argc) { if (print_errors) { /* 1003.2 specifies the format of this message. */ fprintf (stderr, _("%s: option requires an argument -- %c\n"), argv[0], c); } optopt = c; if (optstring[0] == ':') c = ':'; else c = '?'; return c; } else /* We already incremented `optind' once; increment it again when taking next ARGV-elt as argument. */ optarg = argv[optind++]; /* optarg is now the argument, see if it's in the table of longopts. */ for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++) /* Do nothing. */ ; /* Test all long options for either exact match or abbreviated matches. */ for (p = longopts, option_index = 0; p->name; p++, option_index++) if (!strncmp (p->name, nextchar, nameend - nextchar)) { if ((unsigned int) (nameend - nextchar) == strlen (p->name)) { /* Exact match found. */ pfound = p; indfound = option_index; exact = 1; break; } else if (pfound == NULL) { /* First nonexact match found. */ pfound = p; indfound = option_index; } else /* Second or later nonexact match found. */ ambig = 1; } if (ambig && !exact) { if (print_errors) fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"), argv[0], argv[optind]); nextchar += strlen (nextchar); optind++; return '?'; } if (pfound != NULL) { option_index = indfound; if (*nameend) { /* Don't test has_arg with >, because some C compilers don't allow it to be used on enums. */ if (pfound->has_arg) optarg = nameend + 1; else { if (print_errors) fprintf (stderr, _("\ %s: option `-W %s' doesn't allow an argument\n"), argv[0], pfound->name); nextchar += strlen (nextchar); return '?'; } } else if (pfound->has_arg == 1) { if (optind < argc) optarg = argv[optind++]; else { if (print_errors) fprintf (stderr, _("%s: option `%s' requires an argument\n"), argv[0], argv[optind - 1]); nextchar += strlen (nextchar); return optstring[0] == ':' ? ':' : '?'; } } nextchar += strlen (nextchar); if (longind != NULL) *longind = option_index; if (pfound->flag) { *(pfound->flag) = pfound->val; return 0; } return pfound->val; } nextchar = NULL; return 'W'; /* Let the application handle it. */ } if (temp[1] == ':') { if (temp[2] == ':') { /* This is an option that accepts an argument optionally. */ if (*nextchar != '\0') { optarg = nextchar; optind++; } else optarg = NULL; nextchar = NULL; } else { /* This is an option that requires an argument. */ if (*nextchar != '\0') { optarg = nextchar; /* If we end this ARGV-element by taking the rest as an arg, we must advance to the next element now. */ optind++; } else if (optind == argc) { if (print_errors) { /* 1003.2 specifies the format of this message. */ fprintf (stderr, _("%s: option requires an argument -- %c\n"), argv[0], c); } optopt = c; if (optstring[0] == ':') c = ':'; else c = '?'; } else /* We already incremented `optind' once; increment it again when taking next ARGV-elt as argument. */ optarg = argv[optind++]; nextchar = NULL; } } return c; } } int getopt (argc, argv, optstring) int argc; char *const *argv; const char *optstring; { return _getopt_internal (argc, argv, optstring, (const struct option *) 0, (int *) 0, 0); } #endif /* Not ELIDE_CODE. */ #ifdef TEST /* Compile with -DTEST to make an executable for use in testing the above definition of `getopt'. */ int main (argc, argv) int argc; char **argv; { int c; int digit_optind = 0; while (1) { int this_option_optind = optind ? optind : 1; c = getopt (argc, argv, "abc:d:0123456789"); if (c == -1) break; switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (digit_optind != 0 && digit_optind != this_option_optind) printf ("digits occur in two different argv-elements.\n"); digit_optind = this_option_optind; printf ("option %c\n", c); break; case 'a': printf ("option a\n"); break; case 'b': printf ("option b\n"); break; case 'c': printf ("option c with value `%s'\n", optarg); break; case '?': break; default: printf ("?? getopt returned character code 0%o ??\n", c); } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) printf ("%s ", argv[optind++]); printf ("\n"); } exit (0); } #endif /* TEST */ adplay-unix-1.8/src/getopt.h000066400000000000000000000133451320415154400160640ustar00rootroot00000000000000/* Declarations for getopt. Copyright (C) 1989,90,91,92,93,94,96,97,98 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The GNU C Library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef _GETOPT_H #ifndef __need_getopt # define _GETOPT_H 1 #endif #ifdef __cplusplus extern "C" { #endif /* For communication from `getopt' to the caller. When `getopt' finds an option that takes an argument, the argument value is returned here. Also, when `ordering' is RETURN_IN_ORDER, each non-option ARGV-element is returned here. */ extern char *optarg; /* Index in ARGV of the next element to be scanned. This is used for communication to and from the caller and for communication between successive calls to `getopt'. On entry to `getopt', zero means this is the first call; initialize. When `getopt' returns -1, this is the index of the first of the non-option elements that the caller should itself scan. Otherwise, `optind' communicates from one call to the next how much of ARGV has been scanned so far. */ extern int optind; /* Callers store zero here to inhibit the error message `getopt' prints for unrecognized options. */ extern int opterr; /* Set to an option character which was unrecognized. */ extern int optopt; #ifndef __need_getopt /* Describe the long-named options requested by the application. The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector of `struct option' terminated by an element containing a name which is zero. The field `has_arg' is: no_argument (or 0) if the option does not take an argument, required_argument (or 1) if the option requires an argument, optional_argument (or 2) if the option takes an optional argument. If the field `flag' is not NULL, it points to a variable that is set to the value given in the field `val' when the option is found, but left unchanged if the option is not found. To have a long-named option do something other than set an `int' to a compiled-in constant, such as set a value from `optarg', set the option's `flag' field to zero and its `val' field to a nonzero value (the equivalent single-letter option character, if there is one). For long options that have a zero `flag' field, `getopt' returns the contents of the `val' field. */ struct option { # if defined __STDC__ && __STDC__ const char *name; # else char *name; # endif /* has_arg can't be an enum because some compilers complain about type mismatches in all the code that assumes it is an int. */ int has_arg; int *flag; int val; }; /* Names for the values of the `has_arg' field of `struct option'. */ # define no_argument 0 # define required_argument 1 # define optional_argument 2 #endif /* need getopt */ /* Get definitions and prototypes for functions to process the arguments in ARGV (ARGC of them, minus the program name) for options given in OPTS. Return the option character from OPTS just read. Return -1 when there are no more options. For unrecognized options, or options missing arguments, `optopt' is set to the option letter, and '?' is returned. The OPTS string is a list of characters which are recognized option letters, optionally followed by colons, specifying that that letter takes an argument, to be placed in `optarg'. If a letter in OPTS is followed by two colons, its argument is optional. This behavior is specific to the GNU `getopt'. The argument `--' causes premature termination of argument scanning, explicitly telling `getopt' that there are no more options. If OPTS begins with `--', then non-option arguments are treated as arguments to the option '\0'. This behavior is specific to the GNU `getopt'. */ #if defined __STDC__ && __STDC__ # ifdef __GNU_LIBRARY__ /* Many other libraries have conflicting prototypes for getopt, with differences in the consts, in stdlib.h. To avoid compilation errors, only prototype getopt for the GNU C library. */ extern int getopt (int __argc, char *const *__argv, const char *__shortopts); # else /* not __GNU_LIBRARY__ */ extern int getopt (); # endif /* __GNU_LIBRARY__ */ # ifndef __need_getopt extern int getopt_long (int __argc, char *const *__argv, const char *__shortopts, const struct option *__longopts, int *__longind); extern int getopt_long_only (int __argc, char *const *__argv, const char *__shortopts, const struct option *__longopts, int *__longind); /* Internal only. Users should not call this directly. */ extern int _getopt_internal (int __argc, char *const *__argv, const char *__shortopts, const struct option *__longopts, int *__longind, int __long_only); # endif #else /* not __STDC__ */ extern int getopt (); # ifndef __need_getopt extern int getopt_long (); extern int getopt_long_only (); extern int _getopt_internal (); # endif #endif /* __STDC__ */ #ifdef __cplusplus } #endif /* Make sure we later can get all the definitions and declarations. */ #undef __need_getopt #endif /* getopt.h */ adplay-unix-1.8/src/getopt1.c000066400000000000000000000107061320415154400161360ustar00rootroot00000000000000/* getopt_long and getopt_long_only entry points for GNU getopt. Copyright (C) 1987,88,89,90,91,92,93,94,96,97,98 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The GNU C Library 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 Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifdef HAVE_CONFIG_H #include #endif #include "getopt.h" #if !defined __STDC__ || !__STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ #ifndef const #define const #endif #endif #include /* Comment out all this code if we are using the GNU C Library, and are not actually compiling the library itself. This code is part of the GNU C Library, but also included in many other GNU distributions. Compiling and linking in this code is a waste when using the GNU C library (especially if it is a shared library). Rather than having every GNU program understand `configure --with-gnu-libc' and omit the object files, it is simpler to just do this in the source for each such file. */ #define GETOPT_INTERFACE_VERSION 2 #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2 #include #if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION #define ELIDE_CODE #endif #endif #ifndef ELIDE_CODE /* This needs to come after some library #include to get __GNU_LIBRARY__ defined. */ #ifdef __GNU_LIBRARY__ #include #endif #ifndef NULL #define NULL 0 #endif int getopt_long (argc, argv, options, long_options, opt_index) int argc; char *const *argv; const char *options; const struct option *long_options; int *opt_index; { return _getopt_internal (argc, argv, options, long_options, opt_index, 0); } /* Like getopt_long, but '-' as well as '--' can indicate a long option. If an option that starts with '-' (not '--') doesn't match a long option, but does match a short option, it is parsed as a short option instead. */ int getopt_long_only (argc, argv, options, long_options, opt_index) int argc; char *const *argv; const char *options; const struct option *long_options; int *opt_index; { return _getopt_internal (argc, argv, options, long_options, opt_index, 1); } #endif /* Not ELIDE_CODE. */ #ifdef TEST #include int main (argc, argv) int argc; char **argv; { int c; int digit_optind = 0; while (1) { int this_option_optind = optind ? optind : 1; int option_index = 0; static struct option long_options[] = { {"add", 1, 0, 0}, {"append", 0, 0, 0}, {"delete", 1, 0, 0}, {"verbose", 0, 0, 0}, {"create", 0, 0, 0}, {"file", 1, 0, 0}, {0, 0, 0, 0} }; c = getopt_long (argc, argv, "abc:d:0123456789", long_options, &option_index); if (c == -1) break; switch (c) { case 0: printf ("option %s", long_options[option_index].name); if (optarg) printf (" with arg %s", optarg); printf ("\n"); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (digit_optind != 0 && digit_optind != this_option_optind) printf ("digits occur in two different argv-elements.\n"); digit_optind = this_option_optind; printf ("option %c\n", c); break; case 'a': printf ("option a\n"); break; case 'b': printf ("option b\n"); break; case 'c': printf ("option c with value `%s'\n", optarg); break; case 'd': printf ("option d with value `%s'\n", optarg); break; case '?': break; default: printf ("?? getopt returned character code 0%o ??\n", c); } } if (optind < argc) { printf ("non-option ARGV-elements: "); while (optind < argc) printf ("%s ", argv[optind++]); printf ("\n"); } exit (0); } #endif /* TEST */ adplay-unix-1.8/src/null.h000066400000000000000000000020261320415154400155260ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001, 2002 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef H_NULL #define H_NULL #include #include "output.h" class NullOutput: public Player { public: virtual void frame() { } virtual Copl *get_opl() { return &opl; } private: CSilentopl opl; }; #endif adplay-unix-1.8/src/oss.cc000066400000000000000000000033561320415154400155250ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001 - 2003 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include #include #include #include #include "oss.h" #define DEFAULT_DEVICE "/dev/dsp" // Default output device file OSSPlayer::OSSPlayer(Copl *nopl, const char *device, unsigned char bits, int channels, int freq, unsigned long bufsize) : EmuPlayer(nopl, bits, channels, freq, bufsize) { int format = (bits == 16 ? AFMT_S16_LE : AFMT_S8); // Set to default if no device given if(!device) device = DEFAULT_DEVICE; // open OSS audio device if((audio_fd = open(device, O_WRONLY, 0)) == -1) { perror(device); exit(EXIT_FAILURE); } ioctl(audio_fd, SNDCTL_DSP_SETFMT, &format); ioctl(audio_fd, SOUND_PCM_WRITE_CHANNELS, &channels); ioctl(audio_fd, SNDCTL_DSP_SPEED, &freq); } OSSPlayer::~OSSPlayer() { close(audio_fd); } void OSSPlayer::output(const void *buf, unsigned long size) { write(audio_fd, buf, size); } adplay-unix-1.8/src/oss.h000066400000000000000000000023101320415154400153540ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001 - 2003 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef H_OSS #define H_OSS #include "output.h" class OSSPlayer: public EmuPlayer { public: OSSPlayer(Copl *nopl, const char *device, unsigned char bits, int channels, int freq, unsigned long bufsize); virtual ~OSSPlayer(); protected: virtual void output(const void *buf, unsigned long size); private: int audio_fd; // audio device file unsigned long size; // audio buffer size in bytes }; #endif adplay-unix-1.8/src/output.cc000066400000000000000000000041311320415154400162510ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001 - 2003 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include "output.h" #include "defines.h" /***** Player *****/ Player::Player() : p(0), playing(false) { } Player::~Player() { if(p) delete p; } /***** EmuPlayer *****/ EmuPlayer::EmuPlayer(Copl *nopl, unsigned char nbits, unsigned char nchannels, unsigned long nfreq, unsigned long nbufsize) : opl(nopl), buf_size(nbufsize), freq(nfreq), bits(nbits), channels(nchannels) { audiobuf = new char [buf_size * getsampsize()]; } EmuPlayer::~EmuPlayer() { delete [] audiobuf; } // Some output plugins (ALSA) need to change the buffer size mid-init void EmuPlayer::setbufsize(unsigned long nbufsize) { delete [] audiobuf; buf_size = nbufsize; audiobuf = new char [buf_size * getsampsize()]; } void EmuPlayer::frame() { static long minicnt = 0; long i, towrite = buf_size; char *pos = audiobuf; // Prepare audiobuf with emulator output while(towrite > 0) { while(minicnt < 0) { minicnt += freq; playing = p->update(); } i = min(towrite, (long)(minicnt / p->getrefresh() + 4) & ~3); opl->update((short *)pos, i); pos += i * getsampsize(); towrite -= i; i = (long)(p->getrefresh() * i); minicnt -= max(1, i); } // call output driver output(audiobuf, buf_size * getsampsize()); } adplay-unix-1.8/src/output.h000066400000000000000000000032711320415154400161170ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001 - 2003 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef H_OUTPUT #define H_OUTPUT #include class Player { public: CPlayer *p; bool playing; Player(); virtual ~Player(); virtual void frame() = 0; virtual Copl *get_opl() = 0; }; class EmuPlayer: public Player { private: Copl *opl; char *audiobuf; unsigned long buf_size, freq; unsigned char bits, channels; public: EmuPlayer(Copl *nopl, unsigned char nbits, unsigned char nchannels, unsigned long nfreq, unsigned long nbufsize); virtual ~EmuPlayer(); virtual void setbufsize(unsigned long nbufsize); virtual void frame(); virtual Copl *get_opl() { return opl; } protected: virtual void output(const void *buf, unsigned long size) = 0; // The output buffer is always of the size requested through the constructor. // This time, size is measured in bytes, not samples! unsigned char getsampsize() { return (channels * (bits / 8)); } }; #endif adplay-unix-1.8/src/players.h000066400000000000000000000037361320415154400162440ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001 - 2006 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* * players.h - This header conditionally includes AdPlay's output drivers * and sets a reasonable default. */ #ifndef H_PLAYERS #define H_PLAYERS #include "config.h" // Enumerate ALL outputs (regardless of availability) enum Outputs {none, null, ao, oss, disk, esound, qsa, sdl, alsa}; #define DEFAULT_DRIVER none // Null (silent) output #ifdef DRIVER_NULL #include "null.h" #undef DEFAULT_DRIVER #define DEFAULT_DRIVER null #endif // Disk writer #ifdef DRIVER_DISK #include "disk.h" #undef DEFAULT_DRIVER #define DEFAULT_DRIVER disk #endif // EsounD driver #ifdef DRIVER_ESOUND #include "esound.h" #undef DEFAULT_DRIVER #define DEFAULT_DRIVER esound #endif // SDL driver #ifdef DRIVER_SDL #include "sdl.h" #undef DEFAULT_DRIVER #define DEFAULT_DRIVER sdl #endif // AO driver #ifdef DRIVER_AO #include "ao.h" #undef DEFAULT_DRIVER #define DEFAULT_DRIVER ao #endif // OSS driver #ifdef DRIVER_OSS #include "oss.h" #undef DEFAULT_DRIVER #define DEFAULT_DRIVER oss #endif // ALSA driver #ifdef DRIVER_ALSA #include "alsa.h" #undef DEFAULT_DRIVER #define DEFAULT_DRIVER alsa #endif // QSA driver #ifdef DRIVER_QSA #include "qsa.h" #undef DEFAULT_DRIVER #define DEFAULT_DRIVER qsa #endif #endif adplay-unix-1.8/src/qsa.cc000066400000000000000000000061501320415154400155000ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001, 2002 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "qsa.h" #include QSAPlayer::QSAPlayer(unsigned char bits, int channels, int freq) : EmuPlayer(bits, channels, freq, QSA_FRAG_SIZE) { int rval; snd_pcm_channel_params_t cparams; audio_handle=NULL; rval = snd_pcm_open_preferred(&audio_handle, NULL, NULL, SND_PCM_OPEN_PLAYBACK); if (rval < 0) { exit(EXIT_FAILURE); } memset(&cparams, 0, sizeof(snd_pcm_channel_params_t)); cparams.channel = SND_PCM_CHANNEL_PLAYBACK; cparams.mode = SND_PCM_MODE_BLOCK; cparams.start_mode = SND_PCM_START_FULL; cparams.stop_mode = SND_PCM_STOP_STOP; if (bits==16) { cparams.format.format = SND_PCM_SFMT_S16_LE; } else { cparams.format.format = SND_PCM_SFMT_U8; } cparams.format.interleave = 1; cparams.format.rate = freq; cparams.format.voices = channels; cparams.buf.block.frag_size = QSA_FRAG_SIZE; cparams.buf.block.frags_min = 4; cparams.buf.block.frags_max = 8; rval = snd_pcm_plugin_params(audio_handle, &cparams); if (rval < 0) { exit(EXIT_FAILURE); } rval = snd_pcm_plugin_prepare(audio_handle, SND_PCM_CHANNEL_PLAYBACK); if (rval < 0) { exit(EXIT_FAILURE); } } QSAPlayer::~QSAPlayer() { int rval; if (audio_handle != NULL) { rval = snd_pcm_plugin_flush(audio_handle, SND_PCM_CHANNEL_PLAYBACK); rval = snd_pcm_close(audio_handle); audio_handle = NULL; } } void QSAPlayer::output(const void *buf, unsigned long size) { int rval; unsigned long written; unsigned long towrite; snd_pcm_channel_status_t cstatus; towrite=size; do { written = snd_pcm_plugin_write(audio_handle, buf, towrite); if (written != towrite) { if((errno == EINVAL) || (errno == EIO)) { memset(&cstatus, 0, sizeof(cstatus)); if (snd_pcm_plugin_status(audio_handle, &cstatus) < 0 ) { return; } if ((cstatus.status == SND_PCM_STATUS_UNDERRUN) || (cstatus.status == SND_PCM_STATUS_READY)) { if (snd_pcm_plugin_prepare (audio_handle, SND_PCM_CHANNEL_PLAYBACK) < 0 ) { return; } } continue; } } else { break; } } while (1); } adplay-unix-1.8/src/qsa.h000066400000000000000000000022321320415154400153370ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001, 2002 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef H_QSA #define H_QSA #include "output.h" #include #define QSA_FRAG_SIZE 4096 class QSAPlayer: public EmuPlayer { public: QSAPlayer(unsigned char bits, int channels, int freq); virtual ~QSAPlayer(); protected: virtual void output(const void *buf, unsigned long size); private: snd_pcm_t* audio_handle; // audio device handle }; #endif adplay-unix-1.8/src/sdl.cc000066400000000000000000000046111320415154400154760ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001 - 2003 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include "sdl.h" #include "defines.h" SDLPlayer::SDLPlayer(Copl *nopl, unsigned char bits, int channels, int freq, unsigned long bufsize) : opl(nopl) { memset(&spec, 0x00, sizeof(SDL_AudioSpec)); if(SDL_Init(SDL_INIT_AUDIO) < 0) { message(MSG_ERROR, "unable to initialize SDL -- %s", SDL_GetError()); exit(EXIT_FAILURE); } spec.freq = freq; if(bits == 16) spec.format = AUDIO_S16SYS; else spec.format = AUDIO_U8; spec.channels = channels; spec.samples = bufsize; spec.callback = SDLPlayer::callback; spec.userdata = this; if(SDL_OpenAudio(&spec, NULL) < 0) { message(MSG_ERROR, "unable to open audio -- %s", SDL_GetError()); exit(EXIT_FAILURE); } message(MSG_DEBUG, "got audio buffer size -- %d", spec.size); } SDLPlayer::~SDLPlayer() { if(!SDL_WasInit(SDL_INIT_AUDIO)) return; SDL_CloseAudio(); SDL_Quit(); } void SDLPlayer::frame() { SDL_PauseAudio(0); SDL_Delay(1000 * spec.freq / (spec.size / getsampsize())); } void SDLPlayer::callback(void *userdata, Uint8 *audiobuf, int len) { SDLPlayer *self = (SDLPlayer *)userdata; static long minicnt = 0; long i, towrite = len / self->getsampsize(); char *pos = (char *)audiobuf; // Prepare audiobuf with emulator output while(towrite > 0) { while(minicnt < 0) { minicnt += self->spec.freq; self->playing = self->p->update(); } i = min(towrite, (long)(minicnt / self->p->getrefresh() + 4) & ~3); self->opl->update((short *)pos, i); pos += i * self->getsampsize(); towrite -= i; minicnt -= (long)(self->p->getrefresh() * i); } } adplay-unix-1.8/src/sdl.h000066400000000000000000000024261320415154400153420ustar00rootroot00000000000000/* * AdPlay/UNIX - OPL2 audio player * Copyright (C) 2001 - 2003 Simon Peter * * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifndef H_SDL #define H_SDL #include #include "output.h" class SDLPlayer: public Player { private: Copl *opl; SDL_AudioSpec spec; static void callback(void *, Uint8 *, int); unsigned char getsampsize() { return spec.channels * (spec.format == AUDIO_U8 ? 1 : 2); } public: SDLPlayer(Copl *nopl, unsigned char bits, int channels, int freq, unsigned long bufsize); virtual ~SDLPlayer(); virtual void frame(); virtual Copl *get_opl() { return opl; } }; #endif