diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 00000000..4d4cf802 --- /dev/null +++ b/AUTHORS @@ -0,0 +1 @@ +Volker Fischer diff --git a/COPYING b/COPYING new file mode 100644 index 00000000..c7aea189 --- /dev/null +++ b/COPYING @@ -0,0 +1,280 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 675 Mass Ave, Cambridge, MA 02139, 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 diff --git a/ChangeLog b/ChangeLog new file mode 100644 index 00000000..e69de29b diff --git a/INSTALL b/INSTALL new file mode 100755 index 00000000..869c4042 --- /dev/null +++ b/INSTALL @@ -0,0 +1,54 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + + +Windows: +-------- + +Rquired software: QT 2 non-commercial, Visual C++ 6.0 + +- run llcon/windows/MocQT.bat +- open llcon.dsw in your Visual C++ 6.0 environment and compile +- run llcon/windows/Release/llcon.exe + + +Linux: +------ + +Required packages: QT (devel packages, too!), ALSA (devel packages, too!) + +- cd llcon +- sh bootstrap +- ./configure +- make +- run llcon/linux/llcon + +NOTES: +- it may be required by your Linux distrubution that you set the QTDIR + environment variable prior to the "./configure" call. E.g., for SUSE: + export QTDIR=/usr/lib/qt3 + or for Debian: + export QTDIR=/usr/share/qt3 +- if the file "bootstrap" is not available, skip this step + diff --git a/Makefile.am b/Makefile.am new file mode 100644 index 00000000..a15ebeb7 --- /dev/null +++ b/Makefile.am @@ -0,0 +1,3 @@ +AUTOMAKE_OPTIONS = foreign + +SUBDIRS = linux diff --git a/NEWS b/NEWS new file mode 100644 index 00000000..e69de29b diff --git a/README b/README new file mode 100755 index 00000000..3ee5eb0d --- /dev/null +++ b/README @@ -0,0 +1,75 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +llcon +----- + +Low-Latency Connection / client and server + + +OBJECTIVES: +The task is to build a client/server software to enable musicians to play together +over the internet. Target internet connection is DSL with 256 kbps upstream and +1 Mbit downstream. The server software must be located at a server with a very +fast internet connection (at least 1 Mbps for up- and downstream). + +To get sufficient results, a sample rate of 24 kHz (mono channel) was chosen. An +audio compression algorithm with very low delay is IMA-ADPCM (delay is just one +sample). This gives a raw compressed audio data rate of 96 kbps. + +Target hardware setup at the client is stereo audio input signal with one channel +is the instrument and the other channel is a microphone signal. On the microphne +channel a reverberation effect can be applied (maybe at a later time other audio +effects are added). + + +MANUAL: +For starting server type ./llcon -s + +Start the llcon server on a remote computer with fast internet access. Start the +llcon client on your local computer and connect your sound card with your +instrument/microphone and headphone and type in the IP address of the server. +There are levelers for adjusting the sound card (in/out) and network buffer sizes. +It seems that 2 blocks for network buffer is optimal choice. For the sound card +buffer, try to make them as short as possible by watching the LEDs below the +levelers (they should stay green) and the timing standard deviation (should be +as low as approx. 0.5 ms). + +For test purpose it is possible to run server and client on the same computer. For +this setup firstly start server and then the client. Type in 127.0.0.1 for the +IP address in the client. + + +EXTERNAL CODE: +This code contains open source code from different sources. The developer(s) want +to thank the developer of this code for making their efforts available under open +source: + +- audio reverberation code: by Perry R. Cook and Gary P. Scavone, 1995 - 2004 + (taken from "The Synthesis ToolKit in C++ (STK)") + +- IMA-ADPCM: by Erik de Castro Lopo + +- some parts are taken from the project "Dream: a PC-based Digital Radio Mondiale + (DRM) receiver" written by one of the llcon authors, Volker Fischer diff --git a/TODO b/TODO new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/TODO @@ -0,0 +1 @@ + diff --git a/bootstrap b/bootstrap new file mode 100755 index 00000000..fea2bbbc --- /dev/null +++ b/bootstrap @@ -0,0 +1,8 @@ +#! /bin/bash + +aclocal -I . && \ +autoheader && \ +libtoolize --automake --copy && \ +automake --add-missing --copy && \ +autoconf +echo "Ready to run ./configure" diff --git a/configure.in b/configure.in new file mode 100755 index 00000000..0df728d7 --- /dev/null +++ b/configure.in @@ -0,0 +1,70 @@ +dnl Process this file with autoconf to produce a configure script. +AC_PREREQ(2.50) +AC_INIT(src/main.cpp) + +AM_INIT_AUTOMAKE(llcon,0.9.1) + + +AM_CONFIG_HEADER(config.h) + +dnl Checks for programs. +AC_PROG_LIBTOOL +AC_PROG_CC +AC_PROG_CXX +AC_PROG_CPP +AC_PROG_INSTALL +AC_SUBST(LIBTOOL_DEPS) +AC_PROG_MAKE_SET +AC_CHECK_PROGS(RPMBUILD, rpmbuild, rpm) + +dnl Configuration Arguments + +AC_ARG_ENABLE( sound,[ --enable-sound generic sound support], enable_sound=$enableval, enable_sound=yes) + +AC_ARG_WITH( qtdir,[ --with-qtdir=path to QT],QTDIR=$withval) + + + +AC_CHECK_HEADER(sys/asoundlib.h, , enable_sound=no) +AC_CHECK_LIB(asound, snd_pcm_open, , enable_sound=no) + +if test "$enable_sound" = "yes"; then + AC_DEFINE(WITH_SOUND, 1, [Define if you want to use sound]) +fi + +if test "$enable_client" = "yes"; then + AC_DEFINE(APPL_TYPE_CLIENT, 1, [Define if you want to use client]) +fi + + +dnl Checks for header files. +AC_HEADER_STDC +AC_LANG_CPLUSPLUS + +dnl Checks for some external libraries that need to be installed +AC_LANG(C++) + + +dnl QT -------------------------------------------------------------------------- +if test "no$QTDIR" = "no"; then + AC_MSG_ERROR( "*** Please set QTDIR ***" ) +fi + +saved_ldflags="$LDFLAGS" +LDFLAGS="$LDFLAGS -L$QTDIR/lib" + +AC_HAVE_LIBRARY(qt-mt,,exit 1) + +AC_PATH_PROG(MOC, moc,, "$QTDIR/bin") +if test -z "$MOC"; then + AC_MSG_ERROR("No moc found in $QTDIR/bin"); +fi +AC_PATH_PROG(UIC, uic,, "$QTDIR/bin") +if test -z "$UIC"; then + AC_MSG_ERROR("No uic found in $QTDIR/bin"); +fi +AC_SUBST(QTDIR) + + +AC_CONFIG_FILES(Makefile linux/Makefile) +AC_OUTPUT diff --git a/linux/Makefile.am b/linux/Makefile.am new file mode 100755 index 00000000..6e0360b0 --- /dev/null +++ b/linux/Makefile.am @@ -0,0 +1,106 @@ +bin_PROGRAMS = llcon + + +llcon_SOURCES = ../src/buffer.cpp \ + ../src/main.cpp \ + ../src/socket.cpp \ + ../src/audiocompr.cpp \ + ../src/resample.cpp \ + ../src/channel.cpp \ + ../src/util.cpp \ + ../src/llconclientdlg.cpp \ + ../src/client.cpp \ + ../src/llconserverdlg.cpp \ + ../src/server.cpp \ + ../src/settings.cpp \ + ../src/multicolorled.cpp \ + sound.cpp \ + ../src/buffer.h \ + ../src/global.h \ + ../src/socket.h \ + ../src/audiocompr.h \ + ../src/resample.h \ + ../src/resamplefilter.h \ + ../src/channel.h \ + ../src/util.h \ + ../src/client.h \ + ../src/server.h \ + ../src/settings.h \ + ../src/multicolorled.h \ + ../src/llconserverdlg.h \ + ../src/llconclientdlg.h \ + ../src/llconclientdlgbase.ui \ + ../src/llconserverdlgbase.ui \ + ../src/aboutdlgbase.ui \ + sound.h + +# these need to be generated before the rest can be compiled + +BUILT_SOURCES=moc/moc_server.cpp \ + moc/moc_socket.cpp \ + moc/moc_multicolorled.cpp \ + moc/moc_util.cpp \ + moc/moc_llconclientdlg.cpp moc/moc_llconclientdlgbase.cpp moc/llconclientdlgbase.h moc/llconclientdlgbase.cpp \ + moc/moc_llconserverdlg.cpp moc/moc_llconserverdlgbase.cpp moc/llconserverdlgbase.h moc/llconserverdlgbase.cpp \ + moc/moc_aboutdlgbase.cpp moc/aboutdlgbase.h moc/aboutdlgbase.cpp + +# and should be cleaned by make clean + +CLEANFILES=$(BUILT_SOURCES) +nodist_llcon_SOURCES=$(BUILT_SOURCES) + +dist-hook: + mkdir $(distdir)/moc + +moc/moc_server.cpp: ../src/server.h + $(MOC) ../src/server.h -o moc/moc_server.cpp + +moc/moc_socket.cpp: ../src/socket.h + $(MOC) ../src/socket.h -o moc/moc_socket.cpp + +moc/moc_multicolorled.cpp: ../src/multicolorled.h + $(MOC) ../src/multicolorled.h -o moc/moc_multicolorled.cpp + +moc/moc_util.cpp: ../src/util.h + $(MOC) ../src/util.h -o moc/moc_util.cpp + + + +moc/moc_aboutdlgbase.cpp: moc/aboutdlgbase.h + $(MOC) moc/aboutdlgbase.h -o moc/moc_aboutdlgbase.cpp + +moc/aboutdlgbase.h: ../src/aboutdlgbase.ui + $(UIC) ../src/aboutdlgbase.ui -o moc/aboutdlgbase.h + +moc/aboutdlgbase.cpp: ../src/aboutdlgbase.ui moc/aboutdlgbase.h + $(UIC) ../src/aboutdlgbase.ui -i moc/aboutdlgbase.h -o moc/aboutdlgbase.cpp + + +moc/moc_llconclientdlg.cpp: ../src/llconclientdlg.h + $(MOC) ../src/llconclientdlg.h -o moc/moc_llconclientdlg.cpp + +moc/moc_llconclientdlgbase.cpp: moc/llconclientdlgbase.h + $(MOC) moc/llconclientdlgbase.h -o moc/moc_llconclientdlgbase.cpp + +moc/llconclientdlgbase.h: ../src/llconclientdlgbase.ui + $(UIC) ../src/llconclientdlgbase.ui -o moc/llconclientdlgbase.h + +moc/llconclientdlgbase.cpp: ../src/llconclientdlgbase.ui moc/llconclientdlgbase.h + $(UIC) ../src/llconclientdlgbase.ui -i moc/llconclientdlgbase.h -o moc/llconclientdlgbase.cpp + + +moc/moc_llconserverdlg.cpp: ../src/llconserverdlg.h + $(MOC) ../src/llconserverdlg.h -o moc/moc_llconserverdlg.cpp + +moc/moc_llconserverdlgbase.cpp: moc/llconserverdlgbase.h + $(MOC) moc/llconserverdlgbase.h -o moc/moc_llconserverdlgbase.cpp + +moc/llconserverdlgbase.h: ../src/llconserverdlgbase.ui + $(UIC) ../src/llconserverdlgbase.ui -o moc/llconserverdlgbase.h + +moc/llconserverdlgbase.cpp: ../src/llconserverdlgbase.ui moc/llconserverdlgbase.h + $(UIC) ../src/llconserverdlgbase.ui -i moc/llconserverdlgbase.h -o moc/llconserverdlgbase.cpp + + + +llcon_CXXFLAGS=$(QWTINCL) -I../src -I$(QTDIR)/include -DQT_THREAD_SUPPORT -D_REENTRANT -g diff --git a/linux/sound.cpp b/linux/sound.cpp new file mode 100755 index 00000000..5f149bd6 --- /dev/null +++ b/linux/sound.cpp @@ -0,0 +1,480 @@ +/******************************************************************************\ + * Copyright (c) 2004-2005 + * + * Author(s): + * Volker Fischer, Alexander Kurpiers + * + * This code is based on the Open-Source sound interface implementation of + * the Dream DRM Receiver project. + * +\******************************************************************************/ + +#include "sound.h" + +#ifdef WITH_SOUND +/* Wave in ********************************************************************/ +void CSound::InitRecording(int iNewBufferSize, bool bNewBlocking) +{ + int err; + + /* set internal buffer size for read */ + iBufferSizeIn = iNewBufferSize / NUM_IN_OUT_CHANNELS; /* mono size */ + + /* if recording device was already open, close it first */ + if (rhandle != NULL) + snd_pcm_close(rhandle); + + /* record device: The most important ALSA interfaces to the PCM devices are + the "plughw" and the "hw" interface. If you use the "plughw" interface, + you need not care much about the sound hardware. If your soundcard does + not support the sample rate or sample format you specify, your data will + be automatically converted. This also applies to the access type and the + number of channels. With the "hw" interface, you have to check whether + your hardware supports the configuration you would like to use */ + /* either "hw:0,0" or "plughw:0,0" */ + if (err = snd_pcm_open(&rhandle, "hw:0,0", SND_PCM_STREAM_CAPTURE, 0) != 0) + { + qDebug("open error: %s", snd_strerror(err)); +// throw CGenErr("alsa CSound::Init_HW record"); + } + + /* recording should be blocking */ + if (err = snd_pcm_nonblock(rhandle, FALSE) != 0) + { + qDebug("cannot set blocking: %s", snd_strerror(err)); +// throw CGenErr("alsa CSound::Init_HW record"); + } + + /* set hardware parameters */ + SetHWParams(rhandle, true, iBufferSizeIn, iCurPeriodSizeIn); + + + /* sw parameters --------------------------------------------------------- */ + snd_pcm_sw_params_t* swparams; + + if (err = snd_pcm_sw_params_malloc (&swparams) != 0) + { + qDebug("snd_pcm_sw_params_malloc: %s", snd_strerror (err)); +// return NULL ; + } + + /* Get the current swparams */ + if (err = snd_pcm_sw_params_current(rhandle, swparams) < 0) + { + qDebug("Unable to determine current swparams : %s", snd_strerror(err)); +// throw CGenErr("alsa CSound::Init_HW "); + } + + /* Start the transfer when the buffer immediately */ + err = snd_pcm_sw_params_set_start_threshold(rhandle, swparams, 0); + if (err < 0) { + qDebug("Unable to set start threshold mode : %s", snd_strerror(err)); +// throw CGenErr("alsa CSound::Init_HW "); + } + + /* Align all transfers to 1 sample */ + err = snd_pcm_sw_params_set_xfer_align(rhandle, swparams, 1); + if (err < 0) { + qDebug("Unable to set transfer align : %s", snd_strerror(err)); +// throw CGenErr("alsa CSound::Init_HW "); + } + + +// TEST + /* Allow the transfer when at least period_size samples can be processed */ +// /* round up to closest transfer boundary */ +// start_threshold = (buffer_size / xfer_align) * xfer_align ; +// if (start_threshold < 1) +// start_threshold = 1 ; + + +// TEST +snd_pcm_uframes_t period_size = iBufferSizeIn; + + err = snd_pcm_sw_params_set_avail_min(rhandle, swparams, period_size); + if (err < 0) { + qDebug("Unable to set avail min : %s", snd_strerror(err)); +// throw CGenErr("alsa CSound::Init_HW "); + } + + + + /* Write the parameters to the record/playback device */ + err = snd_pcm_sw_params(rhandle, swparams); + if (err < 0) { + qDebug("Unable to set sw params : %s", snd_strerror(err)); +// throw CGenErr("alsa CSound::Init_HW "); + } + + /* clean-up */ + snd_pcm_sw_params_free(swparams); + + snd_pcm_reset(rhandle); + snd_pcm_start(rhandle); + + qDebug("alsa init record done"); +} + +bool CSound::Read(CVector& psData) +{ + /* Check if device must be opened or reinitialized */ + if (bChangParamIn == true) + { + InitRecording ( iBufferSizeIn * NUM_IN_OUT_CHANNELS ); + + /* Reset flag */ + bChangParamIn = false; + } + + int ret = snd_pcm_readi(rhandle, &psData[0], iBufferSizeIn); +//qDebug("ret: %d, iBufferSizeIn: %d", ret, iBufferSizeIn); + + if (ret < 0) + { + if (ret == -EPIPE) + { + /* Under-run */ + qDebug ( "rprepare" ); + + ret = snd_pcm_prepare ( rhandle ); + + if ( ret < 0 ) + { + qDebug ( "Can't recover from underrun, prepare failed: %s", snd_strerror ( ret ) ); + } + + ret = snd_pcm_start ( rhandle ); + + if (ret < 0) + { + qDebug ( "Can't recover from underrun, start failed: %s", snd_strerror ( ret ) ); + } + + return true; + + } + else if ( ret == -ESTRPIPE ) + { + qDebug ( "strpipe" ); + + /* Wait until the suspend flag is released */ + while ( ( ret = snd_pcm_resume ( rhandle ) ) == -EAGAIN ) + { + sleep(1); + } + + if ( ret < 0 ) + { + ret = snd_pcm_prepare(rhandle); + + if (ret < 0) + { + qDebug ( "Can't recover from suspend, prepare failed: %s", snd_strerror ( ret ) ); + } + throw CGenErr ( "CSound:Read" ); + } + + return true; + } + else + { + qDebug ( "CSound::Read: %s", snd_strerror ( ret ) ); + throw CGenErr ( "CSound:Read" ); + } + } + else + { + return false; + } +} + +void CSound::SetInNumBuf ( int iNewNum ) +{ + /* check new parameter */ + if ( ( iNewNum >= MAX_SND_BUF_IN ) || ( iNewNum < 1 ) ) + { + iNewNum = NUM_PERIOD_BLOCKS_IN; + } + + /* Change only if parameter is different */ + if ( iNewNum != iCurPeriodSizeIn ) + { + iCurPeriodSizeIn = iNewNum; + bChangParamIn = true; + } +} + + +/* Wave out *******************************************************************/ +void CSound::InitPlayback ( int iNewBufferSize, bool bNewBlocking ) +{ + int err; + + /* Save buffer size */ + iBufferSizeOut = iNewBufferSize / NUM_IN_OUT_CHANNELS; /* mono size */ + + /* if playback device was already open, close it first */ + if ( phandle != NULL ) + { + snd_pcm_close ( phandle ); + } + + /* playback device */ + /* either "hw:0,0" or "plughw:0,0" */ + if ( err = snd_pcm_open ( &phandle, "hw:0,0", SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK ) != 0) + { + qDebug ( "open error: %s", snd_strerror ( err ) ); +// throw CGenErr("alsa CSound::Init_HW playback"); + } + + /* non-blocking playback */ + if ( err = snd_pcm_nonblock ( phandle, TRUE ) != 0 ) + { + qDebug ( "cannot set blocking: %s", snd_strerror ( err ) ); +// throw CGenErr("alsa CSound::Init_HW record"); + } + + /* set hardware parameters */ + SetHWParams ( phandle, false, iBufferSizeOut, iCurPeriodSizeOut ); + + snd_pcm_start ( phandle ); + qDebug ( "alsa init playback done" ); +} + +bool CSound::Write ( CVector& psData ) +{ + int size = iBufferSizeIn; + int start = 0; + int ret; + + /* Check if device must be opened or reinitialized */ + if ( bChangParamOut == true ) + { + InitPlayback ( iBufferSizeOut * NUM_IN_OUT_CHANNELS ); + + /* Reset flag */ + bChangParamOut = false; + } + + while ( size ) + { + ret = snd_pcm_writei ( phandle, &psData[start], size ); +//qDebug("start: %d, iBufferSizeIn: %d", start, iBufferSizeIn); + + if ( ret < 0 ) + { + if ( ret == -EAGAIN ) + { + if ( ( ret = snd_pcm_wait ( phandle, 1 ) ) < 0 ) + { + qDebug ( "poll failed (%s)", snd_strerror ( ret ) ); + break; + } + + continue; + } + else if ( ret == -EPIPE ) + { + /* under-run */ + qDebug ( "wunderrun" ); + + ret = snd_pcm_prepare ( phandle ); + + if ( ret < 0 ) + { + qDebug ( "Can't recover from underrun, prepare failed: %s", snd_strerror ( ret ) ); + } + continue; + } + else if ( ret == -ESTRPIPE ) + { + qDebug("wstrpipe"); + + /* wait until the suspend flag is released */ + while ( (ret = snd_pcm_resume ( phandle ) ) == -EAGAIN ) + { + sleep(1); + } + + if ( ret < 0 ) + { + ret = snd_pcm_prepare ( phandle ); + + if ( ret < 0 ) + { + qDebug ( "Can't recover from suspend, prepare failed: %s", snd_strerror ( ret ) ); + } + } + continue; + } + else + { + qDebug ( "Write error: %s", snd_strerror ( ret ) ); +// throw CGenErr ( "Write error" ); + } + break; /* skip one period */ + } + + size -= ret; + start += ret; + } + + return false; +} + +void CSound::SetOutNumBuf(int iNewNum) +{ + /* check new parameter */ + if ( ( iNewNum >= MAX_SND_BUF_OUT ) || ( iNewNum < 1 ) ) + { + iNewNum = NUM_PERIOD_BLOCKS_OUT; + } + + /* Change only if parameter is different */ + if ( iNewNum != iCurPeriodSizeOut ) + { + iCurPeriodSizeOut = iNewNum; + bChangParamOut = true; + } +} + + +/* common **********************************************************************/ +bool CSound::SetHWParams(snd_pcm_t* handle, const bool bIsRecord, + const int iBufferSizeIn, const int iNumPeriodBlocks) +{ + int err; + snd_pcm_hw_params_t* hwparams; + + if (err = snd_pcm_hw_params_malloc(&hwparams) < 0) + { + qDebug("cannot allocate hardware parameter structure (%s)\n", snd_strerror(err)); + return true; + } + + if (err = snd_pcm_hw_params_any(handle, hwparams) < 0) + { + qDebug("cannot initialize hardware parameter structure (%s)\n", snd_strerror(err)); + return true; + } + + /* get configuration */ + if (err = snd_pcm_hw_params_any(handle, hwparams) < 0) + { + qDebug("Broken configuration : no configurations available: %s", snd_strerror(err)); + return true; + } + + /* Set the interleaved read/write format */ + if (err = snd_pcm_hw_params_set_access(handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) + { + qDebug("Access type not available : %s", snd_strerror(err)); + return true; + } + + /* Set the sample format */ + if (err = snd_pcm_hw_params_set_format(handle, hwparams, SND_PCM_FORMAT_S16) < 0) + { + qDebug("Sample format not available : %s", snd_strerror(err)); + return true; + } + + /* Set the count of channels */ + if (err = snd_pcm_hw_params_set_channels(handle, hwparams, NUM_IN_OUT_CHANNELS) < 0) + { + qDebug("Channels count (%i) not available s: %s", NUM_IN_OUT_CHANNELS, snd_strerror(err)); + return true; + } + + /* Set the sample-rate */ + unsigned int rrate = SND_CRD_SAMPLE_RATE; + if ( err = snd_pcm_hw_params_set_rate_near ( handle, hwparams, &rrate, 0 ) < 0 ) + { + qDebug("Rate %iHz not available : %s", rrate, snd_strerror(err)); + return true; + } + if ( rrate != SND_CRD_SAMPLE_RATE ) + { + qDebug ( "Rate doesn't match (requested %iHz, get %iHz)", rrate, err ); + return true; + } + + + + + + /* set the buffer and period size */ + +// TEST +snd_pcm_uframes_t BufferFrames = iBufferSizeIn * iNumPeriodBlocks; + + if (err = snd_pcm_hw_params_set_buffer_size_near(handle, hwparams, &BufferFrames) < 0) + { + qDebug("cannot set buffer size (%s)\n", snd_strerror (err)); + return true; + } + +// TEST +snd_pcm_uframes_t PeriodSize = iBufferSizeIn; + + if (err = snd_pcm_hw_params_set_period_size_near(handle, hwparams, &PeriodSize, 0) < 0) +//if (err = snd_pcm_hw_params_set_period_size_max(handle, hwparams, &PeriodSize, 0) < 0) + { + qDebug("cannot set period size (%s)\n", snd_strerror (err)); + return true; + } + + + + /* Write the parameters to device */ + if (err = snd_pcm_hw_params(handle, hwparams) < 0) + { + qDebug("Unable to set hw params : %s", snd_strerror(err)); + return true; + } + +/* check period and buffer size */ +qDebug("desired block size: %d / desired buffer size: %d", iBufferSizeIn, iBufferSizeIn * iNumPeriodBlocks); + +// TEST +snd_pcm_uframes_t buffer_size; +if (err = snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size) < 0) { + qDebug("Unable to get buffer size for playback: %s\n", snd_strerror(err)); +// throw CGenErr("alsa CSound::Init_HW "); +} +qDebug("buffer size %d", buffer_size); + +snd_pcm_uframes_t period_size; +err = snd_pcm_hw_params_get_period_size(hwparams, &period_size, 0); +if (err < 0) +{ + qDebug("Unable to get period size for playback: %s\n", snd_strerror(err)); +// throw CGenErr("alsa CSound::Init_HW "); +} +qDebug("period size %d", period_size); + + + + + /* clean-up */ + snd_pcm_hw_params_free(hwparams); + + return false; +} + +void CSound::Close() +{ + /* read */ + if (rhandle != NULL) + snd_pcm_close(rhandle); + + rhandle = NULL; + + /* playback */ + if (phandle != NULL) + snd_pcm_close(phandle); + + phandle = NULL; +} + +#endif /* WITH_SOUND */ diff --git a/linux/sound.h b/linux/sound.h new file mode 100755 index 00000000..78a25e1b --- /dev/null +++ b/linux/sound.h @@ -0,0 +1,105 @@ +/******************************************************************************\ + * Copyright (c) 2004-2005 + * + * Author(s): + * Volker Fischer, Alexander Kurpiers + * + * This code is based on the Open-Source sound interface implementation of + * the Dream DRM Receiver project. + * +\******************************************************************************/ + +#if !defined(_SOUND_H__9518A621345F78_3634567_8C0D_EEBF182CF549__INCLUDED_) +#define _SOUND_H__9518A621345F78_3634567_8C0D_EEBF182CF549__INCLUDED_ + +#include +#include +#include +#include +#include +#include + +#include +#include "util.h" +#include "global.h" + +#if WITH_SOUND +# define ALSA_PCM_NEW_HW_PARAMS_API +# define ALSA_PCM_NEW_SW_PARAMS_API +# include +#endif + + +/* Definitions ****************************************************************/ +#define NUM_IN_OUT_CHANNELS 2 /* always stereo */ + +/* the number of periods is critical for latency */ +#define NUM_PERIOD_BLOCKS_IN 2 +#define NUM_PERIOD_BLOCKS_OUT 2 + +#define MAX_SND_BUF_IN 200 +#define MAX_SND_BUF_OUT 200 + +/* Classes ********************************************************************/ +class CSound +{ +public: + CSound() +#if WITH_SOUND + : rhandle(NULL), phandle(NULL), iCurPeriodSizeIn(NUM_PERIOD_BLOCKS_IN), + iCurPeriodSizeOut(NUM_PERIOD_BLOCKS_OUT) +#endif + {} + virtual ~CSound() {Close();} + + /* Not implemented yet, always return one device and default string */ + int GetNumDev() {return 1;} + void SetOutDev(int iNewDev) {} + void SetInDev(int iNewDev) {} + + /* Return invalid device ID which is the same as using "wave mapper" which + we assume here to be used */ + int GetOutDev() {return 1;} + int GetInDev() {return 1;} + +#if WITH_SOUND + void SetInNumBuf(int iNewNum); + int GetInNumBuf() {return iCurPeriodSizeIn;} + void SetOutNumBuf(int iNewNum); + int GetOutNumBuf() {return iCurPeriodSizeOut;} + void InitRecording(int iNewBufferSize, bool bNewBlocking = true); + void InitPlayback(int iNewBufferSize, bool bNewBlocking = false); + bool Read(CVector& psData); + bool Write(CVector& psData); + + void Close(); + +protected: + snd_pcm_t* rhandle; + snd_pcm_t* phandle; + + bool SetHWParams(snd_pcm_t* handle, const bool bIsRecord, + const int iBufferSizeIn, const int iNumPeriodBlocks); + + int iBufferSizeOut; + int iBufferSizeIn; + bool bChangParamIn; + int iCurPeriodSizeIn; + bool bChangParamOut; + int iCurPeriodSizeOut; +#else + /* Dummy definitions */ + void SetInNumBuf(int iNewNum) {} + int GetInNumBuf() {return 1;} + void SetOutNumBuf(int iNewNum) {} + int GetOutNumBuf() {return 1;} + void InitRecording(int iNewBufferSize, bool bNewBlocking = true) {printf("no sound!");} + void InitPlayback(int iNewBufferSize, bool bNewBlocking = false) {printf("no sound!");} + bool Read(CVector& psData) {printf("no sound!"); return false;} + bool Write(CVector& psData) {printf("no sound!"); return false;} + void Close() {} +#endif +}; + + +#endif // !defined(_SOUND_H__9518A621345F78_3634567_8C0D_EEBF182CF549__INCLUDED_) diff --git a/src/aboutdlgbase.ui b/src/aboutdlgbase.ui new file mode 100755 index 00000000..5e6b2202 --- /dev/null +++ b/src/aboutdlgbase.ui @@ -0,0 +1,281 @@ + +CAboutDlgBase + + QDialog + + name + CAboutDlgBase + + + geometry + + 0 + 0 + 546 + 423 + + + + sizePolicy + + 1 + 1 + + + + caption + About llcon + + + icon + image0 + + + sizeGripEnabled + true + + + layoutMargin + + + layoutSpacing + + + + margin + 11 + + + spacing + 6 + + + QLayoutWidget + + name + Layout21 + + + + margin + 0 + + + spacing + 6 + + + QLabel + + name + PixmapLabelDreamLogo + + + sizePolicy + + 0 + 0 + + + + pixmap + image1 + + + scaledContents + true + + + + QLabel + + name + TextLabelVersion + + + sizePolicy + + 7 + 5 + + + + text + TextLabelVersion + + + alignment + AlignCenter + + + hAlign + + + + + + QLayoutWidget + + name + Layout8 + + + + margin + 0 + + + spacing + 6 + + + QLayoutWidget + + name + Layout16 + + + + margin + 0 + + + spacing + 6 + + + QLabel + + name + TextLabelAuthorNames + + + text + Author: Volker Fischer + + + + QLabel + + name + TextLabelCopyright + + + text + Copyright (C) 2005 - 2006 + + + + + + + name + Spacer10 + + + orientation + Horizontal + + + sizeType + Expanding + + + sizeHint + + 20 + 20 + + + + + + + QTextView + + name + TextViewCredits + + + text + TextViewCredits + + + + QLayoutWidget + + name + Layout6 + + + + margin + 0 + + + spacing + 6 + + + + name + Spacer12 + + + orientation + Horizontal + + + sizeType + Expanding + + + sizeHint + + 20 + 20 + + + + + QPushButton + + name + buttonOk + + + text + &OK + + + autoDefault + true + + + default + true + + + + + + + + + image0 + 789cd3d7528808f055d0d2e72a2e492cc94c5648ce482c52d04a29cdcdad8c8eb5ade6523234530022130543251d2ea5248564056503300071f5205c0b2004719541dcb434986c22840b0260c56800454c9918b1c444e54454b1c4c4a424e5a4c4442431a0085008081231c4949511621021656565b042843a908032bade24a832547b21c6a1ba0f08d0fda18ccd6fd8c2009f58ad351700407358e1 + + + image1 + 789cd3d7528808f055d0d2e72a2e492cc94c5648ce482c52d04a29cdcdad8c8eb5ade6523234530022130543251d2ea5248564056503300071f5205c0b2004719541dcb434986c22840b0260c56800454c9918b1c444e54454b1c4c4a424e5a4c4442431a0085008081231c4949511621021656565b042843a908032bade24a832547b21c6a1ba0f08d0fda18ccd6fd8c2009f58ad351700407358e1 + + + + + buttonOk + clicked() + CAboutDlgBase + accept() + + + diff --git a/src/audiocompr.cpp b/src/audiocompr.cpp new file mode 100755 index 00000000..c90fe72c --- /dev/null +++ b/src/audiocompr.cpp @@ -0,0 +1,255 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer, Erik de Castro Lopo + * + * This code is based on the Open-Source implementation of IMA-ADPCM written + * by Erik de Castro Lopo in 1999-2004 + * + * Changes: + * - only support for one channel + * - put 2 audio samples in header to get even number of audio samples encoded + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "audiocompr.h" + + +/* Implementation *************************************************************/ +int CAudioCompression::Init(const int iNewAudioLen, + const EAudComprType eNewAuCoTy) +{ + eAudComprType = eNewAuCoTy; + + switch (eNewAuCoTy) + { + case CT_NONE: return iCodeSize = 2 * iNewAudioLen; /* short = 2 * byte */ + case CT_IMAADPCM: return ImaAdpcm.Init(iNewAudioLen); + default: return 0; + } +} + +CVector CAudioCompression::Encode(const CVector& vecsAudio) +{ + if (eAudComprType == CT_NONE) + { + /* no compression, simply ship pure samples */ + CVector vecbyOut(iCodeSize); + const int iAudSize = iCodeSize / 2; + + for (int i = 0; i < iAudSize; i++) + { + vecbyOut[2 * i] = vecsAudio[i] & 0xFF; + vecbyOut[2 * i + 1] = (vecsAudio[i] >> 8) & 0xFF; + } + return vecbyOut; + } + else + { + switch (eAudComprType) + { + case CT_IMAADPCM: return ImaAdpcm.Encode(vecsAudio); /* IMA-ADPCM */ + default: return CVector(0); + } + } +} + +CVector CAudioCompression::Decode(const CVector& vecbyAdpcm) +{ + if (eAudComprType == CT_NONE) + { + /* no compression, reassemble pure samples */ + const int iAudSize = iCodeSize / 2; + CVector vecsOut(iAudSize); + + for (int i = 0; i < iAudSize; i++) + { + int current = vecbyAdpcm[2 * i] | (vecbyAdpcm[2 * i + 1] << 8); + if (current & 0x8000) + current -= 0x10000; + + vecsOut[i] = (short) current; + } + return vecsOut; + } + else + { + switch (eAudComprType) + { + case CT_IMAADPCM: return ImaAdpcm.Decode(vecbyAdpcm); /* IMA-ADPCM */ + default: return CVector(0); + } + } +} + + +/* IMA-ADPCM implementation ------------------------------------------------- */ +int CImaAdpcm::Init(const int iNewAudioLen) +{ + /* set lengths for audio and compressed data */ + iAudSize = iNewAudioLen; + iAdpcmSize = 4 /* bytes header */ + (int) ceil( + (double) (iAudSize - 2 /* first two samples are in header */) / 2); + + iStepindEnc = 0; + + return iAdpcmSize; +} + +CVector CImaAdpcm::Encode(const CVector& vecsAudio) +{ + int i; + CVector vecbyAdpcm; + CVector vecbyAdpcmTemp; + + /* init size */ + vecbyAdpcm.Init(iAdpcmSize); + vecbyAdpcmTemp.Init(iAudSize); + + /* encode the block header ----------------------------------------------- */ + vecbyAdpcm[0] = vecsAudio[0] & 0xFF; + vecbyAdpcm[1] = (vecsAudio[0] >> 8) & 0xFF; + vecbyAdpcm[2] = iStepindEnc; + + int iPrevAudio = vecsAudio[0]; + + + /* encode the samples as 4 bit ------------------------------------------- */ + for (i = 1; i < iAudSize; i++) + { + /* init diff and step */ + int diff = vecsAudio[i] - iPrevAudio; + int step = ima_step_size[iStepindEnc]; + + short bytecode = 0; + + int vpdiff = step >> 3; + if (diff < 0) + { + bytecode = 8; + diff = -diff; + } + short mask = 4; + while (mask) + { + if (diff >= step) + { + bytecode |= mask; + diff -= step; + vpdiff += step; + } + step >>= 1; + mask >>= 1; + } + + if (bytecode & 8) + iPrevAudio -= vpdiff; + else + iPrevAudio += vpdiff; + + /* adjust step size */ + iStepindEnc += ima_indx_adjust[bytecode]; + + /* check that values do not exceed the bounds */ + iPrevAudio = CheckBounds(iPrevAudio, _MINSHORT, _MAXSHORT); + iStepindEnc = CheckBounds(iStepindEnc, 0, IMA_STEP_SIZE_TAB_LEN - 1); + + /* use the input buffer as an intermediate result buffer */ + vecbyAdpcmTemp[i] = bytecode; + } + + + /* pack the 4 bit encoded samples ---------------------------------------- */ + /* The first encoded audio sample is in header */ + vecbyAdpcm[3] = vecbyAdpcmTemp[1] & 0x0F; + + for (i = 4; i < iAdpcmSize; i++) + { + vecbyAdpcm[i] = vecbyAdpcmTemp[2 * i - 6] & 0x0F; + vecbyAdpcm[i] |= (vecbyAdpcmTemp[2 * i - 5] << 4) & 0xF0; + } + + return vecbyAdpcm; +} + +CVector CImaAdpcm::Decode(const CVector& vecbyAdpcm) +{ + int i; + CVector vecsAudio; + + vecsAudio.Init(iAudSize); + + + /* read and check the block header --------------------------------------- */ + int current = vecbyAdpcm[0] | (vecbyAdpcm[1] << 8); + if (current & 0x8000) + current -= 0x10000; + + /* get and bound step index */ + int iStepindDec = CheckBounds(vecbyAdpcm[2], 0, IMA_STEP_SIZE_TAB_LEN - 1); + + /* set first sample which was delivered in the header */ + vecsAudio[0] = current; + + + /* -------------------------------------------------------------------------- + pull apart the packed 4 bit samples and store them in their correct sample + positions */ + /* The first encoded audio sample is in header */ + vecsAudio[1] = vecbyAdpcm[3] & 0x0F; + + for (i = 4; i < iAdpcmSize; i++) + { + const short bytecode = vecbyAdpcm[i]; + vecsAudio[2 * i - 6] = bytecode & 0x0F; + vecsAudio[2 * i - 5] = (bytecode >> 4) & 0x0F; + } + + + /* decode the encoded 4 bit samples -------------------------------------- */ + for (i = 1; i < iAudSize; i++) + { + const short bytecode = vecsAudio[i] & 0xF ; + + short step = ima_step_size[iStepindDec]; + int current = vecsAudio[i - 1]; + + int diff = step >> 3; + if (bytecode & 1) + diff += step >> 2; + if (bytecode & 2) + diff += step >> 1; + if (bytecode & 4) + diff += step; + if (bytecode & 8) + diff = -diff; + + current += diff; + iStepindDec += ima_indx_adjust[bytecode]; + + /* check that values do not exceed the bounds */ + current = CheckBounds(current, _MINSHORT, _MAXSHORT); + iStepindDec = CheckBounds(iStepindDec, 0, IMA_STEP_SIZE_TAB_LEN - 1); + + vecsAudio[i] = current; + } + + return vecsAudio; +} diff --git a/src/audiocompr.h b/src/audiocompr.h new file mode 100755 index 00000000..8117c846 --- /dev/null +++ b/src/audiocompr.h @@ -0,0 +1,104 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer, Erik de Castro Lopo + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#if !defined(AUDIOCOMPR_H_OIHGE76GEKJH3249_GEG98EG3_43441912__INCLUDED_) +#define AUDIOCOMPR_H_OIHGE76GEKJH3249_GEG98EG3_43441912__INCLUDED_ + +#include "util.h" +#include "global.h" +#include "buffer.h" + + +/* Definitions ****************************************************************/ +/* tables */ +static int ima_indx_adjust[16] = +{ -1, -1, -1, -1, /* +0 - +3, decrease the step size */ + 2, 4, 6, 8, /* +4 - +7, increase the step size */ + -1, -1, -1, -1, /* -0 - -3, decrease the step size */ + 2, 4, 6, 8, /* -4 - -7, increase the step size */ +}; + +#define IMA_STEP_SIZE_TAB_LEN 89 +static int ima_step_size[IMA_STEP_SIZE_TAB_LEN] = +{ 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, + 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, + 253, 279, 307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963, + 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, + 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493, 10442, + 11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, + 32767 +}; + + +/* Classes ********************************************************************/ +/* IMA-ADPCM ---------------------------------------------------------------- */ +class CImaAdpcm +{ +public: + CImaAdpcm() : iStepindEnc(0) {} + virtual ~CImaAdpcm() {} + + int Init(const int iNewAudioLen); + CVector Encode(const CVector& vecsAudio); + CVector Decode(const CVector& vecbyAdpcm); + +protected: + int iAudSize; + int iAdpcmSize; + int iStepindEnc; + + /* inline functions must be declared in the header */ + inline int CheckBounds(const int iData, const int iMin, const int iMax) + { + if (iData > iMax) + return iMax; + if (iData < iMin) + return iMin; + + return iData; + } +}; + + +/* Audio compression class -------------------------------------------------- */ +class CAudioCompression +{ +public: + enum EAudComprType {CT_NONE, CT_IMAADPCM}; + + CAudioCompression() {} + virtual ~CAudioCompression() {} + + int Init(const int iNewAudioLen, const EAudComprType eNewAuCoTy); + CVector Encode(const CVector& vecsAudio); + CVector Decode(const CVector& vecbyAdpcm); + +protected: + EAudComprType eAudComprType; + CImaAdpcm ImaAdpcm; + int iCodeSize; +}; + + +#endif /* !defined(AUDIOCOMPR_H_OIHGE76GEKJH3249_GEG98EG3_43441912__INCLUDED_) */ diff --git a/src/buffer.cpp b/src/buffer.cpp new file mode 100755 index 00000000..57d16fd8 --- /dev/null +++ b/src/buffer.cpp @@ -0,0 +1,381 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + * Note: we assuming here that put and get operations are secured by a mutex + * and do not take place at the same time + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "buffer.h" + + +/* Implementation *************************************************************/ +void CNetBuf::Init ( const int iNewBlockSize, const int iNewNumBlocks ) +{ + /* total size -> size of one block times number of blocks */ + iBlockSize = iNewBlockSize; + iMemSize = iNewBlockSize * iNewNumBlocks; + + /* fade in first block added to the buffer */ + bFadeInNewPutData = true; + + /* allocate and clear memory for actual data buffer */ + vecdMemory.Init(iMemSize); + + /* use the "get" flag to make sure the buffer is cleared */ + Clear(CT_GET); + + /* initialize number of samples for fading effect */ + if (FADE_IN_OUT_NUM_SAM < iBlockSize) + iNumSamFading = iBlockSize; + else + iNumSamFading = FADE_IN_OUT_NUM_SAM; + + if (FADE_IN_OUT_NUM_SAM_EXTRA > iBlockSize) + iNumSamFadingExtra = iBlockSize; + else + iNumSamFadingExtra = FADE_IN_OUT_NUM_SAM; + + /* init variables for extrapolation (in case a fade out is needed) */ + dExPDiff = 0.0; + dExPLastV = 0.0; +} + +bool CNetBuf::Put(CVector& vecdData) +{ +#ifdef _DEBUG_ +static FILE* pFileBI = fopen("bufferin.dat", "w"); +fprintf(pFileBI, "%d %d\n", GetAvailSpace() / iBlockSize, iMemSize / iBlockSize); +fflush(pFileBI); +#endif + + bool bPutOK = true; + + /* get size of data to be added to the buffer */ + const int iInSize = vecdData.Size(); + + /* Check if there is not enough space available -> correct */ + if (GetAvailSpace() < iInSize) + { + /* not enough space in buffer for put operation, correct buffer to + prepare for new data */ + Clear(CT_PUT); + + /* set flag to fade in new block to avoid clicks */ + bFadeInNewPutData = true; + + bPutOK = false; /* return error flag */ + } + + /* fade in new block if required */ + if (bFadeInNewPutData) + FadeInAudioDataBlock(vecdData); + + /* copy new data in internal buffer */ + int iCurPos = 0; + if (iPutPos + iInSize > iMemSize) + { + /* remaining space size for second block */ + const int iRemSpace = iPutPos + iInSize - iMemSize; + + /* data must be written in two steps because of wrap around */ + while (iPutPos < iMemSize) + vecdMemory[iPutPos++] = vecdData[iCurPos++]; + + for (iPutPos = 0; iPutPos < iRemSpace; iPutPos++) + vecdMemory[iPutPos] = vecdData[iCurPos++]; + } + else + { + /* data can be written in one step */ + const int iEnd = iPutPos + iInSize; + while (iPutPos < iEnd) + vecdMemory[iPutPos++] = vecdData[iCurPos++]; + } + + /* set buffer state flag */ + if (iPutPos == iGetPos) + eBufState = CNetBuf::BS_FULL; + else + eBufState = CNetBuf::BS_OK; + + return bPutOK; +} + +bool CNetBuf::Get(CVector& vecdData) +{ + bool bGetOK = true; /* init return value */ + bool bFadeOutExtrap = false; + + /* get size of data to be get from the buffer */ + const int iInSize = vecdData.Size(); + + /* Check if there is not enough data available -> correct */ + if (GetAvailData() < iInSize) + { + /* not enough data in buffer for get operation, correct buffer to + prepare for getting data */ + Clear(CT_GET); + + /* set flag to fade in next new block in buffer and fade out last + block by extrapolation to avoid clicks */ + bFadeInNewPutData = true; + bFadeOutExtrap = true; + + bGetOK = false; /* return error flag */ + } + + /* copy data from internal buffer in output buffer */ + int iCurPos = 0; + if (iGetPos + iInSize > iMemSize) + { + /* remaining data size for second block */ + const int iRemData = iGetPos + iInSize - iMemSize; + + /* data must be read in two steps because of wrap around */ + while (iGetPos < iMemSize) + vecdData[iCurPos++] = vecdMemory[iGetPos++]; + + for (iGetPos = 0; iGetPos < iRemData; iGetPos++) + vecdData[iCurPos++] = vecdMemory[iGetPos]; + } + else + { + /* data can be read in one step */ + const int iEnd = iGetPos + iInSize; + while (iGetPos < iEnd) + vecdData[iCurPos++] = vecdMemory[iGetPos++]; + } + + /* set buffer state flag */ + if (iPutPos == iGetPos) + eBufState = CNetBuf::BS_EMPTY; + else + eBufState = CNetBuf::BS_OK; + + + /* extrapolate data from old block to avoid "clicks" + we have to do this method since we cannot fade out the old block + anymore since it is already gone (processed or send through the + network) */ + if (bFadeOutExtrap) + FadeOutExtrapolateAudioDataBlock(vecdData, dExPDiff, dExPLastV); + + /* save some paramters from last block which is needed in case we do not + have enough data for next "get" operation and need to extrapolate the + signal to avoid "clicks" + we assume here that "iBlockSize" is larger than 1! */ + dExPDiff = vecdData[iInSize - 1] - vecdData[iInSize - 2]; + dExPLastV = vecdData[iInSize - 1]; + + return bGetOK; +} + +int CNetBuf::GetAvailSpace() const +{ + /* calculate available space in buffer */ + int iAvSpace = iGetPos - iPutPos; + + /* check for special case and wrap around */ + if (iAvSpace < 0) + iAvSpace += iMemSize; /* wrap around */ + else if ((iAvSpace == 0) && (eBufState == BS_EMPTY)) + iAvSpace = iMemSize; + + return iAvSpace; +} + +int CNetBuf::GetAvailData() const +{ + /* calculate available data in buffer */ + int iAvData = iPutPos - iGetPos; + + /* check for special case and wrap around */ + if (iAvData < 0) + iAvData += iMemSize; /* wrap around */ + else if ((iAvData == 0) && (eBufState == BS_FULL)) + iAvData = iMemSize; + + return iAvData; +} + +void CNetBuf::Clear(const EClearType eClearType) +{ + + int iMiddleOfBuffer; + +#if 0 + /* with the following operation we set the new get pos to a block + boundary (one block below the middle of the buffer in case of odd + number of blocks, e.g.: + [buffer size]: [get pos] + 1: 0 / 2: 0 / 3: 1 / 4: 1 / ... */ + iMiddleOfBuffer = (((iMemSize - iBlockSize) / 2) / iBlockSize) * iBlockSize; +#else +// old code + +// somehow the old code seems to work better than the sophisticated new one....? + /* 1: 0 / 2: 1 / 3: 1 / 4: 2 / ... */ + iMiddleOfBuffer = ((iMemSize / 2) / iBlockSize) * iBlockSize; +#endif + + + /* different behaviour for get and put corrections */ + if (eClearType == CT_GET) + { + /* clear buffer */ + vecdMemory.Reset(0.0); + + /* correct buffer so that after the current get operation the pointer + are at maximum distance */ + iPutPos = 0; + iGetPos = iMiddleOfBuffer; + + /* check for special case */ + if (iPutPos == iGetPos) + eBufState = CNetBuf::BS_FULL; + else + eBufState = CNetBuf::BS_OK; + } + else + { + /* in case of "put" correction, do not delete old data but only shift + the pointers */ + iPutPos = iMiddleOfBuffer; + + /* adjust put pointer relative to current get pointer, take care of + wrap around */ + iPutPos += iGetPos; + if (iPutPos > iMemSize) + iPutPos -= iMemSize; + + /* fade out old data right before new put pointer */ + int iCurPos = iPutPos - iNumSamFading; + int i = iNumSamFading; + + if (iCurPos < 0) + { + /* wrap around */ + iCurPos += iMemSize; + + /* data must be processed in two steps because of wrap around */ + while (iCurPos < iMemSize) + { + vecdMemory[iCurPos++] *= ((double) i / iNumSamFading); + i--; + } + + for (iCurPos = 0; iCurPos < iPutPos; iCurPos++) + { + vecdMemory[iCurPos] *= ((double) i / iNumSamFading); + i--; + } + } + else + { + /* data can be processed in one step */ + while (iCurPos < iPutPos) + { + vecdMemory[iCurPos++] *= ((double) i / iNumSamFading); + i--; + } + } + + /* check for special case */ + if (iPutPos == iGetPos) + { + eBufState = CNetBuf::BS_EMPTY; + } + else + { + eBufState = CNetBuf::BS_OK; + } + } +} + +void CNetBuf::FadeInAudioDataBlock(CVector& vecdData) +{ + /* apply linear fading */ + for (int i = 0; i < iNumSamFading; i++) + { + vecdData[i] *= ((double) i / iNumSamFading); + } + + /* reset flag */ + bFadeInNewPutData = false; +} + +void CNetBuf::FadeOutExtrapolateAudioDataBlock(CVector& vecdData, + const double dExPDiff, + const double dExPLastV) +{ + /* apply linear extrapolation and linear fading */ + for (int i = 0; i < iNumSamFadingExtra; i++) + { + /* calculate extrapolated value */ + vecdData[i] = ((i + 1) * dExPDiff + dExPLastV); + + /* linear fading */ + vecdData[i] *= ((double) (iNumSamFadingExtra - i) / iNumSamFadingExtra); + } +} + + + +/* conversion buffer implementation *******************************************/ +void CConvBuf::Init ( const int iNewMemSize ) +{ + /* set memory size */ + iMemSize = iNewMemSize; + + /* allocate and clear memory for actual data buffer */ + vecsMemory.Init(iMemSize); + + iPutPos = 0; +} + +bool CConvBuf::Put ( const CVector& vecsData) +{ + const int iVecSize = vecsData.Size(); + + /* copy new data in internal buffer */ + int iCurPos = 0; + const int iEnd = iPutPos + iVecSize; + while ( iPutPos < iEnd ) + { + vecsMemory[iPutPos++] = vecsData[iCurPos++]; + } + + bool bBufOk = false; + if ( iEnd == iMemSize ) + { + bBufOk = true; + } + + return bBufOk; +} + +CVector CConvBuf::Get() +{ + iPutPos = 0; + return vecsMemory; +} diff --git a/src/buffer.h b/src/buffer.h new file mode 100755 index 00000000..7d4c52f6 --- /dev/null +++ b/src/buffer.h @@ -0,0 +1,100 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#if !defined(BUFFER_H__3B123453_4344_BB23945IUHF1912__INCLUDED_) +#define BUFFER_H__3B123453_4344_BB23945IUHF1912__INCLUDED_ + +#include "util.h" +#include "global.h" + + +/* Definitions ****************************************************************/ +/* time for fading effect for masking drop outs */ +#define FADE_IN_OUT_TIME ((double) 0.3) /* ms */ +#define FADE_IN_OUT_NUM_SAM ((int) (SAMPLE_RATE * FADE_IN_OUT_TIME) / 1000) + +/* for extrapolation a shorter time for fading */ +#define FADE_IN_OUT_NUM_SAM_EXTRA 5 /* samples */ + + +/* Classes ********************************************************************/ +class CNetBuf +{ +public: + CNetBuf() {} + virtual ~CNetBuf() {} + + void Init(const int iNewBlockSize, const int iNewNumBlocks); + int GetSize() {return iMemSize / iBlockSize;} + + bool Put(CVector& vecdData); + bool Get(CVector& vecdData); + +protected: + enum EBufState {BS_OK, BS_FULL, BS_EMPTY}; + enum EClearType {CT_PUT, CT_GET}; + void Clear(const EClearType eClearType); + int GetAvailSpace() const; + int GetAvailData() const; + void FadeInAudioDataBlock(CVector& vecdData); + void FadeOutExtrapolateAudioDataBlock(CVector& vecdData, + const double dExPDiff, const double dExPLastV); + + CVector vecdMemory; + int iMemSize; + int iBlockSize; + int iGetPos, iPutPos; + EBufState eBufState; + bool bFadeInNewPutData; + int iNumSamFading; + int iNumSamFadingExtra; + + /* extrapolation parameters */ + double dExPDiff; + double dExPLastV; +}; + + +/* conversion buffer (very simple buffer) */ +class CConvBuf +{ +public: + CConvBuf () {} + virtual ~CConvBuf () {} + + void Init ( const int iNewMemSize ); + int GetSize() { return iMemSize; } + + bool Put ( const CVector& vecsData ); + CVector Get (); + +protected: + CVector vecsMemory; + int iMemSize; + int iBlockSize; + int iPutPos; +}; + + +#endif /* !defined(BUFFER_H__3B123453_4344_BB23945IUHF1912__INCLUDED_) */ diff --git a/src/channel.cpp b/src/channel.cpp new file mode 100755 index 00000000..17790821 --- /dev/null +++ b/src/channel.cpp @@ -0,0 +1,448 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "channel.h" + + +/******************************************************************************\ +* CChannelSet * +\******************************************************************************/ +int CChannelSet::GetFreeChan() +{ + /* look for a free channel */ + for (int i = 0; i < MAX_NUM_CHANNELS; i++) + { + if (!vecChannels[i].IsConnected()) + return i; + } + + /* no free channel found, return invalid ID */ + return INVALID_CHANNEL_ID; +} + +int CChannelSet::CheckAddr(const CHostAddress& Addr) +{ + CHostAddress InetAddr; + + /* Check for all possible channels if IP is already in use */ + for (int i = 0; i < MAX_NUM_CHANNELS; i++) + { + if (vecChannels[i].GetAddress(InetAddr)) + { + /* IP found, return channel number */ + if (InetAddr == Addr) + return i; + } + } + + /* IP not found, return invalid ID */ + return INVALID_CHANNEL_ID; +} + +bool CChannelSet::PutData(const CVector& vecbyRecBuf, + const int iNumBytesRead, const CHostAddress& HostAdr) +{ + Mutex.lock(); + + /* get channel ID ------------------------------------------------------- */ + bool bChanOK = true; + + /* check address */ + int iCurChanID = CheckAddr(HostAdr); + + if (iCurChanID == INVALID_CHANNEL_ID) + { + /* a new client is calling, look for free channel */ + iCurChanID = GetFreeChan(); + + if (iCurChanID != INVALID_CHANNEL_ID) + vecChannels[iCurChanID].SetAddress(HostAdr); + else + bChanOK = false; /* no free channel available */ + } + + + /* put received data in jitter buffer ----------------------------------- */ + if (bChanOK) + { + /* put packet in socket buffer */ + if (vecChannels[iCurChanID].PutData(vecbyRecBuf, iNumBytesRead)) + PostWinMessage(MS_JIT_BUF_PUT, MUL_COL_LED_GREEN, iCurChanID); + else + PostWinMessage(MS_JIT_BUF_PUT, MUL_COL_LED_RED, iCurChanID); + } + + Mutex.unlock(); + + return !bChanOK; /* return 1 if error */ +} + +void CChannelSet::GetBlockAllConC(CVector& vecChanID, + CVector >& vecvecdData) +{ + /* init temporal data vector and clear input buffers */ + CVector vecdData(BLOCK_SIZE_SAMPLES); + + vecChanID.Init(0); + vecvecdData.Init(0); + + /* make put and get calls thread safe. Do not forget to unlock mutex + afterwards! */ + Mutex.lock(); + + /* Check all possible channels */ + for (int i = 0; i < MAX_NUM_CHANNELS; i++) + { + /* read out all input buffers to decrease timeout counter on + disconnected channels */ + bool bGetOK = vecChannels[i].GetData(vecdData); + + if (vecChannels[i].IsConnected()) + { + /* add ID and data */ + vecChanID.Add(i); + + const int iOldSize = vecvecdData.Size(); + vecvecdData.Enlarge(1); + vecvecdData[iOldSize].Init(vecdData.Size()); + vecvecdData[iOldSize] = vecdData; + + /* send message for get status (for GUI) */ + if (bGetOK) + PostWinMessage(MS_JIT_BUF_GET, MUL_COL_LED_GREEN, i); + else + PostWinMessage(MS_JIT_BUF_GET, MUL_COL_LED_RED, i); + } + } + + Mutex.unlock(); /* release mutex */ +} + +void CChannelSet::GetConCliParam(CVector& vecHostAddresses, + CVector& vecdSamOffs) +{ + CHostAddress InetAddr; + + /* init return values */ + vecHostAddresses.Init(MAX_NUM_CHANNELS); + vecdSamOffs.Init(MAX_NUM_CHANNELS); + + /* Check all possible channels */ + for (int i = 0; i < MAX_NUM_CHANNELS; i++) + { + if (vecChannels[i].GetAddress(InetAddr)) + { + /* add new address and sample rate offset to vectors */ + vecHostAddresses[i] = InetAddr; + vecdSamOffs[i] = vecChannels[i].GetResampleOffset(); + } + } +} + +void CChannelSet::SetSockBufSize ( const int iNewBlockSize, const int iNumBlocks ) +{ + /* this opperation must be done with mutex */ + Mutex.lock (); + +/* as a test we adjust the buffers of all channels to the new value. Maybe later + do change only for some channels -> take care to set value back to default if + channel is disconnected, afterwards! */ +for ( int i = 0; i < MAX_NUM_CHANNELS; i++ ) + vecChannels[i].SetSockBufSize ( iNewBlockSize, iNumBlocks ); + + Mutex.unlock (); +} + + +/******************************************************************************\ +* CChannel * +\******************************************************************************/ +CChannel::CChannel() +{ + /* init time stamp activation counter */ + iTimeStampActCnt = NUM_BL_TIME_STAMPS; + + /* init time stamp index counter */ + byTimeStampIdxCnt = 0; + + /* init the socket buffer */ + SetSockBufSize ( BLOCK_SIZE_SAMPLES, DEF_NET_BUF_SIZE_NUM_BL ); + + /* init conversion buffer */ + ConvBuf.Init ( BLOCK_SIZE_SAMPLES ); + + /* init audio compression unit */ + iAudComprSize = AudioCompression.Init ( BLOCK_SIZE_SAMPLES, + CAudioCompression::CT_IMAADPCM ); + + /* init time-out for the buffer with zero -> no connection */ + iConTimeOut = 0; + + /* init sample rate offset estimation object */ + SampleOffsetEst.Init(); +} + +void CChannel::SetSockBufSize ( const int iNewBlockSize, const int iNumBlocks ) +{ + /* this opperation must be done with mutex */ + Mutex.lock (); + + SockBuf.Init ( iNewBlockSize, iNumBlocks ); + + Mutex.unlock (); +} + +int CChannel::GetTimeStampIdx () +{ + /* only send time stamp index after a pre-defined number of packets */ + if ( iTimeStampActCnt > 0 ) + { + iTimeStampActCnt--; + return INVALID_TIME_STAMP_IDX; + } + else + { + /* reset time stamp activation counter */ + iTimeStampActCnt = NUM_BL_TIME_STAMPS - 1; + + /* wraps around automatically */ + byTimeStampIdxCnt++; + return byTimeStampIdxCnt; + } +} + +bool CChannel::GetAddress(CHostAddress& RetAddr) +{ + if (IsConnected()) + { + RetAddr = InetAddr; + return true; + } + else + { + RetAddr = CHostAddress(); + return false; + } +} + +bool CChannel::PutData(const CVector& vecbyData, + int iNumBytes) +{ + bool bRet = true; + + Mutex.lock(); /* put mutex lock */ + + /* only process if packet has correct size */ + if (iNumBytes == iAudComprSize) + { + /* decompress audio */ + CVector vecsDecomprAudio(BLOCK_SIZE_SAMPLES); + vecsDecomprAudio = AudioCompression.Decode(vecbyData); + + /* do resampling to compensate for sample rate offsets in the + different sound cards of the clients */ +// we should not do resampling here since we already have resampling +// in the client audio path, we could use this resampling for this +// sample rate correction, too +/* +for (int i = 0; i < BLOCK_SIZE_SAMPLES; i++) + vecdResInData[i] = (double) vecsData[i]; + +const int iInSize = ResampleObj.Resample(vecdResInData, vecdResOutData, + (double) SAMPLE_RATE / (SAMPLE_RATE - dSamRateOffset)); +*/ + +vecdResOutData.Init(BLOCK_SIZE_SAMPLES); +for (int i = 0; i < BLOCK_SIZE_SAMPLES; i++) + vecdResOutData[i] = (double) vecsDecomprAudio[i]; + + + bRet = SockBuf.Put(vecdResOutData); + + /* reset time-out counter */ + iConTimeOut = CON_TIME_OUT_CNT_MAX; + } + else if (iNumBytes == 1) + { + /* time stamp packet */ + SampleOffsetEst.AddTimeStampIdx(vecbyData[0]); + } + else + bRet = false; /* wrong packet size */ + + Mutex.unlock(); /* put mutex unlock */ + + return bRet; +} + +bool CChannel::GetData(CVector& vecdData) +{ + Mutex.lock(); /* get mutex lock */ + + const bool bGetOK = SockBuf.Get(vecdData); + + if (!bGetOK) + { + /* decrease time-out counter */ + if (iConTimeOut > 0) + { + iConTimeOut--; + + /* if time out is reached, re-init resample offset estimation + module */ + if (iConTimeOut == 0) + SampleOffsetEst.Init(); + } + } + + Mutex.unlock(); /* get mutex unlock */ + + return bGetOK; +} + +CVector CChannel::PrepSendPacket(const CVector& vecsNPacket) +{ + /* if the block is not ready we have to initialize with zero length to + tell the following network send routine that nothing should be sent */ + CVector vecbySendBuf ( 0 ); + + /* use conversion buffer to convert sound card block size in network + block size */ + if ( ConvBuf.Put ( vecsNPacket ) ) + { + /* a packet is ready, compress audio */ + vecbySendBuf.Init ( iAudComprSize ); + vecbySendBuf = AudioCompression.Encode ( ConvBuf.Get () ); + } + + return vecbySendBuf; +} + + + +/******************************************************************************\ +* CSampleOffsetEst * +\******************************************************************************/ +void CSampleOffsetEst::Init() +{ + /* init sample rate estimation */ + dSamRateEst = SAMPLE_RATE; + + /* init vectors storing the data */ + veciTimeElapsed.Init(VEC_LEN_SAM_OFFS_EST); + veciTiStIdx.Init(VEC_LEN_SAM_OFFS_EST); + + /* start reference time (the counter wraps to zero 24 hours after the last + call to start() or restart, but this should not concern us since this + software will most probably not be used that long) */ + RefTime.start(); + + /* init accumulated time stamp variable */ + iAccTiStVal = 0; + + /* init count (do not ship any result in init phase) */ + iInitCnt = VEC_LEN_SAM_OFFS_EST + 1; +} + +void CSampleOffsetEst::AddTimeStampIdx(const int iTimeStampIdx) +{ + int i; + + const int iLastIdx = VEC_LEN_SAM_OFFS_EST - 1; + + /* take care of wrap of the time stamp index (byte wrap) */ + if (iTimeStampIdx < veciTiStIdx[iLastIdx] - iAccTiStVal) + iAccTiStVal += _MAXBYTE + 1; + + /* add new data pair to the FIFO */ + for (i = 1; i < VEC_LEN_SAM_OFFS_EST; i++) + { + /* move old data */ + veciTimeElapsed[i - 1] = veciTimeElapsed[i]; + veciTiStIdx[i - 1] = veciTiStIdx[i]; + } + + /* add new data */ + veciTimeElapsed[iLastIdx] = RefTime.elapsed(); + veciTiStIdx[iLastIdx] = iAccTiStVal + iTimeStampIdx; + +/* +static FILE* pFile = fopen("v.dat", "w"); +for (i = 0; i < VEC_LEN_SAM_OFFS_EST; i++) + fprintf(pFile, "%d\n", veciTimeElapsed[i]); +fflush(pFile); +*/ + + + + + /* calculate linear regression for sample rate estimation */ + /* first, calculate averages */ + double dTimeAv = 0; + double dTiStAv = 0; + for (i = 0; i < VEC_LEN_SAM_OFFS_EST; i++) + { + dTimeAv += veciTimeElapsed[i]; + dTiStAv += veciTiStIdx[i]; + } + dTimeAv /= VEC_LEN_SAM_OFFS_EST; + dTiStAv /= VEC_LEN_SAM_OFFS_EST; + + /* calculate gradient */ + double dNom = 0; + double dDenom = 0; + for (i = 0; i < VEC_LEN_SAM_OFFS_EST; i++) + { + const double dCurTimeNoAv = veciTimeElapsed[i] - dTimeAv; + dNom += dCurTimeNoAv * (veciTiStIdx[i] - dTiStAv); + dDenom += dCurTimeNoAv * dCurTimeNoAv; + } + + /* final sample rate offset estimation calculation */ + if (iInitCnt > 0) + iInitCnt--; + else + { + dSamRateEst = dNom / dDenom * NUM_BL_TIME_STAMPS * BLOCK_SIZE_SAMPLES * 1000; + +/* +static FILE* pFile = fopen("v.dat", "w"); +for (i = 0; i < VEC_LEN_SAM_OFFS_EST; i++) + fprintf(pFile, "%d %d\n", veciTimeElapsed[i], veciTiStIdx[i]); +fflush(pFile); +*/ + } + + + +/* +static FILE* pFile = fopen("v.dat", "w"); +fprintf(pFile, "%e\n", dSamRateEst); +fflush(pFile); +*/ + + + + +} diff --git a/src/channel.h b/src/channel.h new file mode 100755 index 00000000..e535c95f --- /dev/null +++ b/src/channel.h @@ -0,0 +1,169 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#if !defined(CHANNEL_HOIH9345KJH98_3_4344_BB23945IUHF1912__INCLUDED_) +#define CHANNEL_HOIH9345KJH98_3_4344_BB23945IUHF1912__INCLUDED_ + +#include +#include "global.h" +#include "buffer.h" +#include "audiocompr.h" +#include "util.h" +#include "resample.h" +#include "qdatetime.h" + + +/* Definitions ****************************************************************/ +/* Set the time-out for the input buffer until the state changes from + connected to not-connected (the actual time depends on the way the error + correction is implemented) */ +#define CON_TIME_OUT_CNT_MAX 50 + +/* maximum number of internet connections (channels) */ +#define MAX_NUM_CHANNELS 10 /* max number channels for server */ + +/* no valid channel number */ +#define INVALID_CHANNEL_ID (MAX_NUM_CHANNELS + 1) + +/* no valid time stamp index */ +#define INVALID_TIME_STAMP_IDX -1 + + +/* Classes ********************************************************************/ +class CSampleOffsetEst +{ +public: + CSampleOffsetEst() {Init();} + virtual ~CSampleOffsetEst() {} + + void Init(); + void AddTimeStampIdx(const int iTimeStampIdx); + double GetSamRate() {return dSamRateEst;} + +protected: + QTime RefTime; + int iAccTiStVal; + double dSamRateEst; + CVector veciTimeElapsed; + CVector veciTiStIdx; + int iInitCnt; +}; + + +/* CChannel ----------------------------------------------------------------- */ +class CChannel +{ +public: + CChannel(); + virtual ~CChannel() {} + + bool PutData(const CVector& vecbyData, + int iNumBytes); + bool GetData(CVector& vecdData); + + CVector PrepSendPacket(const CVector& vecsNPacket); + + bool GetAddress(CHostAddress& RetAddr); + CHostAddress GetAddress() {return InetAddr;} + int GetTimeStampIdx(); + void SetAddress(const CHostAddress NAddr) {InetAddr = NAddr;} + bool IsConnected() const {return iConTimeOut > 0;} + int GetComprAudSize() {return iAudComprSize;} + double GetResampleOffset() {return SampleOffsetEst.GetSamRate();} + void SetSockBufSize ( const int iNewBlockSize, const int iNumBlocks ); + int GetSockBufSize() {return SockBuf.GetSize();} + +protected: + /* audio compression */ + CAudioCompression AudioCompression; + int iAudComprSize; + + /* resampling */ + CResample ResampleObj; + double dSamRateOffset; + CVector vecdResInData; + CVector vecdResOutData; + + CSampleOffsetEst SampleOffsetEst; + + /* connection parameters */ + CHostAddress InetAddr; + + /* network jitter-buffer */ + CNetBuf SockBuf; + + /* network output conversion buffer */ + CConvBuf ConvBuf; + + /* time stamp index counter */ + Q_UINT8 byTimeStampIdxCnt; + int iTimeStampActCnt; + + int iConTimeOut; + + QMutex Mutex; +}; + + +/* CChannelSet (for server) ------------------------------------------------- */ +class CChannelSet +{ +public: + CChannelSet() {} + virtual ~CChannelSet() {} + + bool PutData(const CVector& vecbyRecBuf, + const int iNumBytesRead, const CHostAddress& HostAdr); + + int GetFreeChan(); + int CheckAddr(const CHostAddress& Addr); + + void GetBlockAllConC(CVector& vecChanID, + CVector >& vecvecdData); + void GetConCliParam(CVector& vecHostAddresses, + CVector& vecdSamOffs); + + /* access functions for actual channels */ + bool IsConnected(const int iChanNum) + {return vecChannels[iChanNum].IsConnected();} + CVector PrepSendPacket(const int iChanNum, + const CVector& vecsNPacket) + {return vecChannels[iChanNum].PrepSendPacket(vecsNPacket);} + CHostAddress GetAddress(const int iChanNum) + {return vecChannels[iChanNum].GetAddress();} + int GetTimeStampIdx(const int iChanNum) + {return vecChannels[iChanNum].GetTimeStampIdx();} + + void SetSockBufSize ( const int iNewBlockSize, const int iNumBlocks); + int GetSockBufSize() {return vecChannels[0].GetSockBufSize();} + +protected: + /* do not use the vector class since CChannel does not have appropriate + copy constructor/operator */ + CChannel vecChannels[MAX_NUM_CHANNELS]; + QMutex Mutex; +}; + + +#endif /* !defined(CHANNEL_HOIH9345KJH98_3_4344_BB23945IUHF1912__INCLUDED_) */ diff --git a/src/client.cpp b/src/client.cpp new file mode 100755 index 00000000..0d2dceb8 --- /dev/null +++ b/src/client.cpp @@ -0,0 +1,317 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "client.h" + + +/* Implementation *************************************************************/ +bool CClient::SetServerAddr(QString strNAddr) +{ + QHostAddress InetAddr; + + if (InetAddr.setAddress(strNAddr)) + { + /* The server port is fixed and always the same */ + Channel.SetAddress(CHostAddress(InetAddr, LLCON_PORT_NUMBER)); + + return true; + } + else + return false; /* invalid address */ +} + +void CClient::Init() +{ + /* set block sizes (in samples) */ + iBlockSizeSam = MIN_BLOCK_SIZE_SAMPLES; + iSndCrdBlockSizeSam = MIN_SND_CRD_BLOCK_SIZE_SAMPLES; + + vecsAudioSndCrd.Init(iSndCrdBlockSizeSam * 2); /* stereo */ + vecdAudioSndCrdL.Init(iSndCrdBlockSizeSam); + vecdAudioSndCrdR.Init(iSndCrdBlockSizeSam); + + vecdAudioL.Init(iBlockSizeSam); + vecdAudioR.Init(iBlockSizeSam); + + Sound.InitRecording(iSndCrdBlockSizeSam * 2 /* stereo */); + Sound.InitPlayback(iSndCrdBlockSizeSam * 2 /* stereo */); + + /* resample objects are always initialized with the input block size */ + /* record */ + ResampleObjDownL.Init(iSndCrdBlockSizeSam, + (double) SAMPLE_RATE / SND_CRD_SAMPLE_RATE); + ResampleObjDownR.Init(iSndCrdBlockSizeSam, + (double) SAMPLE_RATE / SND_CRD_SAMPLE_RATE); + + /* playback */ + ResampleObjUpL.Init(iBlockSizeSam, + (double) SND_CRD_SAMPLE_RATE / SAMPLE_RATE); + ResampleObjUpR.Init(iBlockSizeSam, + (double) SND_CRD_SAMPLE_RATE / SAMPLE_RATE); + + /* init network buffers */ + vecsNetwork.Init(iBlockSizeSam); + vecdNetwData.Init(iBlockSizeSam); + + /* init moving average buffer for response time evaluation */ + RespTimeMoAvBuf.Init(LEN_MOV_AV_RESPONSE); + + /* init time for response time evaluation */ + TimeLastBlock = QTime::currentTime(); + + AudioReverb.Clear(); +} + +void CClient::run() +{ + int i, iInCnt; + + /* Set thread priority (The working thread should have a higher + priority than the GUI) */ +#ifdef _WIN32 + SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL); +#else + /* set the process to realtime privs */ + struct sched_param schp; + memset(&schp, 0, sizeof(schp)); + schp.sched_priority = sched_get_priority_max(SCHED_FIFO); + sched_setscheduler(0, SCHED_FIFO, &schp); +#endif + + /* init object */ + Init(); + + + /* runtime phase --------------------------------------------------------- */ + bRun = true; + + /* main loop of working thread */ + while (bRun) + { + /* get audio from sound card (blocking function) */ + if (Sound.Read(vecsAudioSndCrd)) + PostWinMessage(MS_SOUND_IN, MUL_COL_LED_RED); + else + PostWinMessage(MS_SOUND_IN, MUL_COL_LED_GREEN); + + /* copy data from one stereo buffer in two separate buffers */ + iInCnt = 0; + for (i = 0; i < iSndCrdBlockSizeSam; i++) + { + vecdAudioSndCrdL[i] = (double) vecsAudioSndCrd[iInCnt++]; + vecdAudioSndCrdR[i] = (double) vecsAudioSndCrd[iInCnt++]; + } + + /* resample data for each channel seaparately */ + ResampleObjDownL.Resample(vecdAudioSndCrdL, vecdAudioL); + ResampleObjDownR.Resample(vecdAudioSndCrdR, vecdAudioR); + + /* update signal level meters */ + SignalLevelMeterL.Update(vecdAudioL); + SignalLevelMeterR.Update(vecdAudioR); + + /* add reverberation effect if activated */ + if (iReverbLevel != 0) + { + /* first attenuation amplification factor */ + const double dRevLev = (double) iReverbLevel / AUD_REVERB_MAX / 2; + + if (bReverbOnLeftChan) + { + for (i = 0; i < iBlockSizeSam; i++) + { + /* left channel */ + vecdAudioL[i] += + dRevLev * AudioReverb.ProcessSample(vecdAudioL[i]); + } + } + else + { + for (i = 0; i < iBlockSizeSam; i++) + { + /* right channel */ + vecdAudioR[i] += + dRevLev * AudioReverb.ProcessSample(vecdAudioR[i]); + } + } + } + + /* mix both signals depending on the fading setting */ + const int iMiddleOfFader = AUD_FADER_IN_MAX / 2; + const double dAttFact = + (double) (iMiddleOfFader - abs(iMiddleOfFader - iAudioInFader)) / + iMiddleOfFader; + for (i = 0; i < iBlockSizeSam; i++) + { + double dMixedSignal; + + if (iAudioInFader > iMiddleOfFader) + dMixedSignal = vecdAudioL[i] + dAttFact * vecdAudioR[i]; + else + dMixedSignal = vecdAudioR[i] + dAttFact * vecdAudioL[i]; + + vecsNetwork[i] = Double2Short(dMixedSignal); + } + + /* send it through the network */ + Socket.SendPacket(Channel.PrepSendPacket(vecsNetwork), + Channel.GetAddress(), Channel.GetTimeStampIdx()); + + /* receive a new block */ + if (Channel.GetData(vecdNetwData)) + PostWinMessage(MS_JIT_BUF_GET, MUL_COL_LED_GREEN); + else + PostWinMessage(MS_JIT_BUF_GET, MUL_COL_LED_RED); + +#ifdef _DEBUG_ +#if 0 +#if 0 +/* Determine network delay. We can do this very simple if only this client is + connected to the server. In this case, exactly the same audio material is + coming back and we can simply compare the samples */ +/* store send data instatic buffer (may delay is 100 ms) */ +const int iMaxDelaySamples = (int) ((float) 0.3 /*0.1*/ * SAMPLE_RATE); +static CVector vecsOutBuf(iMaxDelaySamples); + +/* update buffer */ +const int iBufDiff = iMaxDelaySamples - iBlockSizeSam; +for (i = 0; i < iBufDiff; i++) + vecsOutBuf[i + iBlockSizeSam] = vecsOutBuf[i]; +for (i = 0; i < iBlockSizeSam; i++) + vecsOutBuf[i] = vecsNetwork[i]; + +/* now search for equal samples */ +int iDelaySamples = 0; +for (i = 0; i < iMaxDelaySamples - 1; i++) +{ + /* compare two successive samples */ + if ((vecsOutBuf[i] == (short) vecdNetwData[0]) && + (vecsOutBuf[i + 1] == (short) vecdNetwData[1])) + { + iDelaySamples = i; + } +} + +static FILE* pFileDelay = fopen("delay.dat", "w"); +fprintf(pFileDelay, "%d\n", iDelaySamples); +fflush(pFileDelay); +#else +/* just store both, input and output, streams */ +// fid=fopen('v.dat','r');x=fread(fid,'int16');fclose(fid); +static FILE* pFileDelay = fopen("v.dat", "wb"); +short sData[2]; +for (i = 0; i < iBlockSizeSam; i++) +{ + sData[0] = vecsNetwork[i]; + sData[1] = (short) vecdNetwData[i]; + fwrite(&sData, size_t(2), size_t(2), pFileDelay); +} +fflush(pFileDelay); +#endif +#endif +#endif + + +/* +// fid=fopen('v.dat','r');x=fread(fid,'int16');fclose(fid); +static FILE* pFileDelay = fopen("v.dat", "wb"); +short sData[2]; +for (i = 0; i < iBlockSizeSam; i++) +{ + sData[0] = (short) vecdNetwData[i]; + fwrite(&sData, size_t(2), size_t(1), pFileDelay); +} +fflush(pFileDelay); +*/ + + + /* check if channel is connected */ + if (Channel.IsConnected()) + { + /* write mono input signal in both sound-card channels */ + for (i = 0; i < iBlockSizeSam; i++) + vecdAudioL[i] = vecdAudioR[i] = vecdNetwData[i]; + } + else + { + /* if not connected, clear data */ + for (i = 0; i < iBlockSizeSam; i++) + vecdAudioL[i] = vecdAudioR[i] = 0.0; + } + + /* resample data for each channel separately */ + ResampleObjUpL.Resample(vecdAudioL, vecdAudioSndCrdL); + ResampleObjUpR.Resample(vecdAudioR, vecdAudioSndCrdR); + + /* copy data from one stereo buffer in two separate buffers */ + iInCnt = 0; + for (i = 0; i < iSndCrdBlockSizeSam; i++) + { + vecsAudioSndCrd[iInCnt++] = Double2Short(vecdAudioSndCrdL[i]); + vecsAudioSndCrd[iInCnt++] = Double2Short(vecdAudioSndCrdR[i]); + } + + /* play the new block */ + if (Sound.Write(vecsAudioSndCrd)) + PostWinMessage(MS_SOUND_OUT, MUL_COL_LED_RED); + else + PostWinMessage(MS_SOUND_OUT, MUL_COL_LED_GREEN); + + + /* update response time measurement --------------------------------- */ + /* add time difference */ + const QTime CurTime = QTime::currentTime(); + + /* we want to calculate the standard deviation (we assume that the mean + is correct at the block period time) */ + const double dCurAddVal = + ( (double) TimeLastBlock.msecsTo ( CurTime ) - MIN_BLOCK_DURATION_MS ); + +/* +// TEST +static FILE* pFileTest = fopen("sti.dat", "w"); +fprintf(pFileTest, "%e\n", dCurAddVal); +fflush(pFileTest); +*/ + + RespTimeMoAvBuf.Add ( dCurAddVal * dCurAddVal ); /* add squared value */ + + /* store old time value */ + TimeLastBlock = CurTime; + } + + /* reset current signal level and LEDs */ + SignalLevelMeterL.Reset(); + SignalLevelMeterR.Reset(); + PostWinMessage(MS_RESET_ALL, 0); +} + +bool CClient::Stop() +{ + /* set flag so that thread can leave the main loop */ + bRun = false; + + /* give thread some time to terminate, return status */ + return wait(5000); +} diff --git a/src/client.h b/src/client.h new file mode 100755 index 00000000..9ea73a88 --- /dev/null +++ b/src/client.h @@ -0,0 +1,135 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#if !defined(CLIENT_HOIHGE76GEKJH98_3_43445KJIUHF1912__INCLUDED_) +#define CLIENT_HOIHGE76GEKJH98_3_43445KJIUHF1912__INCLUDED_ + +#include +#include +#include +#include +#include "global.h" +#include "socket.h" +#include "resample.h" +#include "channel.h" +#include "util.h" +#ifdef _WIN32 +# include "../windows/sound.h" +#else +# include "../linux/sound.h" +# include +#endif + + +/* Definitions ****************************************************************/ +/* audio in fader range */ +#define AUD_FADER_IN_MAX 100 + +/* audio reverberation range */ +#define AUD_REVERB_MAX 100 + + +/* Classes ********************************************************************/ +class CClient : public QThread +{ +public: + CClient() : bRun ( false ), Socket ( &Channel ), + iAudioInFader ( AUD_FADER_IN_MAX / 2 ), + iReverbLevel ( AUD_REVERB_MAX / 6 ), + bReverbOnLeftChan ( false ) {} + virtual ~CClient () {} + + void Init(); + bool Stop(); + bool IsRunning() {return bRun;} + bool SetServerAddr(QString strNAddr); + double MicLevelL() {return SignalLevelMeterL.MicLevel();} + double MicLevelR() {return SignalLevelMeterR.MicLevel();} + bool IsConnected() {return Channel.IsConnected();} + + /* we want to return the standard deviation. For that we need to calculate + the sqaure root */ + double GetTimingStdDev() {return sqrt(RespTimeMoAvBuf.GetAverage());} + + int GetAudioInFader() {return iAudioInFader;} + void SetAudioInFader(const int iNV) {iAudioInFader = iNV;} + + int GetReverbLevel() {return iReverbLevel;} + void SetReverbLevel(const int iNL) {iReverbLevel = iNL;} + + bool IsReverbOnLeftChan() {return bReverbOnLeftChan;} + void SetReverbOnLeftChan(const bool bIL) + {bReverbOnLeftChan = bIL; AudioReverb.Clear();} + + CSound* GetSndInterface() {return &Sound;} + CChannel* GetChannel() {return &Channel;} + + + // settings + string strIPAddress; + +protected: + virtual void run(); + + /* only one channel is needed for client application */ + CChannel Channel; + + CSocket Socket; + CSound Sound; + CSignalLevelMeter SignalLevelMeterL; + CSignalLevelMeter SignalLevelMeterR; + + bool bRun; + CVector vecdNetwData; + + int iAudioInFader; + bool bReverbOnLeftChan; + int iReverbLevel; + CAudioReverb AudioReverb; + + int iSndCrdBlockSizeSam; + int iBlockSizeSam; + + CVector vecsAudioSndCrd; + CVector vecdAudioSndCrdL; + CVector vecdAudioSndCrdR; + + CVector vecdAudioL; + CVector vecdAudioR; + + CVector vecsNetwork; + + /* resample objects */ + CAudioResample ResampleObjDownL; /* left channel */ + CAudioResample ResampleObjDownR; /* right channel */ + CAudioResample ResampleObjUpL; /* left channel */ + CAudioResample ResampleObjUpR; /* right channel */ + + /* debugging, evaluating */ + CMovingAv RespTimeMoAvBuf; + QTime TimeLastBlock; +}; + + +#endif /* !defined(CLIENT_HOIHGE76GEKJH98_3_43445KJIUHF1912__INCLUDED_) */ diff --git a/src/global.h b/src/global.h new file mode 100755 index 00000000..3690c373 --- /dev/null +++ b/src/global.h @@ -0,0 +1,154 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#if !defined(GLOBAL_H__3B123453_4344_BB2B_23E7A0D31912__INCLUDED_) +#define GLOBAL_H__3B123453_4344_BB2B_23E7A0D31912__INCLUDED_ + +#include +#include +#include +#include +#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + + +/* Definitions ****************************************************************/ +/* define this macro to get debug output */ +#define _DEBUG_ +#undef _DEBUG_ + +/* version and application name */ +#ifndef VERSION +# define VERSION "0.9.1" +#endif +#define APP_NAME "llcon" + + +/* defined port number for client and server */ +#define LLCON_PORT_NUMBER 22122 + +/* sample rate */ +#define SAMPLE_RATE 24000 + +/* sound card sample rate. Should be always 48 kHz to avoid sound card driver + internal sample rate conversion which might be buggy */ +#define SND_CRD_SAMPLE_RATE 48000 + +/* minimum block duration - all other buffer durations must be a multiple + of this duration */ +#define MIN_BLOCK_DURATION_MS 2 /* ms */ + +#define MIN_BLOCK_SIZE_SAMPLES ( MIN_BLOCK_DURATION_MS * SAMPLE_RATE / 1000 ) +#define MIN_SND_CRD_BLOCK_SIZE_SAMPLES ( MIN_BLOCK_DURATION_MS * SND_CRD_SAMPLE_RATE / 1000 ) + +/* block length in milliseconds (it seems that with the standard windows time + a minimum block duration of 10 ms can be used) */ +#ifdef _WIN32 +# define BLOCK_DURATION_MS 6 /* ms */ +#else +/* first tests showed that with 24000 kHz a block time shorter than 5 ms leads to + much higher DSL network latencies. A length of 6 ms seems to be optimal */ +# define BLOCK_DURATION_MS 6 /* ms */ +#endif + + +#define BLOCK_SIZE_SAMPLES (BLOCK_DURATION_MS * SAMPLE_RATE / 1000) +#define SND_CRD_BLOCK_SIZE_SAMPLES (BLOCK_DURATION_MS * SND_CRD_SAMPLE_RATE / 1000) + +/* maximum network buffer size (which can be chosen by slider) */ +#define MAX_NET_BUF_SIZE_NUM_BL 10 /* number of blocks */ + +/* default network buffer size */ +#define DEF_NET_BUF_SIZE_NUM_BL 2 /* number of blocks */ + +// number of ticks of audio in/out buffer sliders +#ifdef _WIN32 +# define AUD_SLIDER_LENGTH 15 +#else +# define AUD_SLIDER_LENGTH 6 +#endif + +/* sample rate offset estimation algorithm */ +/* time interval for sample rate offset estimation */ +#define TIME_INT_SAM_OFFS_EST 60 /* s */ + +/* time interval of taps for sample rate offset estimation (time stamps) */ +#define INTVL_TAPS_SAM_OFF_SET 1 /* s */ + +#define NUM_BL_TIME_STAMPS ( ( INTVL_TAPS_SAM_OFF_SET * 1000 ) / MIN_BLOCK_DURATION_MS ) +#define VEC_LEN_SAM_OFFS_EST ( TIME_INT_SAM_OFFS_EST / INTVL_TAPS_SAM_OFF_SET ) + +/* length of the moving average buffer for response time measurement */ +#define TIME_MOV_AV_RESPONSE 30 /* seconds */ +#define LEN_MOV_AV_RESPONSE (TIME_MOV_AV_RESPONSE * 1000 / BLOCK_DURATION_MS) + + +#define _MAXSHORT 32767 +#define _MAXBYTE 255 /* binary: 11111111 */ +#define _MINSHORT (-32768) + + +/* Definitions for window message system ------------------------------------ */ +typedef unsigned int _MESSAGE_IDENT; +#define MS_RESET_ALL 0 /* MS: Message */ +#define MS_SOUND_IN 1 +#define MS_SOUND_OUT 2 +#define MS_JIT_BUF_PUT 3 +#define MS_JIT_BUF_GET 4 + +#define MUL_COL_LED_RED 0 +#define MUL_COL_LED_YELLOW 1 +#define MUL_COL_LED_GREEN 2 + + +/* Classes ********************************************************************/ +class CGenErr +{ +public: + CGenErr(QString strNE) : strError(strNE) {} + QString strError; +}; + +class CLlconEvent : public QCustomEvent +{ +public: + CLlconEvent(int iNewMeTy, int iNewSt, int iNewChN = 0) : + QCustomEvent(QEvent::User + 11), iMessType(iNewMeTy), iStatus(iNewSt), + iChanNum(iNewChN) {} + + int iMessType; + int iStatus; + int iChanNum; +}; + + +/* Prototypes for global functions ********************************************/ +/* Posting a window message */ +void PostWinMessage(const _MESSAGE_IDENT MessID, const int iMessageParam = 0, + const int iChanNum = 0); + + +#endif /* !defined(GLOBAL_H__3B123453_4344_BB2B_23E7A0D31912__INCLUDED_) */ diff --git a/src/llconclientdlg.cpp b/src/llconclientdlg.cpp new file mode 100755 index 00000000..ac8a844c --- /dev/null +++ b/src/llconclientdlg.cpp @@ -0,0 +1,328 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "llconclientdlg.h" + + +/* Implementation *************************************************************/ +CLlconClientDlg::CLlconClientDlg ( CClient* pNCliP, QWidget* parent, + const char* name, bool modal, WFlags f) : pClient ( pNCliP ), + CLlconClientDlgBase ( parent, name, modal, f ) +{ + /* add help text to controls */ + QString strInpLevH = tr("Input level meter: Shows the level of the " + "input audio signal of the sound card. The level is in dB. Overload " + "should be avoided."); + QWhatsThis::add(TextLabelInputLevel, strInpLevH); + QWhatsThis::add(ProgressBarInputLevelL, strInpLevH); + QWhatsThis::add(ProgressBarInputLevelR, strInpLevH); + + QWhatsThis::add(PushButtonConnect, tr("Connect / Disconnect Button:" + " Push this button to connect the server. A valid IP address has " + "to be specified before. If the client is connected, pressing this " + "button will disconnect the connection.")); + + QWhatsThis::add(TextLabelNameVersion, tr("Version: Shows the " + "current version of the software.")); + + QWhatsThis::add(TextLabelStatus, tr("Status Bar: In the status bar " + "different messages are displayed. E.g., if an error ocurred or the " + "status of the connection is shown.")); + + QString strServAddrH = tr("Server Address: In this edit control, " + "the IP address of the server can be set. If an invalid address was " + "chosen, an error message is shown in the status bar."); + QWhatsThis::add(TextLabelServerAddr, strServAddrH); + QWhatsThis::add(LineEditServerAddr, strServAddrH); + + /* set text for version and application name */ + TextLabelNameVersion-> + setText(QString(APP_NAME) + tr(" client ") + QString(VERSION) + + " (" + QString().setNum(BLOCK_DURATION_MS) + " ms)"); + + /* init server address line edit */ + LineEditServerAddr->setText ( pClient->strIPAddress.c_str () ); + + /* init status label */ + OnTimerStatus (); + + /* init sample rate offset label */ +// TextSamRateOffsValue->setText ( "0 Hz" ); +// FIXME disable sample rate estimation result label since estimation does not work +TextSamRateOffsValue->setText ( "---" ); + + /* init connection button text */ + PushButtonConnect->setText ( CON_BUT_CONNECTTEXT ); + + /* Init timing jitter text label */ + TextLabelStdDevTimer->setText ( "" ); + + /* init input level meter bars */ + ProgressBarInputLevelL->setTotalSteps ( NUM_STEPS_INP_LEV_METER ); + ProgressBarInputLevelL->setProgress ( 0 ); + ProgressBarInputLevelR->setTotalSteps ( NUM_STEPS_INP_LEV_METER ); + ProgressBarInputLevelR->setProgress ( 0 ); + + + /* init slider controls --- */ + /* sound buffer in */ + SliderSndBufIn->setRange(2, AUD_SLIDER_LENGTH); + const int iCurNumInBuf = pClient->GetSndInterface()->GetInNumBuf(); + SliderSndBufIn->setValue(iCurNumInBuf); + TextSndBufIn->setText("In: " + QString().setNum(iCurNumInBuf)); + + /* sound buffer out */ + SliderSndBufOut->setRange(2, AUD_SLIDER_LENGTH); + const int iCurNumOutBuf = pClient->GetSndInterface()->GetOutNumBuf(); + SliderSndBufOut->setValue(iCurNumOutBuf); + TextSndBufOut->setText("Out: " + QString().setNum(iCurNumOutBuf)); + + /* network buffer */ + SliderNetBuf->setRange(1, MAX_NET_BUF_SIZE_NUM_BL); + const int iCurNumNetBuf = pClient->GetChannel()->GetSockBufSize(); + SliderNetBuf->setValue(iCurNumNetBuf); + TextNetBuf->setText("Size: " + QString().setNum(iCurNumNetBuf)); + + /* audio in fader */ + SliderAudInFader->setRange(0, AUD_FADER_IN_MAX); + const int iCurAudInFader = pClient->GetAudioInFader(); + SliderAudInFader->setValue(iCurAudInFader); + SliderAudInFader->setTickInterval(AUD_FADER_IN_MAX / 9); + + /* audio reverberation */ + SliderAudReverb->setRange(0, AUD_REVERB_MAX); + const int iCurAudReverb = pClient->GetReverbLevel(); + SliderAudReverb->setValue ( AUD_REVERB_MAX - iCurAudReverb ); + SliderAudReverb->setTickInterval(AUD_REVERB_MAX / 9); + + + /* set radio buttons --- */ + /* reverb channel */ + if (pClient->IsReverbOnLeftChan()) + RadioButtonRevSelL->setChecked(true); + else + RadioButtonRevSelR->setChecked(true); + + + /* Main menu bar -------------------------------------------------------- */ + pMenu = new QMenuBar(this); + CHECK_PTR(pMenu); + pMenu->insertItem(tr("&?"), new CLlconHelpMenu(this)); + pMenu->setSeparator(QMenuBar::InWindowsStyle); + + /* Now tell the layout about the menu */ + CLlconClientDlgBaseLayout->setMenuBar(pMenu); + + + /* connections ---------------------------------------------------------- */ + /* push-buttons */ + QObject::connect(PushButtonConnect, SIGNAL(clicked()), + this, SLOT(OnConnectDisconBut())); + + /* timers */ + QObject::connect(&TimerSigMet, SIGNAL(timeout()), + this, SLOT(OnTimerSigMet())); + QObject::connect(&TimerStatus, SIGNAL(timeout()), + this, SLOT(OnTimerStatus())); + + /* sliders */ + QObject::connect(SliderSndBufIn, SIGNAL(valueChanged(int)), + this, SLOT(OnSliderSndBufInChange(int))); + QObject::connect(SliderSndBufOut, SIGNAL(valueChanged(int)), + this, SLOT(OnSliderSndBufOutChange(int))); + QObject::connect(SliderNetBuf, SIGNAL(valueChanged(int)), + this, SLOT(OnSliderNetBuf(int))); + + QObject::connect(SliderAudInFader, SIGNAL(valueChanged(int)), + this, SLOT(OnSliderAudInFader(int))); + QObject::connect(SliderAudReverb, SIGNAL(valueChanged(int)), + this, SLOT(OnSliderAudReverb(int))); + + /* radio buttons */ + QObject::connect(RadioButtonRevSelL, SIGNAL(clicked()), + this, SLOT(OnRevSelL())); + QObject::connect(RadioButtonRevSelR, SIGNAL(clicked()), + this, SLOT(OnRevSelR())); + + + /* timers --------------------------------------------------------------- */ + /* start timer for status bar */ + TimerStatus.start(STATUSBAR_UPDATE_TIME); +} + +CLlconClientDlg::~CLlconClientDlg() +{ + /* if connected, terminate connection */ + if (pClient->IsRunning()) + { + pClient->Stop(); + } +} + +void CLlconClientDlg::closeEvent ( QCloseEvent * Event ) +{ + // store IP address + pClient->strIPAddress = LineEditServerAddr->text().latin1(); + + // default implementation of this event handler routine + Event->accept(); +} + +void CLlconClientDlg::OnConnectDisconBut() +{ + /* start/stop client, set button text */ + if (pClient->IsRunning()) + { + pClient->Stop(); + PushButtonConnect->setText(CON_BUT_CONNECTTEXT); + + /* stop timer for level meter bars and reset them */ + TimerSigMet.stop(); + ProgressBarInputLevelL->setProgress(0); + ProgressBarInputLevelR->setProgress(0); + + /* immediately update status bar */ + OnTimerStatus(); + } + else + { + /* set address and check if address is valid */ + if (pClient->SetServerAddr(LineEditServerAddr->text())) + { + pClient->start(); + PushButtonConnect->setText(CON_BUT_DISCONNECTTEXT); + + /* start timer for level meter bar */ + TimerSigMet.start(LEVELMETER_UPDATE_TIME); + } + else + { + /* Restart timer to ensure that the text is visible at + least the time for one complete interval */ + TimerStatus.changeInterval(STATUSBAR_UPDATE_TIME); + + /* show the error in the status bar */ + TextLabelStatus->setText(tr("invalid address")); + } + } +} + +void CLlconClientDlg::OnSliderSndBufInChange(int value) +{ + pClient->GetSndInterface()->SetInNumBuf(value); + TextSndBufIn->setText("In: " + QString().setNum(value)); +} + +void CLlconClientDlg::OnSliderSndBufOutChange(int value) +{ + pClient->GetSndInterface()->SetOutNumBuf(value); + TextSndBufOut->setText("Out: " + QString().setNum(value)); +} + +void CLlconClientDlg::OnSliderNetBuf(int value) +{ + pClient->GetChannel()->SetSockBufSize ( MIN_BLOCK_SIZE_SAMPLES, value ); + TextNetBuf->setText("Size: " + QString().setNum(value)); +} + +void CLlconClientDlg::OnTimerSigMet() +{ + /* get current input levels */ + double dCurSigLevelL = pClient->MicLevelL(); + double dCurSigLevelR = pClient->MicLevelR(); + + /* linear transformation of the input level range to the progress-bar + range */ + dCurSigLevelL -= LOW_BOUND_SIG_METER; + dCurSigLevelL *= NUM_STEPS_INP_LEV_METER / + (UPPER_BOUND_SIG_METER - LOW_BOUND_SIG_METER); + dCurSigLevelR -= LOW_BOUND_SIG_METER; + dCurSigLevelR *= NUM_STEPS_INP_LEV_METER / + (UPPER_BOUND_SIG_METER - LOW_BOUND_SIG_METER); + + /* show current level */ + ProgressBarInputLevelL->setProgress((int) ceil(dCurSigLevelL)); + ProgressBarInputLevelR->setProgress((int) ceil(dCurSigLevelR)); +} + +void CLlconClientDlg::OnTimerStatus() +{ + /* show connection status in status bar */ + if (pClient->IsConnected() && pClient->IsRunning()) + TextLabelStatus->setText(tr("connected")); + else + TextLabelStatus->setText(tr("disconnected")); + + /* update sample rate offset label */ +// FIXME disable sample rate estimation result label since estimation does not work +/* + QString strSamRaOffs; + +// FIXME: sample rate estimation result must be corrected since we use +// smaller buffers in client now. Actual estimation should be fixed, not here + + strSamRaOffs.setNum(pClient->GetChannel()->GetResampleOffset() * + MIN_BLOCK_DURATION_MS / BLOCK_DURATION_MS, 'f', 2); + TextSamRateOffsValue->setText(strSamRaOffs + " Hz"); +*/ + + /* response time */ + TextLabelStdDevTimer->setText(QString(). + setNum(pClient->GetTimingStdDev(), 'f', 2) + " ms"); +} + +void CLlconClientDlg::customEvent(QCustomEvent* Event) +{ + if (Event->type() == QEvent::User + 11) + { + const int iMessType = ((CLlconEvent*) Event)->iMessType; + const int iStatus = ((CLlconEvent*) Event)->iStatus; + + switch(iMessType) + { + case MS_SOUND_IN: + CLEDSoundIn->SetLight(iStatus); + break; + + case MS_SOUND_OUT: + CLEDSoundOut->SetLight(iStatus); + break; + + case MS_JIT_BUF_PUT: + CLEDNetwPut->SetLight(iStatus); + break; + + case MS_JIT_BUF_GET: + CLEDNetwGet->SetLight(iStatus); + break; + + case MS_RESET_ALL: + CLEDSoundIn->Reset(); + CLEDSoundOut->Reset(); + CLEDNetwPut->Reset(); + CLEDNetwGet->Reset(); + break; + } + } +} diff --git a/src/llconclientdlg.h b/src/llconclientdlg.h new file mode 100755 index 00000000..c136540e --- /dev/null +++ b/src/llconclientdlg.h @@ -0,0 +1,96 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "global.h" +#include "client.h" +#include "multicolorled.h" +#ifdef _WIN32 +# include "../windows/moc/llconclientdlgbase.h" +#else +# include "moc/llconclientdlgbase.h" +#endif + + +/* Definitions ****************************************************************/ +/* text strings for connection button for connect and disconnect */ +#define CON_BUT_CONNECTTEXT "C&onnect" +#define CON_BUT_DISCONNECTTEXT "D&isconnect" + +/* steps for input level meter */ +#define NUM_STEPS_INP_LEV_METER 100 + +/* update time for GUI controls */ +#define LEVELMETER_UPDATE_TIME 100 /* ms */ +#define STATUSBAR_UPDATE_TIME 1000 /* ms */ + +/* range for signal level meter */ +#define LOW_BOUND_SIG_METER ( -50.0 ) /* dB */ +#define UPPER_BOUND_SIG_METER ( 0.0 ) /* dB */ + + +/* Classes ********************************************************************/ +class CLlconClientDlg : public CLlconClientDlgBase +{ + Q_OBJECT + +public: + CLlconClientDlg ( CClient* pNCliP, QWidget* parent = 0, + const char* name = 0, bool modal = FALSE, WFlags f = 0 ); + + virtual ~CLlconClientDlg (); + +protected: + CClient* pClient; + bool bConnected; + QTimer TimerSigMet; + QTimer TimerStatus; + virtual void customEvent ( QCustomEvent* Event ); + virtual void closeEvent ( QCloseEvent * Event ); + + QMenuBar* pMenu; + +public slots: + void OnConnectDisconBut (); + void OnTimerSigMet (); + void OnTimerStatus (); + void OnSliderSndBufInChange ( int value ); + void OnSliderSndBufOutChange ( int value ); + void OnSliderNetBuf ( int value ); + void OnSliderAudInFader ( int value ) { pClient->SetAudioInFader(value); } + void OnSliderAudReverb ( int value ) + { pClient->SetReverbLevel ( AUD_REVERB_MAX - value ); } + void OnRevSelL () { pClient->SetReverbOnLeftChan(true); } + void OnRevSelR () { pClient->SetReverbOnLeftChan(false); } +}; diff --git a/src/llconclientdlgbase.ui b/src/llconclientdlgbase.ui new file mode 100755 index 00000000..964f3b46 --- /dev/null +++ b/src/llconclientdlgbase.ui @@ -0,0 +1,1125 @@ + +CLlconClientDlgBase + + QDialog + + name + CLlconClientDlgBase + + + geometry + + 0 + 0 + 814 + 287 + + + + caption + llcon + + + icon + image0 + + + sizeGripEnabled + true + + + + margin + 11 + + + spacing + 6 + + + QFrame + + name + FrameMain + + + frameShape + StyledPanel + + + frameShadow + Raised + + + + margin + 11 + + + spacing + 6 + + + QLabel + + name + PixmapLabelCorrados + + + sizePolicy + + 3 + 3 + + + + pixmap + image1 + + + scaledContents + true + + + alignment + AlignCenter + + + hAlign + + + + QLayoutWidget + + name + Layout19 + + + layoutSpacing + + + + margin + 0 + + + spacing + 2 + + + QLayoutWidget + + name + Layout17 + + + layoutSpacing + + + + margin + 0 + + + spacing + 0 + + + QLabel + + name + TextLabelInputLevel + + + sizePolicy + + 1 + 3 + + + + text + Input Level L: + + + + QLabel + + name + TextLabelInputLevel_2 + + + sizePolicy + + 1 + 3 + + + + text + Input Level R: + + + + + + QLayoutWidget + + name + Layout18 + + + layoutSpacing + + + + margin + 0 + + + spacing + 0 + + + QProgressBar + + name + ProgressBarInputLevelL + + + sizePolicy + + 7 + 3 + + + + frameShape + Box + + + frameShadow + Sunken + + + lineWidth + 1 + + + margin + 0 + + + midLineWidth + 0 + + + centerIndicator + true + + + indicatorFollowsStyle + false + + + + QProgressBar + + name + ProgressBarInputLevelR + + + sizePolicy + + 7 + 3 + + + + frameShape + Box + + + frameShadow + Sunken + + + lineWidth + 1 + + + margin + 0 + + + midLineWidth + 0 + + + centerIndicator + true + + + indicatorFollowsStyle + false + + + + + + + + QLayoutWidget + + name + Layout3 + + + + margin + 0 + + + spacing + 6 + + + QLabel + + name + TextLabelServerAddr + + + text + Server Address: + + + + QLineEdit + + name + LineEditServerAddr + + + + + + QLayoutWidget + + name + Layout17 + + + + margin + 0 + + + spacing + 6 + + + QLabel + + name + TextLabelNameVersion + + + text + TextLabelNameVersion + + + + + name + Horizontal Spacing2 + + + orientation + Horizontal + + + sizeType + Expanding + + + sizeHint + + 20 + 20 + + + + + QPushButton + + name + PushButtonConnect + + + text + C&onnect + + + + + + QLabel + + name + TextLabelStatus + + + sizePolicy + + 7 + 1 + + + + frameShape + Panel + + + frameShadow + Sunken + + + text + TextLabelStatus + + + + + + QButtonGroup + + name + GroupBoxAudioInput + + + title + Audio In + + + + margin + 11 + + + spacing + 6 + + + QLayoutWidget + + name + Layout14 + + + + margin + 0 + + + spacing + 6 + + + QLayoutWidget + + name + Layout12 + + + + margin + 0 + + + spacing + 6 + + + QLabel + + name + TextAudInFader + + + text + Audio Fader + + + alignment + AlignCenter + + + hAlign + + + + QSlider + + name + SliderAudInFader + + + pageStep + 1 + + + orientation + Vertical + + + tickmarks + Both + + + + + + QLayoutWidget + + name + Layout13 + + + + margin + 0 + + + spacing + 6 + + + QLabel + + name + TextLabelAudReverb + + + text + Reverb + + + alignment + AlignCenter + + + hAlign + + + + QSlider + + name + SliderAudReverb + + + pageStep + 1 + + + orientation + Vertical + + + tickmarks + Both + + + + + + + + QLabel + + name + TextLabelReverbSelection + + + text + Reverb Selection + + + alignment + AlignCenter + + + hAlign + + + + QLayoutWidget + + name + Layout11 + + + + margin + 0 + + + spacing + 6 + + + QRadioButton + + name + RadioButtonRevSelL + + + text + L + + + + QRadioButton + + name + RadioButtonRevSelR + + + text + R + + + + + + + + QGroupBox + + name + GroupBoxJitterBuffer + + + title + Jitter Buffer + + + + margin + 11 + + + spacing + 6 + + + QLabel + + name + TextNetBuf + + + text + Size + + + alignment + AlignCenter + + + hAlign + + + + QSlider + + name + SliderNetBuf + + + pageStep + 1 + + + orientation + Vertical + + + tickmarks + Both + + + + QLabel + + name + TextLabel2 + + + text + Put / Get: + + + alignment + AlignCenter + + + hAlign + + + + QLayoutWidget + + name + Layout9 + + + + margin + 0 + + + spacing + 6 + + + CMultiColorLED + + name + CLEDNetwPut + + + minimumSize + + 13 + 13 + + + + maximumSize + + 13 + 13 + + + + + CMultiColorLED + + name + CLEDNetwGet + + + minimumSize + + 13 + 13 + + + + maximumSize + + 13 + 13 + + + + + + + + + QGroupBox + + name + GroupBoxSoundCardBuffers + + + title + Sndcard Buffers + + + + margin + 11 + + + spacing + 6 + + + QLayoutWidget + + name + Layout12 + + + + margin + 0 + + + spacing + 6 + + + QLayoutWidget + + name + Layout10 + + + + margin + 0 + + + spacing + 6 + + + QLabel + + name + TextSndBufIn + + + sizePolicy + + 3 + 1 + + + + minimumSize + + 30 + 0 + + + + text + In + + + alignment + AlignCenter + + + hAlign + + + + QSlider + + name + SliderSndBufIn + + + pageStep + 1 + + + orientation + Vertical + + + tickmarks + Both + + + + + + QLayoutWidget + + name + Layout11 + + + + margin + 0 + + + spacing + 6 + + + QLabel + + name + TextSndBufOut + + + sizePolicy + + 3 + 1 + + + + minimumSize + + 30 + 0 + + + + text + Out + + + alignment + AlignCenter + + + hAlign + + + + QSlider + + name + SliderSndBufOut + + + pageStep + 1 + + + orientation + Vertical + + + tickmarks + Both + + + + + + + + QLabel + + name + TextLabel1 + + + text + In / Out: + + + alignment + AlignCenter + + + hAlign + + + + QLayoutWidget + + name + Layout14 + + + + margin + 0 + + + spacing + 6 + + + CMultiColorLED + + name + CLEDSoundIn + + + minimumSize + + 13 + 13 + + + + maximumSize + + 13 + 13 + + + + + CMultiColorLED + + name + CLEDSoundOut + + + minimumSize + + 13 + 13 + + + + maximumSize + + 13 + 13 + + + + + + + + + QGroupBox + + name + GroupBoxMeasureResults + + + minimumSize + + 152 + 0 + + + + title + Measurement Results + + + + margin + 11 + + + spacing + 6 + + + QLayoutWidget + + name + Layout16 + + + + margin + 0 + + + spacing + 6 + + + QLabel + + name + TextLabelStdDevTimerLabel + + + text + StdDev: + + + + QLabel + + name + TextLabelStdDevTimer + + + text + val + + + + + + QLayoutWidget + + name + Layout18 + + + + margin + 0 + + + spacing + 6 + + + QLabel + + name + TextLabelSamOffset + + + text + Fs Offs: + + + + QLabel + + name + TextSamRateOffsValue + + + text + 24000.00 Hz + + + + + + + + + + + CMultiColorLED +
multicolorled.h
+ + 13 + 13 + + 0 + + 0 + 0 + + image2 + + + + + image0 + 789cd3d7528808f055d0d2e72a2e492cc94c5648ce482c52d04a29cdcdad8c8eb5ade6523234530022130543251d2ea5248564056503300071f5205c0b2004719541dcb434986c22840b0260c56800454c9918b1c444e54454b1c4c4a424e5a4c4442431a0085008081231c4949511621021656565b042843a908032bade24a832547b21c6a1ba0f08d0fda18ccd6fd8c2009f58ad351700407358e1 + + + image1 + 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 + + + image2 + 789c6dd2c10ac2300c00d07bbf2234b7229d1ddec44f503c0ae2a154410f53d0ed20e2bf6bdb656dd6861dd23d9a66591b0587fd1654235ebded6f0edcd53e419d87ae7b1f4f9b8f906d0bfe012317426a70b07bdc2f3ec77f8ed6b89559061a0343d06a124cc105596482585094bc0ae599b04646c9018926491b2205e140c485cace25755c175d0a967b622ff900b8cc9c7d29af594ea722d589167f813aa852ba07d94b9dce296e883fe7bb163f23896753 + + + + PushButtonConnect + LineEditServerAddr + + diff --git a/src/llconserverdlg.cpp b/src/llconserverdlg.cpp new file mode 100755 index 00000000..b6d8e4cc --- /dev/null +++ b/src/llconserverdlg.cpp @@ -0,0 +1,177 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "llconserverdlg.h" + + +/* Implementation *************************************************************/ +CLlconServerDlg::CLlconServerDlg(QWidget* parent, const char* name, bool modal, + WFlags f) : CLlconServerDlgBase(parent, name, modal, f) +{ + /* set text for version and application name */ + TextLabelNameVersion-> + setText(QString(APP_NAME) + tr(" server ") + QString(VERSION) + + " (" + QString().setNum(BLOCK_DURATION_MS) + " ms)"); + + /* Create bitmaps */ + /* Define size of the bitmaps */ + const int iXSize = 13; + const int iYSize = 13; + BitmCubeGreen.resize(iXSize, iYSize); + BitmCubeGreen.fill(QColor(0, 255, 0)); + BitmCubeRed.resize(iXSize, iYSize); + BitmCubeRed.fill(QColor(255, 0, 0)); + BitmCubeYellow.resize(iXSize, iYSize); + BitmCubeYellow.fill(QColor(255, 255, 0)); + + /* set up list view for connected clients (We assume that one column is + already there) */ + ListViewClients->setColumnText(0, tr("Client IP : Port")); + ListViewClients->setColumnWidth(0, 170); + ListViewClients->addColumn(tr("Put")); + ListViewClients->setColumnAlignment(1, Qt::AlignCenter); + ListViewClients->addColumn(tr("Get")); + ListViewClients->setColumnAlignment(2, Qt::AlignCenter); + ListViewClients->addColumn(tr("Sample-rate offset [Hz]")); + ListViewClients->clear(); + + /* insert items in reverse order because in Windows all of them are + always visible -> put first item on the top */ + vecpListViewItems.Init(MAX_NUM_CHANNELS); + for (int i = MAX_NUM_CHANNELS - 1; i >= 0; i--) + { + vecpListViewItems[i] = new CServerListViewItem(ListViewClients); +#ifndef _WIN32 + vecpListViewItems[i]->setVisible(false); +#endif + } + + /* Init slider control */ + SliderNetBuf->setRange(1, MAX_NET_BUF_SIZE_NUM_BL); + const int iCurNumNetBuf = Server.GetChannelSet()->GetSockBufSize(); + SliderNetBuf->setValue(iCurNumNetBuf); + TextNetBuf->setText("Size: " + QString().setNum(iCurNumNetBuf)); + + /* start the server */ + Server.Start(); + + /* Init timing jitter text label */ + TextLabelResponseTime->setText(""); + + + /* Main menu bar -------------------------------------------------------- */ + pMenu = new QMenuBar(this); + CHECK_PTR(pMenu); + pMenu->insertItem(tr("&?"), new CLlconHelpMenu(this)); + pMenu->setSeparator(QMenuBar::InWindowsStyle); + + /* Now tell the layout about the menu */ + CLlconServerDlgBaseLayout->setMenuBar(pMenu); + + + /* connections ---------------------------------------------------------- */ + /* timers */ + QObject::connect(&Timer, SIGNAL(timeout()), this, SLOT(OnTimer())); + + /* sliders */ + QObject::connect(SliderNetBuf, SIGNAL(valueChanged(int)), + this, SLOT(OnSliderNetBuf(int))); + + + /* timers --------------------------------------------------------------- */ + /* start timer for GUI controls */ + Timer.start(GUI_CONTRL_UPDATE_TIME); +} + +void CLlconServerDlg::OnTimer() +{ + CVector vecHostAddresses; + CVector vecdSamOffs; + + ListViewMutex.lock(); + + Server.GetConCliParam(vecHostAddresses, vecdSamOffs); + + /* fill list with connected clients */ + for (int i = 0; i < MAX_NUM_CHANNELS; i++) + { + if (!(vecHostAddresses[i].InetAddr == QHostAddress((Q_UINT32) 0))) + { + /* main text (IP, port number) */ + vecpListViewItems[i]->setText(0, QString().sprintf("%s : %d", + vecHostAddresses[i].InetAddr.toString().latin1(), + vecHostAddresses[i].iPort) /* IP, port */); + + /* sample rate offset */ +// FIXME disable sample rate estimation result label since estimation does not work +// vecpListViewItems[i]->setText(3, +// QString().sprintf("%5.2f", vecdSamOffs[i])); + +#ifndef _WIN32 + vecpListViewItems[i]->setVisible(true); +#endif + } +#ifndef _WIN32 + else + vecpListViewItems[i]->setVisible(false); +#endif + } + + ListViewMutex.unlock(); + + /* response time */ + TextLabelResponseTime->setText(QString(). + setNum(Server.GetTimingStdDev(), 'f', 2) + " ms"); +} + +void CLlconServerDlg::OnSliderNetBuf(int value) +{ + Server.GetChannelSet()->SetSockBufSize( BLOCK_SIZE_SAMPLES, value ); + TextNetBuf->setText("Size: " + QString().setNum(value)); +} + +void CLlconServerDlg::customEvent(QCustomEvent* Event) +{ + if (Event->type() == QEvent::User + 11) + { + ListViewMutex.lock(); + + const int iMessType = ((CLlconEvent*) Event)->iMessType; + const int iStatus = ((CLlconEvent*) Event)->iStatus; + const int iChanNum = ((CLlconEvent*) Event)->iChanNum; + + switch(iMessType) + { + case MS_JIT_BUF_PUT: + vecpListViewItems[iChanNum]->SetLight(0, iStatus); + break; + + case MS_JIT_BUF_GET: + vecpListViewItems[iChanNum]->SetLight(1, iStatus); + break; + } + + ListViewMutex.unlock(); + } +} diff --git a/src/llconserverdlg.h b/src/llconserverdlg.h new file mode 100755 index 00000000..37dbb55b --- /dev/null +++ b/src/llconserverdlg.h @@ -0,0 +1,78 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "global.h" +#include "server.h" +#include "multicolorled.h" +#ifdef _WIN32 +# include "../windows/moc/llconserverdlgbase.h" +#else +# include "moc/llconserverdlgbase.h" +#endif + + +/* Definitions ****************************************************************/ +/* update time for GUI controls */ +#define GUI_CONTRL_UPDATE_TIME 1000 /* ms */ + + +/* Classes ********************************************************************/ +class CLlconServerDlg : public CLlconServerDlgBase +{ + Q_OBJECT + +public: + CLlconServerDlg(QWidget* parent = 0, const char* name = 0, + bool modal = FALSE, WFlags f = 0); + + virtual ~CLlconServerDlg() {} + +protected: + QTimer Timer; + CServer Server; + + QPixmap BitmCubeGreen; + QPixmap BitmCubeYellow; + QPixmap BitmCubeRed; + + CVector vecpListViewItems; + QMutex ListViewMutex; + + QMenuBar* pMenu; + + virtual void customEvent(QCustomEvent* Event); + void UpdateSliderNetBuf(); + +public slots: + void OnTimer(); + void OnSliderNetBuf(int value); +}; diff --git a/src/llconserverdlgbase.ui b/src/llconserverdlgbase.ui new file mode 100755 index 00000000..3f373e24 --- /dev/null +++ b/src/llconserverdlgbase.ui @@ -0,0 +1,272 @@ + +CLlconServerDlgBase + + QDialog + + name + CLlconServerDlgBase + + + geometry + + 0 + 0 + 633 + 240 + + + + caption + llcon + + + icon + image0 + + + sizeGripEnabled + true + + + + margin + 11 + + + spacing + 6 + + + QLayoutWidget + + name + Layout4 + + + + margin + 0 + + + spacing + 6 + + + QListView + + + text + Column 1 + + + clickable + true + + + resizeable + true + + + + + text + New Item + + + pixmap + + + + + name + ListViewClients + + + + QGroupBox + + name + GroupBox3 + + + title + Jitter Buffer + + + + margin + 11 + + + spacing + 6 + + + QLabel + + name + TextNetBuf + + + text + Size + + + alignment + AlignCenter + + + hAlign + + + + QSlider + + name + SliderNetBuf + + + pageStep + 1 + + + orientation + Vertical + + + tickmarks + Both + + + + + + + + QLayoutWidget + + name + Layout3 + + + + margin + 0 + + + spacing + 6 + + + QLabel + + name + TextLabelNameVersion + + + text + TextLabelNameVersion + + + + + name + Horizontal Spacing2_2 + + + orientation + Horizontal + + + sizeType + Fixed + + + sizeHint + + 72 + 20 + + + + + QLabel + + name + TextLabel1 + + + text + Timing Standard Deviation: + + + + QLabel + + name + TextLabelResponseTime + + + text + TextLabelResponseTime + + + + + name + Horizontal Spacing2 + + + orientation + Horizontal + + + sizeType + Expanding + + + sizeHint + + 20 + 20 + + + + + QPushButton + + name + buttonOk + + + text + &OK + + + autoDefault + true + + + default + true + + + + + + + + + image0 + 789cd3d7528808f055d0d2e72a2e492cc94c5648ce482c52d04a29cdcdad8c8eb5ade6523234530022130543251d2ea5248564056503300071f5205c0b2004719541dcb434986c22840b0260c56800454c9918b1c444e54454b1c4c4a424e5a4c4442431a0085008081231c4949511621021656565b042843a908032bade24a832547b21c6a1ba0f08d0fda18ccd6fd8c2009f58ad351700407358e1 + + + + + buttonOk + clicked() + CLlconServerDlgBase + accept() + + + diff --git a/src/main.cpp b/src/main.cpp new file mode 100755 index 00000000..1b0fee49 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,106 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include +#include "global.h" +#include "llconclientdlg.h" +#include "llconserverdlg.h" +#include "settings.h" + + +/* Implementation *************************************************************/ +/* This pointer is only used for the post-event routine */ +QApplication* pApp = NULL; + + +int main(int argc, char** argv) +{ + /* Application object */ + QApplication app(argc, argv); + + /* check if server or client application shall be started */ + bool bIsClient = true; + + /* QT docu: argv()[0] is the program name, argv()[1] is the first + argument and argv()[argc()-1] is the last argument */ + if (argc > 1) + { + /* only "-s" is supported right now */ + std::string strShortOpt = "-s"; + if (!strShortOpt.compare(argv[1])) + bIsClient = false; + } + + if (bIsClient) + { + // actual client object + CClient Client; + + // load settings from init-file + CSettings Settings ( &Client ); + Settings.Load (); + + /* client */ + CLlconClientDlg ClientDlg ( &Client, 0, 0, FALSE, Qt::WStyle_MinMax ); + + /* Set main window */ + app.setMainWidget ( &ClientDlg ); + pApp = &app; /* Needed for post-event routine */ + + /* Show dialog */ + ClientDlg.show (); + app.exec (); + + /* Save settings to init-file */ + Settings.Save (); + } + else + { + /* server */ + CLlconServerDlg ServerDlg ( 0, 0, FALSE, Qt::WStyle_MinMax ); + + /* Set main window */ + app.setMainWidget ( &ServerDlg ); + pApp = &app; /* Needed for post-event routine */ + + /* Show dialog */ + ServerDlg.show (); + app.exec (); + } + + return 0; +} + +void PostWinMessage ( const _MESSAGE_IDENT MessID, const int iMessageParam, + const int iChanNum ) +{ + /* In case of simulation no events should be generated */ + if ( pApp != NULL ) + { + CLlconEvent* LlconEv = new CLlconEvent ( MessID, iMessageParam, iChanNum ); + + /* Qt will delete the event object when done */ + QThread::postEvent ( pApp->mainWidget (), LlconEv ); + } +} diff --git a/src/multicolorled.cpp b/src/multicolorled.cpp new file mode 100755 index 00000000..1757c78e --- /dev/null +++ b/src/multicolorled.cpp @@ -0,0 +1,182 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + * Description: + * Implements a multi-color LED + * + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "multicolorled.h" + + +/* Implementation *************************************************************/ +CMultiColorLEDbase::CMultiColorLEDbase() +{ + /* Define size of the bitmaps */ + const int iXSize = 13; + const int iYSize = 13; + + /* Create bitmaps */ + BitmCubeGreen.resize(iXSize, iYSize); + BitmCubeGreen.fill(QColor(0, 255, 0)); + BitmCubeRed.resize(iXSize, iYSize); + BitmCubeRed.fill(QColor(255, 0, 0)); + BitmCubeGrey.resize(iXSize, iYSize); + BitmCubeGrey.fill(QColor(192, 192, 192)); + BitmCubeYellow.resize(iXSize, iYSize); + BitmCubeYellow.fill(QColor(255, 255, 0)); + + /* Init color flags */ + Reset(); + + /* Set init-bitmap */ + SetPixmap(BitmCubeGrey); + eColorFlag = RL_GREY; + + /* Init update time */ + iUpdateTime = DEFAULT_UPDATE_TIME; + + /* Connect timer events to the desired slots */ + connect(&TimerRedLight, SIGNAL(timeout()), + this, SLOT(OnTimerRedLight())); + connect(&TimerGreenLight, SIGNAL(timeout()), + this, SLOT(OnTimerGreenLight())); + connect(&TimerYellowLight, SIGNAL(timeout()), + this, SLOT(OnTimerYellowLight())); +} + +void CMultiColorLEDbase::Reset() +{ + /* Reset color flags */ + bFlagRedLi = false; + bFlagGreenLi = false; + bFlagYellowLi = false; + + UpdateColor(); +} + +void CMultiColorLEDbase::OnTimerRedLight() +{ + bFlagRedLi = false; + UpdateColor(); +} + +void CMultiColorLEDbase::OnTimerGreenLight() +{ + bFlagGreenLi = false; + UpdateColor(); +} + +void CMultiColorLEDbase::OnTimerYellowLight() +{ + bFlagYellowLi = false; + UpdateColor(); +} + +void CMultiColorLEDbase::UpdateColor() +{ + /* Red light has highest priority, then comes yellow and at the end, we + decide to set green light. Allways check the current color of the + control before setting the color to prevent flicking */ + if (bFlagRedLi) + { + if (eColorFlag != RL_RED) + { + SetPixmap(BitmCubeRed); + eColorFlag = RL_RED; + } + return; + } + + if (bFlagYellowLi) + { + if (eColorFlag != RL_YELLOW) + { + SetPixmap(BitmCubeYellow); + eColorFlag = RL_YELLOW; + } + return; + } + + if (bFlagGreenLi) + { + if (eColorFlag != RL_GREEN) + { + SetPixmap(BitmCubeGreen); + eColorFlag = RL_GREEN; + } + return; + } + + /* If no color is active, set control to grey light */ + if (eColorFlag != RL_GREY) + { + SetPixmap(BitmCubeGrey); + eColorFlag = RL_GREY; + } +} + +void CMultiColorLEDbase::SetLight(int iNewStatus) +{ + switch (iNewStatus) + { + case MUL_COL_LED_GREEN: + /* Green light */ + bFlagGreenLi = true; + TimerGreenLight.changeInterval(iUpdateTime); + break; + + case MUL_COL_LED_YELLOW: + /* Yellow light */ + bFlagYellowLi = true; + TimerYellowLight.changeInterval(iUpdateTime); + break; + + case MUL_COL_LED_RED: + /* Red light */ + bFlagRedLi = true; + TimerRedLight.changeInterval(iUpdateTime); + break; + } + + UpdateColor(); +} + +void CMultiColorLEDbase::SetUpdateTime(int iNUTi) +{ + /* Avoid too short intervals */ + if (iNUTi < MIN_TIME_FOR_RED_LIGHT) + iUpdateTime = MIN_TIME_FOR_RED_LIGHT; + else + iUpdateTime = iNUTi; +} + + +CMultiColorLED::CMultiColorLED(QWidget* parent, const char* name, WFlags f) : + QLabel(parent, name, f) +{ + /* Set modified style */ + setFrameShape(QFrame::Panel); + setFrameShadow(QFrame::Sunken); + setIndent(0); +} diff --git a/src/multicolorled.h b/src/multicolorled.h new file mode 100755 index 00000000..d03b70d0 --- /dev/null +++ b/src/multicolorled.h @@ -0,0 +1,139 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + * Description: + * + * SetLight(): + * 0: Green + * 1: Yellow + * 2: Red + * + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#if !defined(AFX_MULTCOLORLED_H__FD6B49B5_87DF_48DD_A873_804E1606C2AC__INCLUDED_) +#define AFX_MULTCOLORLED_H__FD6B49B5_87DF_48DD_A873_804E1606C2AC__INCLUDED_ + +#include +#include +#include +#include +#include "global.h" + + +/* Definitions ****************************************************************/ +#define DEFAULT_UPDATE_TIME 300 + +/* The red and yellow light should be on at least this interval */ +#define MIN_TIME_FOR_RED_LIGHT 100 + + +/* Classes ********************************************************************/ +class CMultiColorLEDbase : public QObject +{ + Q_OBJECT + +public: + CMultiColorLEDbase(); + + void Reset(); + void SetUpdateTime(int iNUTi); + void SetLight(int iNewStatus); + +protected: + enum ELightColor {RL_GREY, RL_RED, RL_GREEN, RL_YELLOW}; + ELightColor eColorFlag; + + virtual void SetPixmap(QPixmap& NewBitmap) {} /* must be implemented in derived class! */ + void UpdateColor(); + + QPixmap BitmCubeGreen; + QPixmap BitmCubeYellow; + QPixmap BitmCubeRed; + QPixmap BitmCubeGrey; + + QTimer TimerRedLight; + QTimer TimerGreenLight; + QTimer TimerYellowLight; + + int iUpdateTime; + + bool bFlagRedLi; + bool bFlagGreenLi; + bool bFlagYellowLi; + +protected slots: + void OnTimerRedLight(); + void OnTimerGreenLight(); + void OnTimerYellowLight(); +}; + + +class CMultiColorLED : public QLabel, public CMultiColorLEDbase +{ +public: + CMultiColorLED(QWidget* parent, const char* name = 0, WFlags f = 0); + +protected: + virtual void SetPixmap(QPixmap& NewBitmap) {setPixmap(NewBitmap);} +}; + + +class CMultColLEDListViewItem : public CMultiColorLEDbase +{ +public: + CMultColLEDListViewItem(const int iNewCol) : iColumn(iNewCol), + pListViewItem(NULL) {} + + void SetListViewItemPointer(QListViewItem* pNewListViewItem) + {pListViewItem = pNewListViewItem;} + +protected: + virtual void SetPixmap(QPixmap& NewBitmap) + {if (pListViewItem != NULL) pListViewItem->setPixmap(iColumn, NewBitmap);} + + QListViewItem* pListViewItem; + int iColumn; +}; + + +class CServerListViewItem : public QListViewItem +{ +public: + CServerListViewItem(QListView* parent) : LED0(1), LED1(2), + QListViewItem(parent) {LED0.SetListViewItemPointer(this); + LED1.SetListViewItemPointer(this);} + + void SetLight(int iWhichLED, int iNewStatus) + { + switch (iWhichLED) { + case 0: LED0.SetLight(iNewStatus); break; + case 1: LED1.SetLight(iNewStatus); break; + } + } + +protected: + CMultColLEDListViewItem LED0, LED1; +}; + + +#endif // AFX_MULTCOLORLED_H__FD6B49B5_87DF_48DD_A873_804E1606C2AC__INCLUDED_ diff --git a/src/resample.cpp b/src/resample.cpp new file mode 100755 index 00000000..04d99b71 --- /dev/null +++ b/src/resample.cpp @@ -0,0 +1,184 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + * Description: + * Resample routine for arbitrary sample-rate conversions in a low range (for + * frequency offset correction). + * The algorithm is based on a polyphase structure. We upsample the input + * signal with a factor INTERP_DECIM_I_D and calculate two successive samples + * whereby we perform a linear interpolation between these two samples to get + * an arbitraty sample grid. + * The polyphase filter is calculated with Matlab(TM), the associated file + * is ResampleFilter.m. + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "resample.h" + + +/* Implementation *************************************************************/ +int CResample::Resample(CVector& vecdInput, CVector& vecdOutput, + const double dRation) +{ + int i; + + /* move old data from the end to the history part of the buffer and + add new data (shift register) */ + /* Shift old values */ + int iMovLen = iInputBlockSize; + for (i = 0; i < iHistorySize; i++) + { + vecdIntBuff[i] = vecdIntBuff[iMovLen++]; + } + + /* Add new block of data */ + int iBlockEnd = iHistorySize; + for (i = 0; i < iInputBlockSize; i++) + { + vecdIntBuff[iBlockEnd++] = vecdInput[i]; + } + + /* sample-interval of new sample frequency in relation to interpolated + sample-interval */ + dTStep = (double) INTERP_DECIM_I_D / dRation; + + /* init output counter */ + int im = 0; + + /* main loop */ + do + { + /* quantize output-time to interpolated time-index */ + const int ik = (int) dtOut; + + + /* calculate convolutions for the two interpolation-taps ------------ */ + /* phase for the linear interpolation-taps */ + const int ip1 = ik % INTERP_DECIM_I_D; + const int ip2 = (ik + 1) % INTERP_DECIM_I_D; + + /* sample positions in input vector */ + const int in1 = (int) (ik / INTERP_DECIM_I_D); + const int in2 = (int) ((ik + 1) / INTERP_DECIM_I_D); + + /* convolution */ + double dy1 = 0.0; + double dy2 = 0.0; + for (int i = 0; i < NUM_TAPS_PER_PHASE; i++) + { + dy1 += fResTaps1To1[ip1][i] * vecdIntBuff[in1 - i]; + dy2 += fResTaps1To1[ip2][i] * vecdIntBuff[in2 - i]; + } + + + /* linear interpolation --------------------------------------------- */ + /* get numbers after the comma */ + const double dxInt = dtOut - (int) dtOut; + vecdOutput[im] = (dy2 - dy1) * dxInt + dy1; + + + /* increase output counter */ + im++; + + /* increase output-time and index one step */ + dtOut = dtOut + dTStep; + } + while (dtOut < dBlockDuration); + + /* set rtOut back */ + dtOut -= iInputBlockSize * INTERP_DECIM_I_D; + + return im; +} + +void CResample::Init(const int iNewInputBlockSize) +{ + iInputBlockSize = iNewInputBlockSize; + + /* history size must be one sample larger, because we use always TWO + convolutions */ + iHistorySize = NUM_TAPS_PER_PHASE + 1; + + /* calculate block duration */ + dBlockDuration = (iInputBlockSize + iHistorySize - 1) * INTERP_DECIM_I_D; + + /* allocate memory for internal buffer, clear sample history */ + vecdIntBuff.Init(iInputBlockSize + iHistorySize, 0.0); + + /* init absolute time for output stream (at the end of the history part */ + dtOut = (double) (iHistorySize - 1) * INTERP_DECIM_I_D; +} + +void CAudioResample::Resample(CVector& vecdInput, + CVector& vecdOutput) +{ + int j; + + if (dRation == 1.0) + { + /* if ratio is 1, no resampling is needed, just copy vector */ + for (j = 0; j < iOutputBlockSize; j++) + vecdOutput[j] = vecdInput[j]; + } + else + { + /* move old data from the end to the history part of the buffer and + add new data (shift register) */ + /* Shift old values */ + int iMovLen = iInputBlockSize; + for (j = 0; j < NUM_TAPS_PER_PHASE; j++) + vecdIntBuff[j] = vecdIntBuff[iMovLen++]; + + /* Add new block of data */ + int iBlockEnd = NUM_TAPS_PER_PHASE; + for (j = 0; j < iInputBlockSize; j++) + vecdIntBuff[iBlockEnd++] = vecdInput[j]; + + /* main loop */ + for (j = 0; j < iOutputBlockSize; j++) + { + /* phase for the linear interpolation-taps */ + const int ip = + (int) (j * INTERP_DECIM_I_D / dRation) % INTERP_DECIM_I_D; + + /* sample position in input vector */ + const int in = (int) (j / dRation) + NUM_TAPS_PER_PHASE; + + /* convolution */ + double dy = 0.0; + for (int i = 0; i < NUM_TAPS_PER_PHASE; i++) + dy += fResTaps1To1[ip][i] * vecdIntBuff[in - i]; + + vecdOutput[j] = dy; + } + } +} + +void CAudioResample::Init(const int iNewInputBlockSize, const double dNewRation) +{ + dRation = dNewRation; + iInputBlockSize = iNewInputBlockSize; + iOutputBlockSize = (int) (iInputBlockSize * dNewRation); + + /* allocate memory for internal buffer, clear sample history */ + vecdIntBuff.Init(iInputBlockSize + NUM_TAPS_PER_PHASE, 0.0); +} diff --git a/src/resample.h b/src/resample.h new file mode 100755 index 00000000..e6a6803e --- /dev/null +++ b/src/resample.h @@ -0,0 +1,75 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#if !defined(RESAMPLE_H__3B0FEUFE7876F_FE8FE_CA63_4344_1912__INCLUDED_) +#define RESAMPLE_H__3B0FEUFE7876F_FE8FE_CA63_4344_1912__INCLUDED_ + +#include "util.h" +#include "resamplefilter.h" +#include "global.h" + + +/* Classes ********************************************************************/ +class CResample +{ +public: + CResample() {} + virtual ~CResample() {} + + void Init(const int iNewInputBlockSize); + int Resample(CVector& vecdInput, CVector& vecdOutput, + const double dRation); + +protected: + double dTStep; + double dtOut; + double dBlockDuration; + + CVector vecdIntBuff; + int iHistorySize; + + int iInputBlockSize; +}; + +class CAudioResample +{ +public: + CAudioResample() {} + virtual ~CAudioResample() {} + + void Init(const int iNewInputBlockSize, const double dNewRation); + void Resample(CVector& vecdInput, CVector& vecdOutput); + +protected: + double dRation; + + CVector vecdIntBuff; + int iHistorySize; + + int iInputBlockSize; + int iOutputBlockSize; +}; + + +#endif // !defined(RESAMPLE_H__3B0FEUFE7876F_FE8FE_CA63_4344_1912__INCLUDED_) diff --git a/src/resamplefilter.h b/src/resamplefilter.h new file mode 100644 index 00000000..c383777e --- /dev/null +++ b/src/resamplefilter.h @@ -0,0 +1,157 @@ +/* Automatically generated file with MATLAB */ +/* File name: "ResampleFilter.m" */ +/* Filter taps in time-domain */ + +#ifndef _RESAMPLEFILTER_H_ +#define _RESAMPLEFILTER_H_ + +#define NUM_TAPS_PER_PHASE 12 +#define INTERP_DECIM_I_D 10 + + +/* Filter for ratios close to 1 */ +static float fResTaps1To1[INTERP_DECIM_I_D][NUM_TAPS_PER_PHASE] = { +{ + -0.00129181992672801360f, + 0.00561586829442904840f, + -0.01349857823816511800f, + 0.02541150940858524100f, + -0.04267869501534898200f, + 0.07724474282951483700f, + 0.96609875058711103000f, + -0.01641812005088002400f, + -0.00427135103965109450f, + 0.00726225824406205160f, + -0.00544188094946287510f, + 0.00266742068076876060f +}, +{ + -0.00207886551285772290f, + 0.00866090598717600930f, + -0.02161960909069559500f, + 0.04383507935997314800f, + -0.08302470868585065700f, + 0.18738870090358245000f, + 0.93524350914423104000f, + -0.09031872116141286000f, + 0.02909509423931267600f, + -0.00897188476756275060f, + 0.00178311012364952820f, + 0.00010586149691723067f +}, +{ + -0.00287519800425638110f, + 0.01143197533872717000f, + -0.02889142869399521600f, + 0.06060641890050100900f, + -0.12152802242786863000f, + 0.30933747340895279000f, + 0.87539536840978205000f, + -0.14271415809850990000f, + 0.05516985095031713000f, + -0.02205265100214613000f, + 0.00761119378345958850f, + -0.00187713739944610450f +}, +{ + -0.00354120720771153910f, + 0.01351098086300389300f, + -0.03433664370844288100f, + 0.07367662235517660800f, + -0.15398027155782226000f, + 0.43728178746780866000f, + 0.79013921003423337000f, + -0.17341770937821352000f, + 0.07263788052016696700f, + -0.03120859084480779800f, + 0.01170664402374247200f, + -0.00319259334815649940f +}, +{ + -0.00391755659664638590f, + 0.01447751287549226700f, + -0.03701682481313090000f, + 0.08107302414568577600f, + -0.17606165300033697000f, + 0.56464344237183917000f, + 0.68451472884717957000f, + -0.18369620562420094000f, + 0.08111657494320076400f, + -0.03614676421513295800f, + 0.01396276906259418800f, + -0.00384568128202934270f +}, +{ + -0.00384568128202934270f, + 0.01396276906259418800f, + -0.03614676421513295800f, + 0.08111657494320076400f, + -0.18369620562420094000f, + 0.68451472884717957000f, + 0.56464344237183917000f, + -0.17606165300033697000f, + 0.08107302414568577600f, + -0.03701682481313090000f, + 0.01447751287549226700f, + -0.00391755659664638590f +}, +{ + -0.00319259334815649940f, + 0.01170664402374247200f, + -0.03120859084480779800f, + 0.07263788052016696700f, + -0.17341770937821352000f, + 0.79013921003423337000f, + 0.43728178746780866000f, + -0.15398027155782226000f, + 0.07367662235517660800f, + -0.03433664370844288100f, + 0.01351098086300389300f, + -0.00354120720771153910f +}, +{ + -0.00187713739944610450f, + 0.00761119378345958850f, + -0.02205265100214613000f, + 0.05516985095031713000f, + -0.14271415809850990000f, + 0.87539536840978205000f, + 0.30933747340895279000f, + -0.12152802242786863000f, + 0.06060641890050100900f, + -0.02889142869399521600f, + 0.01143197533872717000f, + -0.00287519800425638110f +}, +{ + 0.00010586149691723067f, + 0.00178311012364952820f, + -0.00897188476756275060f, + 0.02909509423931267600f, + -0.09031872116141286000f, + 0.93524350914423104000f, + 0.18738870090358245000f, + -0.08302470868585065700f, + 0.04383507935997314800f, + -0.02161960909069559500f, + 0.00866090598717600930f, + -0.00207886551285772290f +}, +{ + 0.00266742068076876060f, + -0.00544188094946287510f, + 0.00726225824406205160f, + -0.00427135103965109450f, + -0.01641812005088002400f, + 0.96609875058711103000f, + 0.07724474282951483700f, + -0.04267869501534898200f, + 0.02541150940858524100f, + -0.01349857823816511800f, + 0.00561586829442904840f, + -0.00129181992672801360f +}, +}; + + +#endif /* _RESAMPLEFILTER_H_ */ diff --git a/src/resamplefilter.m b/src/resamplefilter.m new file mode 100755 index 00000000..c281d082 --- /dev/null +++ b/src/resamplefilter.m @@ -0,0 +1,50 @@ +%/******************************************************************************\ +% * Copyright (c) 2004-2006 +% * +% * Author(s): +% * Volker Fischer +% * +%\******************************************************************************/ + +% Filter for ratios close to 1 ------------------------------------------------- +% Fixed for sample-rate conversiones of R ~ 1 +I = 10; % D = I +% Number of taps per poly-phase +NoTapsP = 12; +% Cut-off frequency +fc = 0.97 / I; +% MMSE filter-design and windowing +h = I * firls(I * NoTapsP - 1, [0 fc fc 1], [1 1 0 0]) .* kaiser(I * NoTapsP, 5)'; + + +% Export coefficiants to file **************************************** +fid = fopen('resamplefilter.h', 'w'); + +fprintf(fid, '/* Automatically generated file with MATLAB */\n'); +fprintf(fid, '/* File name: "ResampleFilter.m" */\n'); +fprintf(fid, '/* Filter taps in time-domain */\n\n'); + +fprintf(fid, '#ifndef _RESAMPLEFILTER_H_\n'); +fprintf(fid, '#define _RESAMPLEFILTER_H_\n\n'); + +fprintf(fid, '#define NUM_TAPS_PER_PHASE '); +fprintf(fid, int2str(NoTapsP)); +fprintf(fid, '\n'); +fprintf(fid, '#define INTERP_DECIM_I_D '); +fprintf(fid, int2str(I)); +fprintf(fid, '\n\n\n'); + +% Write filter taps +fprintf(fid, '/* Filter for ratios close to 1 */\n'); +fprintf(fid, 'static float fResTaps1To1[INTERP_DECIM_I_D][NUM_TAPS_PER_PHASE] = {\n'); +for i = 1:I + hTemp = h(i:I:end) ; + fprintf(fid, '{\n'); + fprintf(fid, ' %.20ff,\n', hTemp(1:end - 1)); + fprintf(fid, ' %.20ff\n', hTemp(end)); + fprintf(fid, '},\n'); +end +fprintf(fid, '};\n\n\n'); + +fprintf(fid, '#endif /* _RESAMPLEFILTER_H_ */\n'); +fclose(fid); diff --git a/src/server.cpp b/src/server.cpp new file mode 100755 index 00000000..afce0053 --- /dev/null +++ b/src/server.cpp @@ -0,0 +1,113 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "server.h" + + +/* Implementation *************************************************************/ +CServer::CServer() : Socket(&ChannelSet) +{ + vecsSendData.Init(BLOCK_SIZE_SAMPLES); + + /* init moving average buffer for response time evaluation */ + RespTimeMoAvBuf.Init(LEN_MOV_AV_RESPONSE); + + /* connect timer timeout signal */ + QObject::connect(&Timer, SIGNAL(timeout()), this, SLOT(OnTimer())); +} + +void CServer::Start() +{ + /* start main timer */ + Timer.start(BLOCK_DURATION_MS); + + /* init time for response time evaluation */ + TimeLastBlock = QTime::currentTime(); +} + +void CServer::OnTimer() +{ + CVector vecChanID; + CVector > vecvecdData(BLOCK_SIZE_SAMPLES); + + /* get data from all connected clients */ + ChannelSet.GetBlockAllConC(vecChanID, vecvecdData); + + /* actual processing of audio data -> mix */ + vecsSendData = ProcessData(vecvecdData); + + /* get number of connected clients from vector size */ + const int iNumClients = vecvecdData.Size(); + + /* send the same data to all connected clients */ + for (int i = 0; i < iNumClients; i++) + { + Socket.SendPacket(ChannelSet.PrepSendPacket(vecChanID[i], vecsSendData), + ChannelSet.GetAddress(vecChanID[i]), + ChannelSet.GetTimeStampIdx(vecChanID[i])); + } + + + /* update response time measurement ------------------------------------- */ + /* add time difference */ + const QTime CurTime = QTime::currentTime(); + + /* we want to calculate the standard deviation (we assume that the mean is + correct at the block period time) */ + const double dCurAddVal = + ((double) TimeLastBlock.msecsTo(CurTime) - BLOCK_DURATION_MS); + + RespTimeMoAvBuf.Add(dCurAddVal * dCurAddVal); /* add squared value */ + + /* store old time value */ + TimeLastBlock = CurTime; +} + +CVector CServer::ProcessData(CVector >& vecvecdData) +{ + CVector vecsOutData; + vecsOutData.Init(BLOCK_SIZE_SAMPLES); + + const int iNumClients = vecvecdData.Size(); + + /* we normalize with sqrt() of N to avoid that the level drops too much + in case that a new client connects */ + const double dNorm = sqrt((double) iNumClients); + + /* mix all audio data from all clients together */ + for (int i = 0; i < BLOCK_SIZE_SAMPLES; i++) + { + double dMixedData = 0.0; + + for (int j = 0; j < iNumClients; j++) + { + dMixedData += vecvecdData[j][i]; + } + + /* normalization and truncating to short */ + vecsOutData[i] = Double2Short(dMixedData / dNorm); + } + + return vecsOutData; +} diff --git a/src/server.h b/src/server.h new file mode 100755 index 00000000..31f7b346 --- /dev/null +++ b/src/server.h @@ -0,0 +1,78 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#if !defined(SERVER_HOIHGE7LOKIH83JH8_3_43445KJIUHF1912__INCLUDED_) +#define SERVER_HOIHGE7LOKIH83JH8_3_43445KJIUHF1912__INCLUDED_ + +#include +#include +#include +#include +#include +#include "global.h" +#include "socket.h" +#include "channel.h" +#include "util.h" + + +/* Classes ********************************************************************/ +class CServer : public QObject +{ + Q_OBJECT + +public: + CServer(); + virtual ~CServer() {} + + void Start(); + void GetConCliParam(CVector& vecHostAddresses, + CVector& vecdSamOffs) + {ChannelSet.GetConCliParam(vecHostAddresses, vecdSamOffs);} + + /* we want to return the standard deviation. For that we need to calculate + the sqaure root */ + double GetTimingStdDev() {return sqrt(RespTimeMoAvBuf.GetAverage());} + + CChannelSet* GetChannelSet() {return &ChannelSet;} + +protected: + CVector ProcessData(CVector >& vecvecdData); + + QTimer Timer; + CVector vecsSendData; + + /* actual working objects */ + CChannelSet ChannelSet; + CSocket Socket; + + /* debugging, evaluating */ + CMovingAv RespTimeMoAvBuf; + QTime TimeLastBlock; + +public slots: + void OnTimer(); +}; + + +#endif /* !defined(SERVER_HOIHGE7LOKIH83JH8_3_43445KJIUHF1912__INCLUDED_) */ diff --git a/src/settings.cpp b/src/settings.cpp new file mode 100755 index 00000000..60bfdc76 --- /dev/null +++ b/src/settings.cpp @@ -0,0 +1,378 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer, Robert Kesterson + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "settings.h" + + +/* Implementation *************************************************************/ +void CSettings::Load () +{ + /* load settings from init-file */ + ReadIniFile (); +} + +void CSettings::Save() +{ + /* write settings in init-file */ + WriteIniFile (); +} + + +/* Read and write init-file ***************************************************/ +void CSettings::ReadIniFile() +{ + int iValue; + bool bValue; + + /* Load data from init-file */ + INIFile ini = LoadIni ( LLCON_INIT_FILE_NAME ); + + + // IP address + pClient->strIPAddress = GetIniSetting ( ini, "Client", "ipaddress" ); + + // audio fader + if ( GetNumericIniSet(ini, "Client", "audfad", 0, AUD_FADER_IN_MAX, iValue ) == TRUE ) { + pClient->SetAudioInFader ( iValue ); + } + + // reverberation level + if ( GetNumericIniSet(ini, "Client", "revlev", 0, AUD_REVERB_MAX, iValue ) == TRUE ) { + pClient->SetReverbLevel ( iValue ); + } + + // reverberation channel assignment + if ( GetFlagIniSet(ini, "Client", "reverblchan", bValue ) == TRUE ) { + pClient->SetReverbOnLeftChan ( bValue ); + } + + // sound card in number of buffers + if ( GetNumericIniSet(ini, "Client", "audinbuf", 0, AUD_SLIDER_LENGTH, iValue ) == TRUE ) { + pClient->GetSndInterface()->SetInNumBuf( iValue ); + } + + // sound card out number of buffers + if ( GetNumericIniSet(ini, "Client", "audoutbuf", 0, AUD_SLIDER_LENGTH, iValue ) == TRUE ) { + pClient->GetSndInterface()->SetOutNumBuf ( iValue ); + } + + // network jitter buffer size + if ( GetNumericIniSet(ini, "Client", "jitbuf", 0, MAX_NET_BUF_SIZE_NUM_BL, iValue ) == TRUE ) { + pClient->GetChannel()->SetSockBufSize ( MIN_BLOCK_SIZE_SAMPLES, iValue ); + } +} + +void CSettings::WriteIniFile() +{ + INIFile ini; + + // IP address + PutIniSetting ( ini, "Client", "ipaddress", pClient->strIPAddress.c_str() ); + + // audio fader + SetNumericIniSet ( ini, "Client", "audfad", pClient->GetAudioInFader () ); + + // reverberation level + SetNumericIniSet ( ini, "Client", "revlev", pClient->GetReverbLevel () ); + + // reverberation channel assignment + SetFlagIniSet ( ini, "Client", "reverblchan", pClient->IsReverbOnLeftChan () ); + + // sound card in number of buffers + SetNumericIniSet ( ini, "Client", "audinbuf", pClient->GetSndInterface()->GetInNumBuf () ); + + // sound card out number of buffers + SetNumericIniSet ( ini, "Client", "audoutbuf", pClient->GetSndInterface()->GetOutNumBuf () ); + + // network jitter buffer size + SetNumericIniSet ( ini, "Client", "jitbuf", pClient->GetChannel()->GetSockBufSize () ); + + + /* Save settings in init-file */ + SaveIni ( ini, LLCON_INIT_FILE_NAME ); +} + +bool CSettings::GetNumericIniSet ( INIFile& theINI, string strSection, + string strKey, int iRangeStart, + int iRangeStop, int& iValue ) +{ + /* Init return value */ + bool bReturn = FALSE; + + const string strGetIni = + GetIniSetting ( theINI, strSection.c_str (), strKey.c_str () ); + + /* Check if it is a valid parameter */ + if ( !strGetIni.empty () ) + { + iValue = atoi( strGetIni.c_str () ); + + /* Check range */ + if ( ( iValue >= iRangeStart ) && ( iValue <= iRangeStop ) ) + { + bReturn = TRUE; + } + } + + return bReturn; +} + +void CSettings::SetNumericIniSet ( INIFile& theINI, string strSection, + string strKey, int iValue ) +{ + char cString[256]; + + sprintf ( cString, "%d", iValue ); + PutIniSetting ( theINI, strSection.c_str (), strKey.c_str (), cString ); +} + +bool CSettings::GetFlagIniSet ( INIFile& theINI, string strSection, + string strKey, bool& bValue ) +{ + /* Init return value */ + bool bReturn = FALSE; + + const string strGetIni = + GetIniSetting ( theINI, strSection.c_str (), strKey.c_str () ); + + if ( !strGetIni.empty () ) + { + if ( atoi ( strGetIni.c_str () ) ) + { + bValue = TRUE; + } + else + { + bValue = FALSE; + } + + bReturn = TRUE; + } + + return bReturn; +} + +void CSettings::SetFlagIniSet ( INIFile& theINI, string strSection, string strKey, + bool bValue ) +{ + if ( bValue == TRUE ) + { + PutIniSetting ( theINI, strSection.c_str (), strKey.c_str (), "1" ); + } + else + { + PutIniSetting ( theINI, strSection.c_str (), strKey.c_str (), "0" ); + } +} + + +/* INI File routines using the STL ********************************************/ +/* The following code was taken from "INI File Tools (STLINI)" written by + Robert Kesterson in 1999. The original files are stlini.cpp and stlini.h. + The homepage is http://robertk.com/source + + Copyright August 18, 1999 by Robert Kesterson */ + +#ifdef _MSC_VER +/* These pragmas are to quiet VC++ about the expanded template identifiers + exceeding 255 chars. You won't be able to see those variables in a debug + session, but the code will run normally */ +#pragma warning (push) +#pragma warning (disable : 4786 4503) +#endif + +string CSettings::GetIniSetting(CSettings::INIFile& theINI, const char* section, + const char* key, const char* defaultval) +{ + string result(defaultval); + INIFile::iterator iSection = theINI.find(string(section)); + + if (iSection != theINI.end()) + { + INISection::iterator apair = iSection->second.find(string(key)); + + if (apair != iSection->second.end()) + result = apair->second; + } + + return result; +} + +void CSettings::PutIniSetting(CSettings::INIFile &theINI, const char *section, + const char *key, const char *value) +{ + INIFile::iterator iniSection; + INISection::iterator apair; + + if ((iniSection = theINI.find(string(section))) == theINI.end()) + { + /* No such section? Then add one */ + INISection newsection; + if (key) + { + newsection.insert( + std::pair(string(key), string(value))); + } + + theINI.insert( + std::pair(string(section), newsection)); + } + else if (key) + { + /* Found section, make sure key isn't in there already, + if it is, just drop and re-add */ + apair = iniSection->second.find(string(key)); + if (apair != iniSection->second.end()) + iniSection->second.erase(apair); + + iniSection->second.insert( + std::pair(string(key), string(value))); + } +} + +CSettings::INIFile CSettings::LoadIni(const char* filename) +{ + INIFile theINI; + char *value, *temp; + string section; + char buffer[MAX_INI_LINE]; + std::fstream file(filename, std::ios::in); + + while (file.good()) + { + memset(buffer, 0, sizeof(buffer)); + file.getline(buffer, sizeof(buffer)); + + if ((temp = strchr(buffer, '\n'))) + *temp = '\0'; /* Cut off at newline */ + + if ((temp = strchr(buffer, '\r'))) + *temp = '\0'; /* Cut off at linefeeds */ + + if ((buffer[0] == '[') && (temp = strrchr(buffer, ']'))) + { /* if line is like --> [section name] */ + *temp = '\0'; /* Chop off the trailing ']' */ + section = &buffer[1]; + PutIniSetting(theINI, &buffer[1]); /* Start new section */ + } + else if (buffer[0] && (value = strchr(buffer, '='))) + { + /* Assign whatever follows = sign to value, chop at "=" */ + *value++ = '\0'; + + /* And add both sides to INISection */ + PutIniSetting(theINI, section.c_str(), buffer, value); + } + else if (buffer[0]) + { + /* Must be a comment or something */ + PutIniSetting(theINI, section.c_str(), buffer, ""); + } + } + return theINI; +} + +void CSettings::SaveIni(CSettings::INIFile &theINI, const char* filename) +{ + bool bFirstSection = TRUE; /* Init flag */ + + std::fstream file(filename, std::ios::out); + if(!file.good()) + return; + + /* Just iterate the hashes and values and dump them to a file */ + INIFile::iterator section = theINI.begin(); + while (section != theINI.end()) + { + if (section->first > "") + { + if (bFirstSection == TRUE) + { + /* Don't put a newline at the beginning of the first section */ + file << "[" << section->first << "]" << std::endl; + + /* Reset flag */ + bFirstSection = FALSE; + } + else + file << std::endl << "[" << section->first << "]" << std::endl; + } + + INISection::iterator pair = section->second.begin(); + + while (pair != section->second.end()) + { + if (pair->second > "") + file << pair->first << "=" << pair->second << std::endl; + else + file << pair->first << "=" << std::endl; + pair++; + } + section++; + } + file.close(); +} + +/* Return true or false depending on whether the first string is less than the + second */ +bool CSettings::StlIniCompareStringNoCase::operator()(const string& x, + const string& y) const +{ +#ifdef WIN32 + return (stricmp(x.c_str(), y.c_str()) < 0) ? true : false; +#else +#ifdef strcasecmp + return (strcasecmp(x.c_str(), y.c_str()) < 0) ? true : false; +#else + unsigned nCount = 0; + int nResult = 0; + const char *p1 = x.c_str(); + const char *p2 = y.c_str(); + + while (*p1 && *p2) + { + nResult = toupper(*p1) - toupper(*p2); + if (nResult != 0) + break; + p1++; + p2++; + nCount++; + } + if (nResult == 0) + { + if (*p1 && !*p2) + nResult = -1; + if (!*p1 && *p2) + nResult = 1; + } + if (nResult < 0) + return true; + return false; +#endif /* strcasecmp */ +#endif +} + +#ifdef _MSC_VER +#pragma warning(pop) +#endif diff --git a/src/settings.h b/src/settings.h new file mode 100755 index 00000000..d51a87bf --- /dev/null +++ b/src/settings.h @@ -0,0 +1,88 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer, Robert Kesterson + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#if !defined(SETTINGS_H__3B0BA660_DGEG56G456G9876D31912__INCLUDED_) +#define SETTINGS_H__3B0BA660_DGEG56G456G9876D31912__INCLUDED_ + +#include "global.h" +#include "client.h" +#include +#include +#include + + +/* Definitions ****************************************************************/ +// name of the init-file +#define LLCON_INIT_FILE_NAME "llcon.ini" + +/* change this if you expect to have huge lines in your INI files. Note that + this is the max size of a single line, NOT the max number of lines */ +#define MAX_INI_LINE 500 + + +/* Classes ********************************************************************/ +class CSettings +{ +public: + CSettings ( CClient* pNCliP ) : pClient ( pNCliP ) {} + + void Load (); + void Save (); + +protected: + void ReadIniFile (); + void WriteIniFile (); + + /* Function declarations for stlini code written by Robert Kesterson */ + struct StlIniCompareStringNoCase + { + bool operator () ( const std::string& x, const std::string& y ) const; + }; + + /* These typedefs just make the code a bit more readable */ + typedef std::map INISection; + typedef std::map INIFile; + + string GetIniSetting( INIFile& theINI, const char* pszSection, + const char* pszKey, const char* pszDefaultVal = "" ); + void PutIniSetting ( INIFile &theINI, const char *pszSection, + const char* pszKey = NULL, const char* pszValue = "" ); + void SaveIni ( INIFile& theINI, const char* pszFilename ); + INIFile LoadIni ( const char* pszFilename ); + + + void SetNumericIniSet ( INIFile& theINI, string strSection, string strKey, + int iValue ); + bool GetNumericIniSet ( INIFile& theINI, string strSection, string strKey, + int iRangeStart, int iRangeStop, int& iValue ); + void SetFlagIniSet ( INIFile& theINI, string strSection, string strKey, + bool bValue ); + bool GetFlagIniSet ( INIFile& theINI, string strSection, string strKey, + bool& bValue ); + + /* Pointer to the client object needed for the various settings */ + CClient* pClient; +}; + +#endif // !defined(SETTINGS_H__3B0BA660_DGEG56G456G9876D31912__INCLUDED_) diff --git a/src/socket.cpp b/src/socket.cpp new file mode 100755 index 00000000..89ebb139 --- /dev/null +++ b/src/socket.cpp @@ -0,0 +1,121 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "socket.h" + + +/* Implementation *************************************************************/ +void CSocket::Init() +{ + /* allocate memory for network receive and send buffer in samples */ + vecbyRecBuf.Init(MAX_SIZE_BYTES_NETW_BUF); + + /* initialize the listening socket */ + bool bSuccess = SocketDevice.bind( + QHostAddress((Q_UINT32) 0) /* INADDR_ANY */, LLCON_PORT_NUMBER); + + if (bIsClient) + { + /* if no success, try if server is on same machine (only for client) */ + if (!bSuccess) + { + /* if server and client is on same machine, decrease port number by + one by definition */ + bSuccess = + SocketDevice.bind(QHostAddress((Q_UINT32) 0) /* INADDR_ANY */, + LLCON_PORT_NUMBER - 1); + } + } + + if (!bSuccess) + { + /* show error message */ + QMessageBox::critical(0, "Network Error", "Cannot bind the socket.", + QMessageBox::Ok, QMessageBox::NoButton); + + /* exit application */ + exit(1); + } + + QSocketNotifier* pSocketNotivRead = + new QSocketNotifier(SocketDevice.socket(), QSocketNotifier::Read); + + /* connect the "activated" signal */ + QObject::connect(pSocketNotivRead, SIGNAL(activated(int)), + this, SLOT(OnDataReceived())); +} + +void CSocket::SendPacket(const CVector& vecbySendBuf, + const CHostAddress& HostAddr, const int iTimeStampIdx) +{ + const int iVecSizeOut = vecbySendBuf.Size(); + + if ( iVecSizeOut != 0 ) + { + /* send packet through network */ + SocketDevice.writeBlock ((const char*) &((CVector) vecbySendBuf)[0], + iVecSizeOut, HostAddr.InetAddr, HostAddr.iPort); + } + + /* sent time stamp if required */ + if (iTimeStampIdx != INVALID_TIME_STAMP_IDX) + { + /* Always one byte long */ + SocketDevice.writeBlock((const char*) &iTimeStampIdx, 1, + HostAddr.InetAddr, HostAddr.iPort); + } +} + +void CSocket::OnDataReceived() +{ + /* read block from network interface */ + const int iNumBytesRead = SocketDevice.readBlock((char*) &vecbyRecBuf[0], + MAX_SIZE_BYTES_NETW_BUF); + + /* check if an error occurred */ + if (iNumBytesRead < 0) + return; + + /* get host address of client */ + CHostAddress RecHostAddr(SocketDevice.peerAddress(), + SocketDevice.peerPort()); + + if (bIsClient) + { + /* client */ + /* check if packet comes from the server we want to connect */ + if (!(pChannel->GetAddress() == RecHostAddr)) + return; + + if (pChannel->PutData(vecbyRecBuf, iNumBytesRead)) + PostWinMessage(MS_JIT_BUF_PUT, MUL_COL_LED_GREEN); + else + PostWinMessage(MS_JIT_BUF_PUT, MUL_COL_LED_RED); + } + else + { + /* server */ + pChannelSet->PutData(vecbyRecBuf, iNumBytesRead, RecHostAddr); + } +} diff --git a/src/socket.h b/src/socket.h new file mode 100755 index 00000000..a215922f --- /dev/null +++ b/src/socket.h @@ -0,0 +1,78 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#if !defined(SOCKET_HOIHGE76GEKJH98_3_4344_BB23945IUHF1912__INCLUDED_) +#define SOCKET_HOIHGE76GEKJH98_3_4344_BB23945IUHF1912__INCLUDED_ + +#include +#include +#include +#include +#include +#include +#include "global.h" +#include "channel.h" +#include "util.h" + + +/* Definitions ****************************************************************/ +/* maximum block size for network input buffer. Consider two bytes per sample */ +#define MAX_SIZE_BYTES_NETW_BUF (BLOCK_SIZE_SAMPLES * 2) + + +/* Classes ********************************************************************/ +class CSocket : public QObject +{ + Q_OBJECT + +public: + CSocket::CSocket(CChannel* pNewChannel) : pChannel(pNewChannel), + SocketDevice(QSocketDevice::Datagram /* UDP */), bIsClient(true) + {Init();} + CSocket::CSocket(CChannelSet* pNewChannelSet) : pChannelSet(pNewChannelSet), + SocketDevice(QSocketDevice::Datagram /* UDP */), bIsClient(false) + {Init();} + virtual ~CSocket() {} + + void SendPacket(const CVector& vecbySendBuf, + const CHostAddress& HostAddr, const int iTimeStampIdx); + +protected: + void Init(); + + QSocketDevice SocketDevice; + + CVector vecbyRecBuf; + CHostAddress RecHostAddr; + + CChannel* pChannel; /* for client */ + CChannelSet* pChannelSet; /* for server */ + bool bIsClient; + +public slots: + void OnDataReceived(); +}; + + +#endif /* !defined(SOCKET_HOIHGE76GEKJH98_3_4344_BB23945IUHF1912__INCLUDED_) */ diff --git a/src/util.cpp b/src/util.cpp new file mode 100755 index 00000000..40e07c9e --- /dev/null +++ b/src/util.cpp @@ -0,0 +1,276 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "util.h" + + +/* Implementation *************************************************************/ +/* Input level meter implementation ------------------------------------------ */ +void CSignalLevelMeter::Update(CVector& vecdAudio) +{ + /* Do the update for entire vector, convert to floating-point */ + const int iVecSize = vecdAudio.Size(); + + for (int i = 0; i < iVecSize; i++) + { + /* norm of current audio sample */ + const double dCurSig = fabs(vecdAudio[i]); + + /* search for maximum. Decrease this max with time */ + /* decrease max with time */ + if (dCurLevel >= METER_FLY_BACK) + dCurLevel -= METER_FLY_BACK; + else + { + if ((dCurLevel <= METER_FLY_BACK) && (dCurLevel > 1.0)) + dCurLevel -= 2.0; + } + + /* search for max */ + if (dCurSig > dCurLevel) + dCurLevel = dCurSig; + } +} + +double CSignalLevelMeter::MicLevel() +{ + const double dNormMicLevel = dCurLevel / _MAXSHORT; + + /* logarithmic measure */ + if (dNormMicLevel > 0) + return 20.0 * log10(dNormMicLevel); + else + return -100000.0; /* large negative value */ +} + + +/* Global functions implementation ********************************************/ +void DebugError(const char* pchErDescr, const char* pchPar1Descr, + const double dPar1, const char* pchPar2Descr, + const double dPar2) +{ + FILE* pFile = fopen("DebugError.dat", "a"); + fprintf(pFile, pchErDescr); fprintf(pFile, " ### "); + fprintf(pFile, pchPar1Descr); fprintf(pFile, ": "); + fprintf(pFile, "%e ### ", dPar1); + fprintf(pFile, pchPar2Descr); fprintf(pFile, ": "); + fprintf(pFile, "%e\n", dPar2); + fclose(pFile); + printf("\nDebug error! For more information see test/DebugError.dat\n"); + exit(1); +} + + +/******************************************************************************\ +* Audio Reverberation * +\******************************************************************************/ +/* + The following code is based on "JCRev: John Chowning's reverberator class" + by Perry R. Cook and Gary P. Scavone, 1995 - 2004 + which is in "The Synthesis ToolKit in C++ (STK)" + http://ccrma.stanford.edu/software/stk + + Original description: + This class is derived from the CLM JCRev function, which is based on the use + of networks of simple allpass and comb delay filters. This class implements + three series allpass units, followed by four parallel comb filters, and two + decorrelation delay lines in parallel at the output. +*/ +CAudioReverb::CAudioReverb(const double rT60) +{ + /* Delay lengths for 44100 Hz sample rate */ + int lengths[9] = {1777, 1847, 1993, 2137, 389, 127, 43, 211, 179}; + const double scaler = (double) SAMPLE_RATE / 44100.0; + + int delay, i; + if (scaler != 1.0) + { + for (i = 0; i < 9; i++) + { + delay = (int) floor(scaler * lengths[i]); + + if ((delay & 1) == 0) + delay++; + + while (!isPrime(delay)) + delay += 2; + + lengths[i] = delay; + } + } + + for (i = 0; i < 3; i++) + allpassDelays_[i].Init(lengths[i + 4]); + + for (i = 0; i < 4; i++) + combDelays_[i].Init(lengths[i]); + + setT60(rT60); + allpassCoefficient_ = (double) 0.7; + Clear(); +} + +bool CAudioReverb::isPrime(const int number) +{ +/* + Returns true if argument value is prime. Taken from "class Effect" in + "STK abstract effects parent class". +*/ + if (number == 2) + return true; + + if (number & 1) + { + for (int i = 3; i < (int) sqrt((double) number) + 1; i += 2) + { + if ((number % i) == 0) + return false; + } + + return true; /* prime */ + } + else + return false; /* even */ +} + +void CAudioReverb::Clear() +{ + /* Reset and clear all internal state */ + allpassDelays_[0].Reset(0); + allpassDelays_[1].Reset(0); + allpassDelays_[2].Reset(0); + combDelays_[0].Reset(0); + combDelays_[1].Reset(0); + combDelays_[2].Reset(0); + combDelays_[3].Reset(0); +} + +void CAudioReverb::setT60(const double rT60) +{ + /* Set the reverberation T60 decay time */ + for (int i = 0; i < 4; i++) + { + combCoefficient_[i] = pow((double) 10.0, (double) (-3.0 * + combDelays_[i].Size() / (rT60 * SAMPLE_RATE))); + } +} + +double CAudioReverb::ProcessSample(const double input) +{ + /* Compute one output sample */ + double temp, temp0, temp1, temp2; + + temp = allpassDelays_[0].Get(); + temp0 = allpassCoefficient_ * temp; + temp0 += input; + allpassDelays_[0].Add((int) temp0); + temp0 = -(allpassCoefficient_ * temp0) + temp; + + temp = allpassDelays_[1].Get(); + temp1 = allpassCoefficient_ * temp; + temp1 += temp0; + allpassDelays_[1].Add((int) temp1); + temp1 = -(allpassCoefficient_ * temp1) + temp; + + temp = allpassDelays_[2].Get(); + temp2 = allpassCoefficient_ * temp; + temp2 += temp1; + allpassDelays_[2].Add((int) temp2); + temp2 = -(allpassCoefficient_ * temp2) + temp; + + const double temp3 = temp2 + (combCoefficient_[0] * combDelays_[0].Get()); + const double temp4 = temp2 + (combCoefficient_[1] * combDelays_[1].Get()); + const double temp5 = temp2 + (combCoefficient_[2] * combDelays_[2].Get()); + const double temp6 = temp2 + (combCoefficient_[3] * combDelays_[3].Get()); + + combDelays_[0].Add((int) temp3); + combDelays_[1].Add((int) temp4); + combDelays_[2].Add((int) temp5); + combDelays_[3].Add((int) temp6); + + return (temp3 + temp4 + temp5 + temp6) * (double) 0.5; +} + + +/******************************************************************************\ +* GUI utilities * +\******************************************************************************/ +/* About dialog ------------------------------------------------------------- */ +CAboutDlg::CAboutDlg(QWidget* parent, const char* name, bool modal, WFlags f) + : CAboutDlgBase(parent, name, modal, f) +{ + /* Set the text for the about dialog html text control */ + TextViewCredits->setText( + "

" /* General description of llcon software */ + "llcon " + tr("Client/Server communication tool to enable " + "musician to play together through a conventional broadband internet " + "connection (like DSL).") + "" + "


" + "

" /* GPL header text */ + "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 his program; if not, write to the Free Software " + "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 " + "USA" + "


" + "

" /* Libraries used by this compilation of Dream */ + "" + tr("llcon uses the following libraries or code snippets:") + + "

" + "
    " + "
  • audio reverberation code: by Perry R. Cook and Gary P. Scavone, " + "1995 - 2004 (taken from \"The Synthesis ToolKit in C++ (STK)\")
    • " + "
  • IMA-ADPCM: by Erik de Castro Lopo
    • " + "
  • INI File Tools (STLINI): Robert Kesterson in 1999
    • " + "
  • Parts from Dream DRM Receiver by Volker Fischer and Alexander " + "Kurpiers
    • " + "
" + "
"); + + /* Set version number in about dialog */ + QString strVersionText; + strVersionText = "
" + tr("llcon, Version "); + strVersionText += VERSION; + strVersionText += "
" + + tr("llcon, Low-Latency (Internet) Connection") + "
"; + strVersionText += tr("Under the GNU General Public License (GPL)") + + "
"; + TextLabelVersion->setText(strVersionText); +} + + +/* Help menu ---------------------------------------------------------------- */ +CLlconHelpMenu::CLlconHelpMenu ( QWidget* parent ) : QPopupMenu ( parent ) +{ + /* Standard help menu consists of about and what's this help */ + insertItem ( tr ( "What's &This" ), this , + SLOT ( OnHelpWhatsThis () ), SHIFT+Key_F1 ); + insertSeparator(); + insertItem ( tr ( "&About..." ), this, SLOT ( OnHelpAbout () ) ); +} diff --git a/src/util.h b/src/util.h new file mode 100755 index 00000000..1c17c130 --- /dev/null +++ b/src/util.h @@ -0,0 +1,381 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#if !defined(UTIL_HOIH934256GEKJH98_3_43445KJIUHF1912__INCLUDED_) +#define UTIL_HOIH934256GEKJH98_3_43445KJIUHF1912__INCLUDED_ + +#include +#include +#include +#include +#include +#include +#include "global.h" +using namespace std; /* Because of the library: "vector" */ +#ifdef _WIN32 +# include "../windows/moc/aboutdlgbase.h" +#else +# include "moc/aboutdlgbase.h" +#endif + + +/* Definitions ****************************************************************/ +#define METER_FLY_BACK 2 + + +/* Global functions ***********************************************************/ +/* Converting double to short */ +inline short Double2Short(const double dInput) +{ + /* Lower bound */ + if (dInput < _MINSHORT) + return _MINSHORT; + + /* Upper bound */ + if (dInput > _MAXSHORT) + return _MAXSHORT; + + return (short) dInput; +} + +/* Debug error handling */ +void DebugError(const char* pchErDescr, const char* pchPar1Descr, + const double dPar1, const char* pchPar2Descr, + const double dPar2); + + +/******************************************************************************\ +* CVector base class * +\******************************************************************************/ +template class CVector : public std::vector +{ +public: + CVector() : iVectorSize(0) {pData = this->begin();} + CVector(const int iNeSi) {Init(iNeSi);} + CVector(const int iNeSi, const TData tInVa) {Init(iNeSi, tInVa);} + virtual ~CVector() {} + + /* Copy constructor: The order of the initialization list must not be + changed. First, the base class must be initialized, then the pData + pointer must be set to the new data source. The bit access is, by + default, reset */ + CVector(const CVector& vecI) : + std::vector(static_cast&>(vecI)), + iVectorSize(vecI.Size()), pData(this->begin()) {} + + void Init(const int iNewSize); + + /* Use this init to give all elements a defined value */ + void Init(const int iNewSize, const TData tIniVal); + void Reset(const TData tResetVal); + + void Enlarge(const int iAddedSize); + void Add(const TData& tI) {Enlarge(1); pData[iVectorSize - 1] = tI;} + + inline int Size() const {return iVectorSize;} + + /* This operator allows for a l-value assignment of this object: + CVector[x] = y is possible */ + inline TData& operator[](const int iPos) { +#ifdef _DEBUG_ + if ((iPos < 0) || (iPos > iVectorSize - 1)) + { + DebugError("Writing vector out of bounds", "Vector size", + iVectorSize, "New parameter", iPos); + } +#endif + return pData[iPos];} + + inline TData operator[](const int iPos) const { +#ifdef _DEBUG_ + if ((iPos < 0) || (iPos > iVectorSize - 1)) + { + DebugError("Reading vector out of bounds", "Vector size", + iVectorSize, "New parameter", iPos); + } +#endif + return pData[iPos];} + + inline CVector& operator=(const CVector& vecI) { +#ifdef _DEBUG_ + /* Vectors which shall be copied MUST have same size! (If this is + satisfied, the parameter "iVectorSize" must not be adjusted as + a side effect) */ + if (vecI.Size() != iVectorSize) + { + DebugError("Vector operator=() different size", "Vector size", + iVectorSize, "New parameter", vecI.Size()); + } +#endif + vector::operator=(vecI); + + /* Reset my data pointer in case, the operator=() of the base class + did change the actual memory */ + pData = this->begin(); + + return *this; + } + +protected: + typename std::vector::iterator pData; + int iVectorSize; +}; + + +/* Implementation *************************************************************/ +template void CVector::Init(const int iNewSize) +{ + iVectorSize = iNewSize; + + /* Clear old buffer and reserve memory for new buffer, get iterator + for pointer operations */ + this->clear(); + this->resize(iNewSize); + pData = this->begin(); +} + +template void CVector::Init(const int iNewSize, + const TData tIniVal) +{ + /* Call actual init routine */ + Init(iNewSize); + + /* Set values */ + Reset(tIniVal); +} + +template void CVector::Enlarge(const int iAddedSize) +{ + iVectorSize += iAddedSize; + this->resize(iVectorSize); + + /* We have to reset the pointer since it could be that the vector size was + zero before enlarging the vector */ + pData = this->begin(); +} + +template void CVector::Reset(const TData tResetVal) +{ + /* Set all values to reset value */ + for (int i = 0; i < iVectorSize; i++) + pData[i] = tResetVal; +} + + +/******************************************************************************\ +* CFIFO class (first in, first out) * +\******************************************************************************/ +template class CFIFO : public CVector +{ +public: + CFIFO() : CVector(), iCurIdx(0) {} + CFIFO(const int iNeSi) : CVector(iNeSi), iCurIdx(0) {} + CFIFO(const int iNeSi, const TData tInVa) : + CVector(iNeSi, tInVa), iCurIdx(0) {} + + void Add(const TData tNewD); + inline TData Get() {return this->pData[iCurIdx];} + + virtual void Init(const int iNewSize); + virtual void Init(const int iNewSize, const TData tIniVal); + +protected: + int iCurIdx; +}; + +template void CFIFO::Init(const int iNewSize) +{ + iCurIdx = 0; + CVector::Init(iNewSize); +} + +template void CFIFO::Init(const int iNewSize, + const TData tIniVal) +{ + iCurIdx = 0; + CVector::Init(iNewSize, tIniVal); +} + +template void CFIFO::Add(const TData tNewD) +{ + this->pData[iCurIdx] = tNewD; + + /* Increment index */ + iCurIdx++; + if (iCurIdx >= this->iVectorSize) + iCurIdx = 0; +} + + +/******************************************************************************\ +* CMovingAv class (moving average) * +\******************************************************************************/ +template class CMovingAv : public CVector +{ +public: + CMovingAv() : CVector(), iCurIdx(0), iNorm(0), + tCurAvResult(TData(0)) {} + CMovingAv(const int iNeSi) : CVector(iNeSi), iCurIdx(0), iNorm(0), + tCurAvResult(TData(0)) {} + CMovingAv(const int iNeSi, const TData tInVa) : + CVector(iNeSi, tInVa), iCurIdx(0), iNorm(0), + tCurAvResult(TData(0)) {} + + void Add(const TData tNewD); + inline TData GetAverage() + { + if (this->iNorm == 0) return TData(0); + else return tCurAvResult / this->iNorm; + } + + virtual void Init(const int iNewSize); + void InitVec(const int iNewSize, const int iNewVecSize); + +protected: + int iCurIdx; + int iNorm; + TData tCurAvResult; +}; + +template void CMovingAv::Init(const int iNewSize) +{ + iNorm = 0; + iCurIdx = 0; + tCurAvResult = TData(0); /* Only for scalars! */ + CVector::Init(iNewSize); +} + +template void CMovingAv::Add(const TData tNewD) +{ +/* + Optimized calculation of the moving average. We only add a new value and + subtract the old value from the result. We only need one addition and a + history buffer +*/ + /* Subtract oldest value */ + tCurAvResult -= this->pData[iCurIdx]; + + /* Add new value and write in memory */ + tCurAvResult += tNewD; + this->pData[iCurIdx] = tNewD; + + /* Increase position pointer and test if wrap */ + iCurIdx++; + if (iCurIdx >= this->iVectorSize) + iCurIdx = 0; + + /* take care of norm */ + if (this->iNorm < this->iVectorSize) + this->iNorm++; +} + + +/******************************************************************************\ +* GUI utilities * +\******************************************************************************/ +/* About dialog ------------------------------------------------------------- */ +class CAboutDlg : public CAboutDlgBase +{ + Q_OBJECT + +public: + CAboutDlg(QWidget* parent = 0, const char* name = 0, bool modal = FALSE, + WFlags f = 0); +}; + + +/* Help menu ---------------------------------------------------------------- */ +class CLlconHelpMenu : public QPopupMenu +{ + Q_OBJECT + +public: + CLlconHelpMenu(QWidget* parent = 0); + +protected: + CAboutDlg AboutDlg; + +public slots: + void OnHelpWhatsThis () { QWhatsThis::enterWhatsThisMode (); } + void OnHelpAbout () { AboutDlg.exec(); } +}; + + +/* Other Classes **************************************************************/ +/* Signal Level Meter ------------------------------------------------------- */ +class CSignalLevelMeter +{ +public: + CSignalLevelMeter() : dCurLevel(0.0) {} + virtual ~CSignalLevelMeter() {} + + void Update(CVector& vecdAudio); + double MicLevel(); + void Reset() {dCurLevel = 0.0;} + +protected: + double dCurLevel; +}; + +class CHostAddress +{ +public: + CHostAddress() : InetAddr((Q_UINT32) 0), iPort(0) {} + CHostAddress(const QHostAddress NInetAddr, const Q_UINT16 iNPort) : + InetAddr(NInetAddr), iPort(iNPort) {} + CHostAddress(const CHostAddress& NHAddr) : + InetAddr(NHAddr.InetAddr), iPort(NHAddr.iPort) {} + + /* copy and compare operators */ + CHostAddress& operator=(const CHostAddress& NHAddr) + {InetAddr = NHAddr.InetAddr; iPort = NHAddr.iPort; return *this;} + bool operator==(const CHostAddress& CompAddr) /* oompare operator */ + {return ((CompAddr.InetAddr == InetAddr) && (CompAddr.iPort == iPort));} + + QHostAddress InetAddr; + Q_UINT16 iPort; +}; + + +/* Audio Reverbration ------------------------------------------------------- */ +class CAudioReverb +{ +public: + CAudioReverb(const double rT60 = (double) 5.0); + + void Clear(); + double ProcessSample(const double input); + +protected: + void setT60(const double rT60); + bool isPrime(const int number); + + CFIFO allpassDelays_[3]; + CFIFO combDelays_[4]; + double allpassCoefficient_; + double combCoefficient_[4]; +}; + + +#endif /* !defined(UTIL_HOIH934256GEKJH98_3_43445KJIUHF1912__INCLUDED_) */ diff --git a/windows/MocQT.bat b/windows/MocQT.bat new file mode 100755 index 00000000..1ab82b26 --- /dev/null +++ b/windows/MocQT.bat @@ -0,0 +1,48 @@ +rem/******************************************************************************\ +rem * Copyright (c) 2004-2006 +rem * +rem * Author(s): +rem * Volker Fischer +rem * +rem * Description: +rem * Script for compiling the QT resources under Windows (MOCing and UICing) +rem ****************************************************************************** +rem * +rem * This program is free software; you can redistribute it and/or modify it under +rem * the terms of the GNU General Public License as published by the Free Software +rem * Foundation; either version 2 of the License, or (at your option) any later +rem * version. +rem * +rem * This program is distributed in the hope that it will be useful, but WITHOUT +rem * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +rem * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 1111 +rem * details. +rem * +rem * You should have received a copy of the GNU General Public License along with +rem * this program; if not, write to the Free Software Foundation, Inc., +rem * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +rem * +rem\******************************************************************************/ + + +rem .h -------------- +%qtdir%\bin\moc.exe ..\src\util.h -o moc\moc_util.cpp +%qtdir%\bin\moc.exe ..\src\multicolorled.h -o moc\moc_multicolorled.cpp +%qtdir%\bin\moc.exe ..\src\llconclientdlg.h -o moc\moc_llconclientdlg.cpp +%qtdir%\bin\moc.exe ..\src\llconserverdlg.h -o moc\moc_llconserverdlg.cpp +%qtdir%\bin\moc.exe ..\src\server.h -o moc\moc_server.cpp +%qtdir%\bin\moc.exe ..\src\socket.h -o moc\moc_socket.cpp + + +rem .ui ------------- +%qtdir%\bin\uic.exe ..\src\aboutdlgbase.ui -o moc\aboutdlgbase.h +%qtdir%\bin\uic.exe ..\src\aboutdlgbase.ui -i aboutdlgbase.h -o moc\aboutdlgbase.cpp +%qtdir%\bin\moc.exe moc\aboutdlgbase.h -o moc\moc_aboutdlgbase.cpp + +%qtdir%\bin\uic.exe ..\src\llconclientdlgbase.ui -o moc\llconclientdlgbase.h +%qtdir%\bin\uic.exe ..\src\llconclientdlgbase.ui -i llconclientdlgbase.h -o moc\llconclientdlgbase.cpp +%qtdir%\bin\moc.exe moc\llconclientdlgbase.h -o moc\moc_llconclientdlgbase.cpp + +%qtdir%\bin\uic.exe ..\src\llconserverdlgbase.ui -o moc\llconserverdlgbase.h +%qtdir%\bin\uic.exe ..\src\llconserverdlgbase.ui -i llconserverdlgbase.h -o moc\llconserverdlgbase.cpp +%qtdir%\bin\moc.exe moc\llconserverdlgbase.h -o moc\moc_llconserverdlgbase.cpp diff --git a/windows/llcon.dsp b/windows/llcon.dsp new file mode 100755 index 00000000..52588c97 --- /dev/null +++ b/windows/llcon.dsp @@ -0,0 +1,313 @@ +# Microsoft Developer Studio Project File - Name="llcon" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Application" 0x0101 + +CFG=llcon - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "llcon.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "llcon.mak" CFG="llcon - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "llcon - Win32 Release" (based on "Win32 (x86) Application") +!MESSAGE "llcon - Win32 Debug" (based on "Win32 (x86) Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +MTL=midl.exe +RSC=rc.exe + +!IF "$(CFG)" == "llcon - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /W3 /GX /O2 /I "$(QTDIR)\include" /I "../src" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "QT_DLL" /D "QT_THREAD_SUPPORT" /FD /c +# SUBTRACT CPP /YX /Yc /Yu +# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32 +# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32 +# ADD BASE RSC /l 0x409 /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 +# ADD LINK32 winmm.lib $(QTDIR)\lib\qt-mt230nc.lib $(QTDIR)\lib\qtmain.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /machine:I386 + +!ELSEIF "$(CFG)" == "llcon - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c +# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "$(QTDIR)\include" /I "../src" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "QT_DLL" /D "QT_THREAD_SUPPORT" /FD /GZ /c +# SUBTRACT CPP /YX /Yc /Yu +# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32 +# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32 +# ADD BASE RSC /l 0x409 /d "_DEBUG" +# ADD RSC /l 0x409 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept +# ADD LINK32 winmm.lib $(QTDIR)\lib\qt-mt230nc.lib $(QTDIR)\lib\qtmain.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /debug /machine:I386 /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "llcon - Win32 Release" +# Name "llcon - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Group "moc Files" + +# PROP Default_Filter "" +# Begin Source File + +SOURCE=.\moc\aboutdlgbase.cpp +# End Source File +# Begin Source File + +SOURCE=.\moc\llconclientdlgbase.cpp +# End Source File +# Begin Source File + +SOURCE=.\moc\llconserverdlgbase.cpp +# End Source File +# Begin Source File + +SOURCE=.\moc\moc_aboutdlgbase.cpp +# End Source File +# Begin Source File + +SOURCE=.\moc\moc_llconclientdlg.cpp +# End Source File +# Begin Source File + +SOURCE=.\moc\moc_llconclientdlgbase.cpp +# End Source File +# Begin Source File + +SOURCE=.\moc\moc_llconserverdlg.cpp +# End Source File +# Begin Source File + +SOURCE=.\moc\moc_llconserverdlgbase.cpp +# End Source File +# Begin Source File + +SOURCE=.\moc\moc_multicolorled.cpp +# End Source File +# Begin Source File + +SOURCE=.\moc\moc_server.cpp +# End Source File +# Begin Source File + +SOURCE=.\moc\moc_socket.cpp +# End Source File +# Begin Source File + +SOURCE=.\moc\moc_util.cpp +# End Source File +# End Group +# Begin Source File + +SOURCE=..\src\audiocompr.cpp +# End Source File +# Begin Source File + +SOURCE=..\src\buffer.cpp +# End Source File +# Begin Source File + +SOURCE=..\src\channel.cpp +# End Source File +# Begin Source File + +SOURCE=..\src\client.cpp +# End Source File +# Begin Source File + +SOURCE=..\src\llconclientdlg.cpp +# End Source File +# Begin Source File + +SOURCE=..\src\llconserverdlg.cpp +# End Source File +# Begin Source File + +SOURCE=..\src\main.cpp +# End Source File +# Begin Source File + +SOURCE=..\src\multicolorled.cpp +# End Source File +# Begin Source File + +SOURCE=..\src\resample.cpp +# End Source File +# Begin Source File + +SOURCE=..\src\server.cpp +# End Source File +# Begin Source File + +SOURCE=..\src\settings.cpp +# End Source File +# Begin Source File + +SOURCE=..\src\socket.cpp +# End Source File +# Begin Source File + +SOURCE=.\sound.cpp +# End Source File +# Begin Source File + +SOURCE=..\src\util.cpp +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=..\src\audiocompr.h +# End Source File +# Begin Source File + +SOURCE=..\src\buffer.h +# End Source File +# Begin Source File + +SOURCE=..\src\channel.h +# End Source File +# Begin Source File + +SOURCE=..\src\client.h +# End Source File +# Begin Source File + +SOURCE=..\src\global.h +# End Source File +# Begin Source File + +SOURCE=..\src\llconclientdlg.h +# End Source File +# Begin Source File + +SOURCE=..\src\llconserverdlg.h +# End Source File +# Begin Source File + +SOURCE=..\src\multicolorled.h +# End Source File +# Begin Source File + +SOURCE=..\src\resample.h +# End Source File +# Begin Source File + +SOURCE=..\src\resamplefilter.h +# End Source File +# Begin Source File + +SOURCE=..\src\server.h +# End Source File +# Begin Source File + +SOURCE=..\src\settings.h +# End Source File +# Begin Source File + +SOURCE=..\src\socket.h +# End Source File +# Begin Source File + +SOURCE=.\sound.h +# End Source File +# Begin Source File + +SOURCE=..\src\util.h +# End Source File +# End Group +# Begin Group "Resource Files" + +# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" +# Begin Source File + +SOURCE=.\llcon.rc +# End Source File +# Begin Source File + +SOURCE=.\mainicon.ico +# End Source File +# End Group +# Begin Source File + +SOURCE=..\AUTHORS +# End Source File +# Begin Source File + +SOURCE=..\ChangeLog +# End Source File +# Begin Source File + +SOURCE=..\COPYING +# End Source File +# Begin Source File + +SOURCE=..\INSTALL +# End Source File +# Begin Source File + +SOURCE=.\MocQT.bat +# End Source File +# Begin Source File + +SOURCE=..\NEWS +# End Source File +# Begin Source File + +SOURCE=..\README +# End Source File +# Begin Source File + +SOURCE=..\TODO +# End Source File +# End Target +# End Project diff --git a/windows/llcon.dsw b/windows/llcon.dsw new file mode 100755 index 00000000..9fb43f96 --- /dev/null +++ b/windows/llcon.dsw @@ -0,0 +1,29 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00 +# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! + +############################################################################### + +Project: "llcon"=.\llcon.dsp - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Global: + +Package=<5> +{{{ +}}} + +Package=<3> +{{{ +}}} + +############################################################################### + diff --git a/windows/llcon.rc b/windows/llcon.rc new file mode 100755 index 00000000..8f0b1527 --- /dev/null +++ b/windows/llcon.rc @@ -0,0 +1,72 @@ +//Microsoft Developer Studio generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDI_MAINICON ICON DISCARDABLE "mainicon.ico" + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE DISCARDABLE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE DISCARDABLE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE DISCARDABLE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/windows/mainicon.ico b/windows/mainicon.ico new file mode 100755 index 00000000..def8ea54 Binary files /dev/null and b/windows/mainicon.ico differ diff --git a/windows/resource.h b/windows/resource.h new file mode 100755 index 00000000..cdb434d9 --- /dev/null +++ b/windows/resource.h @@ -0,0 +1,16 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by llcon.rc +// +#define IDI_MAINICON 101 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 105 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1000 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/windows/sound.cpp b/windows/sound.cpp new file mode 100755 index 00000000..f460c778 --- /dev/null +++ b/windows/sound.cpp @@ -0,0 +1,601 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + * Description: + * Sound card interface for Windows operating systems + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#include "Sound.h" + + +/* Implementation *************************************************************/ +/******************************************************************************\ +* Wave in * +\******************************************************************************/ +bool CSound::Read(CVector& psData) +{ + int i; + bool bError; + + /* Check if device must be opened or reinitialized */ + if (bChangParamIn == TRUE) + { + OpenInDevice(); + + /* Reinit sound interface */ + InitRecording(iBufferSizeIn, bBlockingRec); + + /* Reset flag */ + bChangParamIn = FALSE; + } + + /* Wait until data is available */ + if (!(m_WaveInHeader[iWhichBufferIn].dwFlags & WHDR_DONE)) + { + if (bBlockingRec == TRUE) + WaitForSingleObject(m_WaveInEvent, INFINITE); + else + return FALSE; + } + + /* Check if buffers got lost */ + int iNumInBufDone = 0; + for (i = 0; i < iCurNumSndBufIn; i++) + { + if (m_WaveInHeader[i].dwFlags & WHDR_DONE) + iNumInBufDone++; + } + + /* If the number of done buffers equals the total number of buffers, it is + very likely that a buffer got lost -> set error flag */ + if (iNumInBufDone == iCurNumSndBufIn) + bError = TRUE; + else + bError = FALSE; + + /* Copy data from sound card in output buffer */ + for (i = 0; i < iBufferSizeIn; i++) + psData[i] = psSoundcardBuffer[iWhichBufferIn][i]; + + /* Add the buffer so that it can be filled with new samples */ + AddInBuffer(); + + /* In case more than one buffer was ready, reset event */ + ResetEvent(m_WaveInEvent); + + return bError; +} + +void CSound::AddInBuffer() +{ + /* Unprepare old wave-header */ + waveInUnprepareHeader( + m_WaveIn, &m_WaveInHeader[iWhichBufferIn], sizeof(WAVEHDR)); + + /* Prepare buffers for sending to sound interface */ + PrepareInBuffer(iWhichBufferIn); + + /* Send buffer to driver for filling with new data */ + waveInAddBuffer(m_WaveIn, &m_WaveInHeader[iWhichBufferIn], sizeof(WAVEHDR)); + + /* Toggle buffers */ + iWhichBufferIn++; + if (iWhichBufferIn == iCurNumSndBufIn) + iWhichBufferIn = 0; +} + +void CSound::PrepareInBuffer(int iBufNum) +{ + /* Set struct entries */ + m_WaveInHeader[iBufNum].lpData = (LPSTR) &psSoundcardBuffer[iBufNum][0]; + m_WaveInHeader[iBufNum].dwBufferLength = iBufferSizeIn * BYTES_PER_SAMPLE; + m_WaveInHeader[iBufNum].dwFlags = 0; + + /* Prepare wave-header */ + waveInPrepareHeader(m_WaveIn, &m_WaveInHeader[iBufNum], sizeof(WAVEHDR)); +} + +void CSound::InitRecording(int iNewBufferSize, bool bNewBlocking) +{ + /* Check if device must be opened or reinitialized */ + if (bChangParamIn == TRUE) + { + OpenInDevice(); + + /* Reset flag */ + bChangParamIn = FALSE; + } + + /* Set internal parameter */ + iBufferSizeIn = iNewBufferSize; + bBlockingRec = bNewBlocking; + + /* Reset interface so that all buffers are returned from the interface */ + waveInReset(m_WaveIn); + waveInStop(m_WaveIn); + + /* Reset current buffer ID (it is important to do this BEFORE calling + "AddInBuffer()" */ + iWhichBufferIn = 0; + + /* Create memory for sound card buffer */ + for (int i = 0; i < iCurNumSndBufIn; i++) + { + /* Unprepare old wave-header in case that we "re-initialized" this + module. Calling "waveInUnprepareHeader()" with an unprepared + buffer (when the module is initialized for the first time) has + simply no effect */ + waveInUnprepareHeader(m_WaveIn, &m_WaveInHeader[i], sizeof(WAVEHDR)); + + if (psSoundcardBuffer[i] != NULL) + delete[] psSoundcardBuffer[i]; + + psSoundcardBuffer[i] = new short[iBufferSizeIn]; + + + /* Send all buffers to driver for filling the queue ----------------- */ + /* Prepare buffers before sending them to the sound interface */ + PrepareInBuffer(i); + + AddInBuffer(); + } + + /* Notify that sound capturing can start now */ + waveInStart(m_WaveIn); + + /* This reset event is very important for initialization, otherwise we will + get errors! */ + ResetEvent(m_WaveInEvent); +} + +void CSound::OpenInDevice() +{ + /* Open wave-input and set call-back mechanism to event handle */ + if (m_WaveIn != NULL) + { + waveInReset(m_WaveIn); + waveInClose(m_WaveIn); + } + + MMRESULT result = waveInOpen(&m_WaveIn, iCurInDev, &sWaveFormatEx, + (DWORD) m_WaveInEvent, NULL, CALLBACK_EVENT); + + if (result != MMSYSERR_NOERROR) + { + throw CGenErr("Sound Interface Start, waveInOpen() failed. This error " + "usually occurs if another application blocks the sound in."); + } +} + +void CSound::SetInDev(int iNewDev) +{ + /* Set device to wave mapper if iNewDev is invalid */ + if ((iNewDev >= iNumDevs) || (iNewDev < 0)) + iNewDev = WAVE_MAPPER; + + /* Change only in case new device id is not already active */ + if (iNewDev != iCurInDev) + { + iCurInDev = iNewDev; + bChangParamIn = TRUE; + } +} + +void CSound::SetInNumBuf(int iNewNum) +{ + /* check new parameter */ + if ((iNewNum >= MAX_SND_BUF_IN) || (iNewNum < 1)) + iNewNum = NUM_SOUND_BUFFERS_IN; + + /* Change only if parameter is different */ + if (iNewNum != iCurNumSndBufIn) + { + iCurNumSndBufIn = iNewNum; + bChangParamIn = TRUE; + } +} + + +/******************************************************************************\ +* Wave out * +\******************************************************************************/ +bool CSound::Write(CVector& psData) +{ + int i, j; + int iCntPrepBuf; + int iIndexDoneBuf; + bool bError; + + /* Check if device must be opened or reinitialized */ + if (bChangParamOut == TRUE) + { + OpenOutDevice(); + + /* Reinit sound interface */ + InitPlayback(iBufferSizeOut, bBlockingPlay); + + /* Reset flag */ + bChangParamOut = FALSE; + } + + /* Get number of "done"-buffers and position of one of them */ + GetDoneBuffer(iCntPrepBuf, iIndexDoneBuf); + + /* Now check special cases (Buffer is full or empty) */ + if (iCntPrepBuf == 0) + { + if (bBlockingPlay == TRUE) + { + /* Blocking wave out routine. Needed for transmitter. Always + ensure that the buffer is completely filled to avoid buffer + underruns */ + while (iCntPrepBuf == 0) + { + WaitForSingleObject(m_WaveOutEvent, INFINITE); + + GetDoneBuffer(iCntPrepBuf, iIndexDoneBuf); + } + } + else + { + /* All buffers are filled, dump new block ----------------------- */ +// It would be better to kill half of the buffer blocks to set the start +// back to the middle: TODO + return TRUE; /* An error occurred */ + } + } + else if (iCntPrepBuf == iCurNumSndBufOut) + { + /* --------------------------------------------------------------------- + Buffer is empty -> send as many cleared blocks to the sound- + interface until half of the buffer size is reached */ + /* Send half of the buffer size blocks to the sound-interface */ + for (j = 0; j < iCurNumSndBufOut / 2; j++) + { + /* First, clear these buffers */ + for (i = 0; i < iBufferSizeOut; i++) + psPlaybackBuffer[j][i] = 0; + + /* Then send them to the interface */ + AddOutBuffer(j); + } + + /* Set index for done buffer */ + iIndexDoneBuf = iCurNumSndBufOut / 2; + + bError = TRUE; + } + else + bError = FALSE; + + /* Copy stereo data from input in soundcard buffer */ + for (i = 0; i < iBufferSizeOut; i++) + psPlaybackBuffer[iIndexDoneBuf][i] = psData[i]; + + /* Now, send the current block */ + AddOutBuffer(iIndexDoneBuf); + + return bError; +} + +void CSound::GetDoneBuffer(int& iCntPrepBuf, int& iIndexDoneBuf) +{ + /* Get number of "done"-buffers and position of one of them */ + iCntPrepBuf = 0; + for (int i = 0; i < iCurNumSndBufOut; i++) + { + if (m_WaveOutHeader[i].dwFlags & WHDR_DONE) + { + iCntPrepBuf++; + iIndexDoneBuf = i; + } + } +} + +void CSound::AddOutBuffer(int iBufNum) +{ + /* Unprepare old wave-header */ + waveOutUnprepareHeader( + m_WaveOut, &m_WaveOutHeader[iBufNum], sizeof(WAVEHDR)); + + /* Prepare buffers for sending to sound interface */ + PrepareOutBuffer(iBufNum); + + /* Send buffer to driver for filling with new data */ + waveOutWrite(m_WaveOut, &m_WaveOutHeader[iBufNum], sizeof(WAVEHDR)); +} + +void CSound::PrepareOutBuffer(int iBufNum) +{ + /* Set Header data */ + m_WaveOutHeader[iBufNum].lpData = (LPSTR) &psPlaybackBuffer[iBufNum][0]; + m_WaveOutHeader[iBufNum].dwBufferLength = iBufferSizeOut * BYTES_PER_SAMPLE; + m_WaveOutHeader[iBufNum].dwFlags = 0; + + /* Prepare wave-header */ + waveOutPrepareHeader(m_WaveOut, &m_WaveOutHeader[iBufNum], sizeof(WAVEHDR)); +} + +void CSound::InitPlayback(int iNewBufferSize, bool bNewBlocking) +{ + int i, j; + + /* Check if device must be opened or reinitialized */ + if (bChangParamOut == TRUE) + { + OpenOutDevice(); + + /* Reset flag */ + bChangParamOut = FALSE; + } + + /* Set internal parameters */ + iBufferSizeOut = iNewBufferSize; + bBlockingPlay = bNewBlocking; + + /* Reset interface */ + waveOutReset(m_WaveOut); + + for (j = 0; j < iCurNumSndBufOut; j++) + { + /* Unprepare old wave-header (in case header was not prepared before, + simply nothing happens with this function call */ + waveOutUnprepareHeader(m_WaveOut, &m_WaveOutHeader[j], sizeof(WAVEHDR)); + + /* Create memory for playback buffer */ + if (psPlaybackBuffer[j] != NULL) + delete[] psPlaybackBuffer[j]; + + psPlaybackBuffer[j] = new short[iBufferSizeOut]; + + /* Clear new buffer */ + for (i = 0; i < iBufferSizeOut; i++) + psPlaybackBuffer[j][i] = 0; + + /* Prepare buffer for sending to the sound interface */ + PrepareOutBuffer(j); + + /* Initially, send all buffers to the interface */ + AddOutBuffer(j); + } +} + +void CSound::OpenOutDevice() +{ + if (m_WaveOut != NULL) + { + waveOutReset(m_WaveOut); + waveOutClose(m_WaveOut); + } + + MMRESULT result = waveOutOpen(&m_WaveOut, iCurOutDev, &sWaveFormatEx, + (DWORD) m_WaveOutEvent, NULL, CALLBACK_EVENT); + + if (result != MMSYSERR_NOERROR) + throw CGenErr("Sound Interface Start, waveOutOpen() failed."); +} + +void CSound::SetOutDev(int iNewDev) +{ + /* Set device to wave mapper if iNewDev is invalid */ + if ((iNewDev >= iNumDevs) || (iNewDev < 0)) + iNewDev = WAVE_MAPPER; + + /* Change only in case new device id is not already active */ + if (iNewDev != iCurOutDev) + { + iCurOutDev = iNewDev; + bChangParamOut = TRUE; + } +} + +void CSound::SetOutNumBuf(int iNewNum) +{ + /* check new parameter */ + if ((iNewNum >= MAX_SND_BUF_OUT) || (iNewNum < 1)) + iNewNum = NUM_SOUND_BUFFERS_OUT; + + /* Change only if parameter is different */ + if (iNewNum != iCurNumSndBufOut) + { + iCurNumSndBufOut = iNewNum; + bChangParamOut = TRUE; + } +} + + +/******************************************************************************\ +* Common * +\******************************************************************************/ +void CSound::Close() +{ + int i; + MMRESULT result; + + /* Reset audio driver */ + if (m_WaveOut != NULL) + { + result = waveOutReset(m_WaveOut); + if (result != MMSYSERR_NOERROR) + throw CGenErr("Sound Interface, waveOutReset() failed."); + } + + if (m_WaveIn != NULL) + { + result = waveInReset(m_WaveIn); + if (result != MMSYSERR_NOERROR) + throw CGenErr("Sound Interface, waveInReset() failed."); + } + + /* Set event to ensure that thread leaves the waiting function */ + if (m_WaveInEvent != NULL) + SetEvent(m_WaveInEvent); + + /* Wait for the thread to terminate */ + Sleep(500); + + /* Unprepare wave-headers */ + if (m_WaveIn != NULL) + { + for (i = 0; i < iCurNumSndBufIn; i++) + { + result = waveInUnprepareHeader( + m_WaveIn, &m_WaveInHeader[i], sizeof(WAVEHDR)); + + if (result != MMSYSERR_NOERROR) + { + throw CGenErr("Sound Interface, waveInUnprepareHeader()" + " failed."); + } + } + + /* Close the sound in device */ + result = waveInClose(m_WaveIn); + if (result != MMSYSERR_NOERROR) + throw CGenErr("Sound Interface, waveInClose() failed."); + } + + if (m_WaveOut != NULL) + { + for (i = 0; i < iCurNumSndBufOut; i++) + { + result = waveOutUnprepareHeader( + m_WaveOut, &m_WaveOutHeader[i], sizeof(WAVEHDR)); + + if (result != MMSYSERR_NOERROR) + { + throw CGenErr("Sound Interface, waveOutUnprepareHeader()" + " failed."); + } + } + + /* Close the sound out device */ + result = waveOutClose(m_WaveOut); + if (result != MMSYSERR_NOERROR) + throw CGenErr("Sound Interface, waveOutClose() failed."); + } + + /* Set flag to open devices the next time it is initialized */ + bChangParamIn = TRUE; + bChangParamOut = TRUE; +} + +CSound::CSound() +{ + int i; + + /* init number of sound buffers */ + iCurNumSndBufIn = NUM_SOUND_BUFFERS_IN; + iCurNumSndBufOut = NUM_SOUND_BUFFERS_OUT; + + /* Should be initialized because an error can occur during init */ + m_WaveInEvent = NULL; + m_WaveOutEvent = NULL; + m_WaveIn = NULL; + m_WaveOut = NULL; + + /* Init buffer pointer to zero */ + for (i = 0; i < MAX_SND_BUF_IN; i++) + { + memset(&m_WaveInHeader[i], 0, sizeof(WAVEHDR)); + psSoundcardBuffer[i] = NULL; + } + + for (i = 0; i < MAX_SND_BUF_OUT; i++) + { + memset(&m_WaveOutHeader[i], 0, sizeof(WAVEHDR)); + psPlaybackBuffer[i] = NULL; + } + + /* Init wave-format structure */ + sWaveFormatEx.wFormatTag = WAVE_FORMAT_PCM; + sWaveFormatEx.nChannels = NUM_IN_OUT_CHANNELS; + sWaveFormatEx.wBitsPerSample = BITS_PER_SAMPLE; + sWaveFormatEx.nSamplesPerSec = SND_CRD_SAMPLE_RATE; + sWaveFormatEx.nBlockAlign = sWaveFormatEx.nChannels * + sWaveFormatEx.wBitsPerSample / 8; + sWaveFormatEx.nAvgBytesPerSec = sWaveFormatEx.nBlockAlign * + sWaveFormatEx.nSamplesPerSec; + sWaveFormatEx.cbSize = 0; + + /* Get the number of digital audio devices in this computer, check range */ + iNumDevs = waveInGetNumDevs(); + + if (iNumDevs > MAX_NUMBER_SOUND_CARDS) + iNumDevs = MAX_NUMBER_SOUND_CARDS; + + /* At least one device must exist in the system */ + if (iNumDevs == 0) + throw CGenErr("No audio device found."); + + /* Get info about the devices and store the names */ + for (i = 0; i < iNumDevs; i++) + { + if (!waveInGetDevCaps(i, &m_WaveInDevCaps, sizeof(WAVEINCAPS))) + pstrDevices[i] = m_WaveInDevCaps.szPname; + } + + /* We use an event controlled wave-in (wave-out) structure */ + /* Create events */ + m_WaveInEvent = CreateEvent(NULL, FALSE, FALSE, NULL); + m_WaveOutEvent = CreateEvent(NULL, FALSE, FALSE, NULL); + + /* Set flag to open devices */ + bChangParamIn = TRUE; + bChangParamOut = TRUE; + + /* Default device number, "wave mapper" */ + iCurInDev = WAVE_MAPPER; + iCurOutDev = WAVE_MAPPER; + + /* Non-blocking wave out is default */ + bBlockingPlay = FALSE; + + /* Blocking wave in is default */ + bBlockingRec = TRUE; +} + +CSound::~CSound() +{ + int i; + + /* Delete allocated memory */ + for (i = 0; i < iCurNumSndBufIn; i++) + { + if (psSoundcardBuffer[i] != NULL) + delete[] psSoundcardBuffer[i]; + } + + for (i = 0; i < iCurNumSndBufOut; i++) + { + if (psPlaybackBuffer[i] != NULL) + delete[] psPlaybackBuffer[i]; + } + + /* Close the handle for the events */ + if (m_WaveInEvent != NULL) + CloseHandle(m_WaveInEvent); + + if (m_WaveOutEvent != NULL) + CloseHandle(m_WaveOutEvent); +} diff --git a/windows/sound.h b/windows/sound.h new file mode 100755 index 00000000..d75a7682 --- /dev/null +++ b/windows/sound.h @@ -0,0 +1,119 @@ +/******************************************************************************\ + * Copyright (c) 2004-2006 + * + * Author(s): + * Volker Fischer + * + * + ****************************************************************************** + * + * 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 + * +\******************************************************************************/ + +#if !defined(AFX_SOUNDIN_H__9518A621_7F78_11D3_8C0D_EEBF182CF549__INCLUDED_) +#define AFX_SOUNDIN_H__9518A621_7F78_11D3_8C0D_EEBF182CF549__INCLUDED_ + +#include +#include +#include +#include "../src/util.h" +#include "../src/global.h" + + +/* Definitions ****************************************************************/ +#define NUM_IN_OUT_CHANNELS 2 /* Stereo recording (but we only + use one channel for recording) */ +#define BITS_PER_SAMPLE 16 /* Use all bits of the D/A-converter */ +#define BYTES_PER_SAMPLE 2 /* Number of bytes per sample */ + +#define MAX_SND_BUF_IN 200 +#define MAX_SND_BUF_OUT 200 + +#define NUM_SOUND_BUFFERS_IN (70 / BLOCK_DURATION_MS) +#define NUM_SOUND_BUFFERS_OUT (80 / BLOCK_DURATION_MS) + +//#define NUM_SOUND_BUFFERS_IN 7//200 /* Number of sound card buffers */ +//#define NUM_SOUND_BUFFERS_OUT 8//100//15 /* Number of sound card buffers */ + +/* Maximum number of recognized sound cards installed in the system */ +#define MAX_NUMBER_SOUND_CARDS 10 + + +/* Classes ********************************************************************/ +class CSound +{ +public: + CSound(); + virtual ~CSound(); + + void InitRecording(int iNewBufferSize, bool bNewBlocking = TRUE); + void InitPlayback(int iNewBufferSize, bool bNewBlocking = FALSE); + bool Read(CVector& psData); + bool Write(CVector& psData); + + int GetNumDev() {return iNumDevs;} + std::string GetDeviceName(int iDiD) {return pstrDevices[iDiD];} + void SetOutDev(int iNewDev); + int GetOutDev() {return iCurOutDev;} + void SetInDev(int iNewDev); + int GetInDev() {return iCurInDev;} + void SetOutNumBuf(int iNewNum); + int GetOutNumBuf() {return iCurNumSndBufOut;} + void SetInNumBuf(int iNewNum); + int GetInNumBuf() {return iCurNumSndBufIn;} + + void Close(); + +protected: + void OpenInDevice(); + void OpenOutDevice(); + void PrepareInBuffer(int iBufNum); + void PrepareOutBuffer(int iBufNum); + void AddInBuffer(); + void AddOutBuffer(int iBufNum); + void GetDoneBuffer(int& iCntPrepBuf, int& iIndexDoneBuf); + + WAVEFORMATEX sWaveFormatEx; + UINT iNumDevs; + std::string pstrDevices[MAX_NUMBER_SOUND_CARDS]; + UINT iCurInDev; + UINT iCurOutDev; + bool bChangParamIn; + bool bChangParamOut; + int iCurNumSndBufIn; + int iCurNumSndBufOut; + + /* Wave in */ + WAVEINCAPS m_WaveInDevCaps; + HWAVEIN m_WaveIn; + HANDLE m_WaveInEvent; + WAVEHDR m_WaveInHeader[MAX_SND_BUF_IN]; + int iBufferSizeIn; + int iWhichBufferIn; + short* psSoundcardBuffer[MAX_SND_BUF_IN]; + bool bBlockingRec; + + /* Wave out */ + int iBufferSizeOut; + HWAVEOUT m_WaveOut; + short* psPlaybackBuffer[MAX_SND_BUF_OUT]; + WAVEHDR m_WaveOutHeader[MAX_SND_BUF_OUT]; + HANDLE m_WaveOutEvent; + bool bBlockingPlay; +}; + + +#endif // !defined(AFX_SOUNDIN_H__9518A621_7F78_11D3_8C0D_EEBF182CF549__INCLUDED_)