Merge lp:~alex.barker/mixxx/mixxx-libs into lp:~mixxxdevelopers/mixxx/trunk

[KWhat]

Update of libsoundtouch to 1.6 and fidlib 0.9.10

[RJ Skerry-Ryan (rryan)]

Looks good! Thanks Alex.

review: Approve

=== modified file 'mixxx/build/depends.py'
--- mixxx/build/depends.py	2011-07-19 18:12:33 +0000
+++ mixxx/build/depends.py	2011-07-25 04:35:51 +0000
@@ -208,11 +208,11 @@
         else:
             symbol = 'T_LINUX'
 
-        return [build.env.StaticObject('#lib/fidlib-0.9.9/fidlib.c',
+        return [build.env.StaticObject('#lib/fidlib-0.9.10/fidlib.c',
                                        CPPDEFINES=symbol)]
 
     def configure(self, build, conf):
-        build.env.Append(CPPPATH='#lib/fidlib-0.9.9/')
+        build.env.Append(CPPPATH='#lib/fidlib-0.9.10/')
 
 class KissFFT(Dependence):
 
@@ -231,7 +231,7 @@
         build.env.Append(CPPPATH="#lib/replaygain")
 
 class SoundTouch(Dependence):
-    SOUNDTOUCH_PATH = 'soundtouch-1.5.0'
+    SOUNDTOUCH_PATH = 'soundtouch-1.6.0'
 
     def sources(self, build):
         sources = ['engine/enginebufferscalest.cpp',
@@ -244,21 +244,11 @@
                    '#lib/%s/PeakFinder.cpp' % self.SOUNDTOUCH_PATH,
                    '#lib/%s/BPMDetect.cpp' % self.SOUNDTOUCH_PATH]
         if build.platform_is_windows and build.toolchain_is_msvs:
-            if build.machine_is_64bit:
-                sources.append(
-                    '#lib/%s/cpu_detect_x64_win.cpp' % self.SOUNDTOUCH_PATH)
-            elif build.machine == 'x86':
-                sources.append(
-                    '#lib/%s/cpu_detect_x86_win.cpp' % self.SOUNDTOUCH_PATH)
-            else:
-                raise Exception("Unhandled CPU configuration for SoundTouch")
+            sources.append(
+                '#lib/%s/cpu_detect_x86_win.cpp' % self.SOUNDTOUCH_PATH)
         elif build.toolchain_is_gnu:
-            if build.machine == 'x86_64':
-                sources.append(
-                    '#lib/%s/cpu_detect_x64_gcc.cpp' % self.SOUNDTOUCH_PATH)
-            else:
-                sources.append(
-                    '#lib/%s/cpu_detect_x86_gcc.cpp' % self.SOUNDTOUCH_PATH)
+            sources.append(
+                '#lib/%s/cpu_detect_x86_gcc.cpp' % self.SOUNDTOUCH_PATH)
         else:
             raise Exception("Unhandled CPU configuration for SoundTouch")
 
@@ -268,16 +258,11 @@
         if build.machine_is_64bit or \
                 (build.toolchain_is_msvs and optimize > 1) or \
                 (build.toolchain_is_gnu and optimize > 2):
+            # FIXME -DSOUNDTOUCH_ALLOW_X86_OPTIMIZATIONS needs to be passed somewhere some how.
             sources.extend(
                 ['#lib/%s/mmx_optimized.cpp' % self.SOUNDTOUCH_PATH,
                  '#lib/%s/sse_optimized.cpp' % self.SOUNDTOUCH_PATH,
                  ])
-        if build.toolchain_is_msvs and not build.machine_is_64bit:
-            sources.append('#lib/%s/3dnow_win.cpp' % self.SOUNDTOUCH_PATH)
-        else:
-            # TODO(XXX) the docs refer to a 3dnow_gcc, but we don't seem to have
-            # it.
-            pass
 
         return sources
 

=== modified file 'mixxx/build/qtcreator/mixxx.pro'
--- mixxx/build/qtcreator/mixxx.pro	2011-02-24 21:21:09 +0000
+++ mixxx/build/qtcreator/mixxx.pro	2011-07-25 04:35:51 +0000
@@ -609,7 +609,7 @@
     $$BASE_DIR/lib/soundtouch-1.4.1/cpu_detect_x86_gcc.cpp
 
 # Fidlib
-SOURCES += $$BASE_DIR/lib/fidlib-0.9.9/fidlib.c
+SOURCES += $$BASE_DIR/lib/fidlib-0.9.10/fidlib.c
 win32-g++ {
     DEFINES += T_MINGW
 }

=== added directory 'mixxx/lib/fidlib-0.9.10'
=== added file 'mixxx/lib/fidlib-0.9.10/COPYING'
--- mixxx/lib/fidlib-0.9.10/COPYING	1970-01-01 00:00:00 +0000
+++ mixxx/lib/fidlib-0.9.10/COPYING	2011-07-25 04:35:51 +0000
@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+

+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+

+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+

+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+

+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+

+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year  name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

=== added file 'mixxx/lib/fidlib-0.9.10/COPYING_LIB'
--- mixxx/lib/fidlib-0.9.10/COPYING_LIB	1970-01-01 00:00:00 +0000
+++ mixxx/lib/fidlib-0.9.10/COPYING_LIB	2011-07-25 04:35:51 +0000
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+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 and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+

+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+

+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, 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 library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete 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 distribute a copy of this License along with the
+Library.
+
+  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 Library or any portion
+of it, thus forming a work based on the Library, 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) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+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 Library, 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 Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+

+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you 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.
+
+  If distribution of 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 satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+

+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be 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.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+

+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library 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.
+
+  9. 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 Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+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 with
+this License.
+

+  11. 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 Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library 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 Library.
+
+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.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library 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.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser 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 Library
+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 Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+

+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+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
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "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
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. 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 LIBRARY 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
+LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+

+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+

=== added file 'mixxx/lib/fidlib-0.9.10/fidlib.c'
--- mixxx/lib/fidlib-0.9.10/fidlib.c	1970-01-01 00:00:00 +0000
+++ mixxx/lib/fidlib-0.9.10/fidlib.c	2011-07-25 04:35:51 +0000
@@ -0,0 +1,2304 @@
+//
+//	Fidlib digital filter designer code
+//	-----------------------------------
+//
+//        Copyright (c) 2002-2004 Jim Peters <http://uazu.net/>.  This
+//        file is released under the GNU Lesser General Public License
+//        (LGPL) version 2.1 as published by the Free Software
+//        Foundation.  See the file COPYING_LIB for details, or visit
+//        <http://www.fsf.org/licenses/licenses.html>.
+//
+//	The code in this file was written to go with the Fiview app
+//	(http://uazu.net/fiview/), but it may be used as a library for
+//	other applications.  The idea behind this library is to allow
+//	filters to be designed at run-time, which gives much greater
+//	flexibility to filtering applications.
+//
+//	This file depends on the fidmkf.h file which provides the
+//	filter types from Tony Fisher's 'mkfilter' package.  See that
+//	file for references and links used there.
+//
+//
+//	Here are some of the sources I used whilst writing this code:
+//
+//	Robert Bristow-Johnson's EQ cookbook formulae:
+//	  http://www.harmony-central.com/Computer/Programming/Audio-EQ-Cookbook.txt
+//	
+
+#define VERSION "0.9.10"
+
+//
+//	Filter specification string
+//	---------------------------
+//
+//	The filter specification string can be used to completely
+//	specify the filter, or it can be used with the frequency or
+//	frequency range missing, in which case default values are
+//	picked up from values passed directly to the routine.
+//	
+//	The spec consists of a series of letters usually followed by
+//	the order of the filter and then by any other parameters
+//	required, preceded by slashes.  For example:
+//
+//	  LpBu4/20.4	Lowpass butterworth, 4th order, -3.01dB at 20.4Hz
+//	  BpBu2/3-4	Bandpass butterworth, 2nd order, from 3 to 4Hz
+//	  BpBu2/=3-4	Same filter, but adjusted exactly to the range given
+//	  BsRe/1000/10	Bandstop resonator, Q=1000, frequency 10Hz
+//
+//	The routines fid_design() or fid_parse() are used to convert
+//	this spec-string into filter coefficients and a description
+//	(if required).
+//
+//
+//	Typical usage:
+//	-------------
+//
+//	FidFilter *filt, *filt2;
+//	char *desc;
+//	FidRun *run;
+//	FidFunc *funcp;
+//	void *fbuf1, *fbuf2;
+//	int delay;
+//	void my_error_func(char *err);
+//
+//	// Design a filter, and optionally get its long description
+//	filt= fid_design(spec, rate, freq0, freq1, adj, &desc);
+//
+//	// List all the possible filter types
+//	fid_list_filters(stdout);
+//	okay= fid_list_filters_buf(buf, buf+sizeof(buf));
+//
+//	// Calculate the response of the filter at a given frequency
+//	// (frequency is given as a proportion of the sampling rate, in 
+//	// the range 0 to 0.5).  If phase is returned, then this is 
+//	// given in the range 0 to 1 (for 0 to 2*pi).
+//	resp= fid_response(filt, freq);
+//	resp= fid_response_pha(filt, freq, &phase);
+//
+//	// Estimate the signal delay caused by a particular filter, in samples
+//	delay= fid_calc_delay(filt);
+//	
+//	// Run a given filter (this will do JIT filter compilation if this is
+//	// implemented for this processor / OS)
+//	run= fid_run_new(filt, &funcp);
+//	fbuf1= fid_run_newbuf(run);
+//	fbuf2= fid_run_newbuf(run);
+//	while (...) {
+//	   out_1= funcp(fbuf1, in_1);
+//	   out_2= funcp(fbuf2, in_2);
+//	   if (restart_required) fid_run_zapbuf(fbuf1);
+//	   ...
+//	}
+//	fid_run_freebuf(fbuf2);
+//	fid_run_freebuf(fbuf1);
+//	fid_run_free(run);
+//
+//	// If you need to allocate your own buffers separately for some 
+//	// reason, then do it this way:
+//	run= fid_run_new(filt, &funcp);
+//	len= fid_run_bufsize(run);
+//	fbuf1= Alloc(len); fid_run_initbuf(run, fbuf1);
+//	fbuf2= Alloc(len); fid_run_initbuf(run, fbuf2);
+//	while (...) {
+//	   out_1= funcp(fbuf1, in_1);
+//	   out_2= funcp(fbuf2, in_2);
+//	   if (restart_required) fid_run_zapbuf(fbuf1);
+//	   ...
+//	}
+//	free(fbuf2);
+//	free(fbuf1);
+//	fid_run_free(run);
+//
+//	// Convert an arbitrary filter into a new filter which is a single 
+//	// IIR/FIR pair.  This is done by convolving the coefficients.  This 
+//	// flattened filter will give the same result, in theory.  However, 
+//	// in practice this will be less accurate, especially in cases where 
+//	// the limits of the floating point format are being reached (e.g. 
+//	// subtracting numbers with small highly significant differences).
+//	// The routine also ensures that the IIR first coefficient is 1.0.
+//	filt2= fid_flatten(filt);
+//	free(filt);
+//
+//	// Parse an entire filter-spec string possibly containing several FIR,
+//	// IIR and predefined filters and return it as a FidFilter at the given 
+//	// location.  Stops at the first ,; or unmatched )]} character, or the end
+//	// of the string.  Returns a strdup'd error string on error, or else 0.
+//	err= fid_parse(double rate, char **pp, FidFilter **ffp);
+//
+//	// Set up your own fatal-error handler (default is to dump a message 
+//	// to STDERR and exit on fatal conditions)
+//	fid_set_error_handler(&my_error_func);
+//
+//	// Get the version number of the library as a string (e.g. "1.0.0")
+//	txt= fid_version();
+//
+//	// Design a filter and reduce it to a list of all the non-const 
+//	// coefficients, which is returned in the given double[].  The number
+//	// of coefficients expected must be provided (as a check).
+//	#define N_COEF <whatever>
+//	double coef[N_COEF], gain;
+//	gain= fid_design_coef(coef, N_COEF, spec, rate, freq0, freq1, adj);
+//
+//	// Rewrite a filter spec in a full and/or separated-out form
+//	char *full, *min;
+//	double minf0, minf1;
+//	int minadj;
+//	fid_rewrite_spec(spec, freq0, freq1, adj, &full, &min, &minf0, &minf1, &minadj);
+//	...
+//	free(full); free(min);
+//
+//	// Create a FidFilter based on coefficients provided in the
+//	// given double array.  
+//	static double array[]= { 'I', 3, 1.0, 0.55, 0.77, 'F', 3, 1, -2, 1, 0 };
+//	filt= fid_cv_array(array);
+//
+//	// Join a number of filters into a single filter (and free them too, 
+//	// if the first argument is 1)
+//	filt= fid_cat(0, filt1, filt2, filt3, filt4, 0);
+//
+//
+
+//
+//	Format of returned filter
+//	-------------------------
+//
+//	The filter returned is a single chunk of allocated memory in
+//	which is stored a number of FidFilter instances.  Each
+//	instance has variable length according to the coefficients
+//	contained in it.  It is probably easier to think of this as a
+//	stream of items in memory.  Each sub-filter starts with its
+//	type as a short -- either 'I' for IIR filters, or 'F' for FIR
+//	filters.  (Other types may be added later, e.g. AM modulation
+//	elements, or whatever).  This is followed by a short bitmap
+//	which indicates which of the coefficients are constants,
+//	aiding code-generation.  Next comes the count of the following
+//	coefficients, as an int.  (These header fields normally takes 8 
+//	bytes, the same as a double, but this might depend on the 
+//	platform).  Then follow the coefficients, as doubles.  The next 
+//	sub-filter follows on straight after that.  The end of the list 
+//	is marked by 8 zero bytes, meaning typ==0, cbm==0 and len==0.
+//
+//	The filter can be read with the aid of the FidFilter structure
+//	(giving typ, cbm, len and val[] elements) and the FFNEXT() 
+//	macro: using ff= FFNEXT(ff) steps to the next FidFilter 
+//	structure along the chain.
+//
+//	Note that within the sub-filters, coefficients are listed in
+//	the order that they apply to data, from current-sample
+//	backwards in time, i.e. most recent first (so an FIR val[] of
+//	0, 0, 1 represents a two-sample delay FIR filter).  IIR
+//	filters are *not* necessarily adjusted so that their first
+//	coefficient is 1.
+//
+//	Most filters have their gain pre-adjusted so that some
+//	suitable part of the response is at gain==1.0.  However, this
+//	depends on the filter type.
+//
+
+//
+//	Check that a target macro has been set.  This macro selects
+//	various fixes required on various platforms:
+//
+//	  T_LINUX  Linux, or probably any UNIX-like platform with GCC
+//	  T_MINGW  MinGW -- either building on Win32 or cross-compiling
+//	  T_MSVC   Microsoft Visual C
+//
+//	(On MSVC, add "T_MSVC" to the preprocessor definitions in the
+//	project settings, or add /D "T_MSVC" to the compiler
+//	command-line.)
+//
+
+#ifndef T_LINUX
+#ifndef T_MINGW
+#ifndef T_MSVC
+#error Please define one of the T_* target macros (e.g. -DT_LINUX); see fidlib.c
+#endif
+#endif
+#endif
+
+
+//
+//	Select which method of filter execution is preferred.
+//	RF_CMDLIST is recommended (and is the default).
+//
+//	  RF_COMBINED -- easy to understand code, lower accuracy
+//	  RF_CMDLIST  -- faster pre-compiled code
+//	  RF_JIT      -- fastest JIT run-time generated code (no longer supported)
+//
+
+#ifndef RF_COMBINED
+#ifndef RF_CMDLIST
+#ifndef RF_JIT
+
+#define RF_CMDLIST
+
+#endif
+#endif
+#endif
+
+//
+//	Includes
+//
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include "fidlib.h"
+
+#ifndef M_PI
+#define M_PI           3.14159265358979323846
+#endif
+
+extern FidFilter *mkfilter(char *, ...);
+
+//
+//	Target-specific fixes
+//
+
+// Macro for local inline routines that shouldn't be visible externally
+#ifdef T_MSVC
+ #define STATIC_INLINE static __inline
+#else
+ #define STATIC_INLINE static inline 
+#endif
+
+// MinGW and MSVC fixes
+#if defined(T_MINGW) || defined(T_MSVC)
+ #ifndef vsnprintf
+  #define vsnprintf _vsnprintf
+ #endif
+ #ifndef snprintf
+  #define snprintf _snprintf
+ #endif
+// Not sure if we strictly need this still
+ STATIC_INLINE double 
+ my_asinh(double val) {
+    return log(val + sqrt(val*val + 1.0));
+ }
+ #define asinh(xx) my_asinh(xx)
+#endif
+
+
+//
+//	Support code
+//
+
+static void (*error_handler)(char *err)= 0;
+
+static void 
+error(char *fmt, ...) {
+   char buf[1024];
+   va_list ap;
+   va_start(ap, fmt);
+
+   vsnprintf(buf, sizeof(buf), fmt, ap);	// Ignore overflow
+   buf[sizeof(buf)-1]= 0;
+   if (error_handler) error_handler(buf);
+
+   // If error handler routine returns, we dump to STDERR and exit anyway
+   fprintf(stderr, "fidlib error: %s\n", buf);
+   exit(1);
+}
+
+static char *
+strdupf(char *fmt, ...) {
+   va_list ap;
+   char buf[1024], *rv;
+   int len;
+   va_start(ap, fmt);
+   len= vsnprintf(buf, sizeof(buf), fmt, ap);
+   if (len < 0 || len >= sizeof(buf)-1) 
+      error("strdupf exceeded buffer");
+   rv= strdup(buf);
+   if (!rv) error("Out of memory");
+   return rv;
+}
+
+static void *
+Alloc(int size) {
+   void *vp= calloc(1, size);
+   if (!vp) error("Out of memory");
+   return vp;
+}
+
+#define ALLOC(type) ((type*)Alloc(sizeof(type)))
+#define ALLOC_ARR(cnt, type) ((type*)Alloc((cnt) * sizeof(type)))
+
+
+//
+//      Complex multiply: aa *= bb;
+//
+
+STATIC_INLINE void
+cmul(double *aa, double *bb) {
+   double rr= aa[0] * bb[0] - aa[1] * bb[1];
+   double ii= aa[0] * bb[1] + aa[1] * bb[0];
+   aa[0]= rr;
+   aa[1]= ii;
+}
+
+//
+//      Complex square: aa *= aa;
+//
+
+STATIC_INLINE void
+csqu(double *aa) {
+   double rr= aa[0] * aa[0] - aa[1] * aa[1];
+   double ii= 2 * aa[0] * aa[1];
+   aa[0]= rr;
+   aa[1]= ii;
+}
+
+//
+//      Complex multiply by real: aa *= bb;
+//
+
+STATIC_INLINE void
+cmulr(double *aa, double fact) {
+   aa[0] *= fact;
+   aa[1] *= fact;
+}
+
+//
+//	Complex conjugate: aa= aa*
+//
+
+STATIC_INLINE void 
+cconj(double *aa) {
+   aa[1]= -aa[1];
+}
+
+//
+//      Complex divide: aa /= bb;
+//
+
+STATIC_INLINE void
+cdiv(double *aa, double *bb) {
+   double rr= aa[0] * bb[0] + aa[1] * bb[1];
+   double ii= -aa[0] * bb[1] + aa[1] * bb[0];
+   double fact= 1.0 / (bb[0] * bb[0] + bb[1] * bb[1]);
+   aa[0]= rr * fact;
+   aa[1]= ii * fact;
+}
+
+//
+//	Complex reciprocal: aa= 1/aa
+//
+
+STATIC_INLINE void 
+crecip(double *aa) {
+   double fact= 1.0 / (aa[0] * aa[0] + aa[1] * aa[1]);
+   aa[0] *= fact;
+   aa[1] *= -fact;
+} 
+  
+//
+//	Complex assign: aa= bb
+//
+
+STATIC_INLINE void 
+cass(double *aa, double *bb) {
+   memcpy(aa, bb, 2*sizeof(double));  // Assigning doubles is really slow
+}
+
+//
+//	Complex assign: aa= (rr + ii*j)
+//
+
+STATIC_INLINE void 
+cassz(double *aa, double rr, double ii) {
+   aa[0]= rr;
+   aa[1]= ii;
+}
+
+//
+//	Complex add: aa += bb
+//
+
+STATIC_INLINE void 
+cadd(double *aa, double *bb) {
+   aa[0] += bb[0];
+   aa[1] += bb[1];
+}
+
+//
+//	Complex add: aa += (rr + ii*j)
+//
+
+STATIC_INLINE void 
+caddz(double *aa, double rr, double ii) {
+   aa[0] += rr;
+   aa[1] += ii;
+}
+
+//
+//	Complex subtract: aa -= bb
+//
+
+STATIC_INLINE void 
+csub(double *aa, double *bb) {
+   aa[0] -= bb[0];
+   aa[1] -= bb[1];
+}
+
+//
+//	Complex subtract: aa -= (rr + ii*j)
+//
+
+STATIC_INLINE void 
+csubz(double *aa, double rr, double ii) {
+   aa[0] -= rr;
+   aa[1] -= ii;
+}
+
+//
+//	Complex negate: aa= -aa
+//
+
+STATIC_INLINE void 
+cneg(double *aa) {
+   aa[0]= -aa[0];
+   aa[1]= -aa[1];
+}
+
+//
+//      Evaluate a complex polynomial given the coefficients.
+//      rv[0]+i*rv[1] is the result, in[0]+i*in[1] is the input value.
+//      Coefficients are real values.
+//
+
+STATIC_INLINE void
+evaluate(double *rv, double *coef, int n_coef, double *in) {
+   double pz[2];        // Powers of Z
+
+   // Handle first iteration by hand
+   rv[0]= *coef++;
+   rv[1]= 0;
+
+   if (--n_coef > 0) {
+      // Handle second iteration by hand
+      pz[0]= in[0];
+      pz[1]= in[1];
+      rv[0] += *coef * pz[0];
+      rv[1] += *coef * pz[1];
+      coef++; n_coef--;
+
+      // Loop for remainder
+      while (n_coef > 0) {
+         cmul(pz, in);
+         rv[0] += *coef * pz[0];
+         rv[1] += *coef * pz[1];
+         coef++;
+         n_coef--;
+      }
+   }
+}
+
+
+//
+//	Housekeeping
+//
+
+void 
+fid_set_error_handler(void (*rout)(char*)) {
+   error_handler= rout;
+}
+
+char *
+fid_version() {
+   return VERSION;
+}
+
+
+//
+//	Get the response and phase of a filter at the given frequency
+//	(expressed as a proportion of the sampling rate, 0->0.5).
+//	Phase is returned as a number from 0 to 1, representing a
+//	phase between 0 and two-pi.
+//
+
+double 
+fid_response_pha(FidFilter *filt, double freq, double *phase) {
+   double top[2], bot[2];
+   double theta= freq * 2 * M_PI;
+   double zz[2];
+
+   top[0]= 1;
+   top[1]= 0;
+   bot[0]= 1;
+   bot[1]= 0;
+   zz[0]= cos(theta);
+   zz[1]= sin(theta);
+   
+   while (filt->len) {
+      double resp[2];
+      int cnt= filt->len;
+      evaluate(resp, filt->val, cnt, zz);
+      if (filt->typ == 'I')
+	 cmul(bot, resp); 
+      else if (filt->typ == 'F')
+	 cmul(top, resp);
+      else 
+	 error("Unknown filter type %d in fid_response_pha()", filt->typ);
+      filt= FFNEXT(filt);
+   }
+
+   cdiv(top, bot);
+
+   if (phase) {
+      double pha= atan2(top[1], top[0]) / (2 * M_PI);
+      if (pha < 0) pha += 1.0;
+      *phase= pha;
+   }
+
+   return hypot(top[1], top[0]);
+}
+
+//
+//	Get the response of a filter at the given frequency (expressed
+//	as a proportion of the sampling rate, 0->0.5).
+//
+//	Code duplicate, as I didn't want the overhead of a function
+//	call to fid_response_pha.  Almost every call in this routine
+//	can be inlined.
+//
+
+double 
+fid_response(FidFilter *filt, double freq) {
+   double top[2], bot[2];
+   double theta= freq * 2 * M_PI;
+   double zz[2];
+
+   top[0]= 1;
+   top[1]= 0;
+   bot[0]= 1;
+   bot[1]= 0;
+   zz[0]= cos(theta);
+   zz[1]= sin(theta);
+   
+   while (filt->len) {
+      double resp[2];
+      int cnt= filt->len;
+      evaluate(resp, filt->val, cnt, zz);
+      if (filt->typ == 'I')
+	 cmul(bot, resp); 
+      else if (filt->typ == 'F')
+	 cmul(top, resp);
+      else 
+	 error("Unknown filter type %d in fid_response()", filt->typ);
+      filt= FFNEXT(filt);
+   }
+
+   cdiv(top, bot);
+
+   return hypot(top[1], top[0]);
+}
+
+
+//
+//	Estimate the delay that a filter causes to the signal by
+//	looking for the point at which 50% of the filter calculations
+//	are complete.  This involves running test impulses through the
+//	filter several times.  The estimated delay in samples is
+//	returned.
+//	
+//	Delays longer than 8,000,000 samples are not handled well, as
+//	the code drops out at this point rather than get stuck in an
+//	endless loop.
+//
+
+int 
+fid_calc_delay(FidFilter *filt) {
+   FidRun *run;
+   FidFunc *dostep;
+   void *f1, *f2;
+   double tot, tot100, tot50;
+   int cnt;
+
+   run= fid_run_new(filt, &dostep);
+
+   // Run through to find at least the 99.9% point of filter; the r2
+   // (tot100) filter runs at 4x the speed of the other one to act as
+   // a reference point much further ahead in the impulse response.
+   f1= fid_run_newbuf(run);
+   f2= fid_run_newbuf(run);
+   
+   tot= fabs(dostep(f1, 1.0));
+   tot100= fabs(dostep(f2, 1.0));
+   tot100 += fabs(dostep(f2, 0.0));
+   tot100 += fabs(dostep(f2, 0.0));
+   tot100 += fabs(dostep(f2, 0.0));
+   
+   for (cnt= 1; cnt < 0x1000000; cnt++) {
+      tot += fabs(dostep(f1, 0.0));
+      tot100 += fabs(dostep(f2, 0.0));
+      tot100 += fabs(dostep(f2, 0.0));
+      tot100 += fabs(dostep(f2, 0.0));
+      tot100 += fabs(dostep(f2, 0.0));
+      
+      if (tot/tot100 >= 0.999) break;
+   }
+   fid_run_freebuf(f1);
+   fid_run_freebuf(f2);
+
+   // Now find the 50% point
+   tot50= tot100/2;
+   f1= fid_run_newbuf(run);
+   tot= fabs(dostep(f1, 1.0));
+   for (cnt= 0; tot < tot50; cnt++) 
+      tot += fabs(dostep(f1, 0.0));
+   fid_run_freebuf(f1);
+
+   // Clean up, return
+   fid_run_free(run);
+   return cnt;
+}
+   
+
+//
+//	'mkfilter'-derived code
+//
+
+#include "fidmkf.h"
+
+
+//
+//	Stack a number of identical filters, generating the required
+//	FidFilter* return value
+//
+
+static FidFilter*
+stack_filter(int order, int n_head, int n_val, ...) {
+   FidFilter *rv= FFALLOC(n_head * order, n_val * order);
+   FidFilter *p, *q;
+   va_list ap;
+   int a, b, len;
+
+   if (order == 0) return rv;
+   
+   // Copy from ap
+   va_start(ap, n_val);
+   p= q= rv;
+   for (a= 0; a<n_head; a++) {
+      p->typ= va_arg(ap, int);
+      p->cbm= va_arg(ap, int);
+      p->len= va_arg(ap, int);
+      for (b= 0; b<p->len; b++) 
+	 p->val[b]= va_arg(ap, double);
+      p= FFNEXT(p);
+   }
+   order--;
+
+   // Check length
+   len= ((char*)p)-((char*)q);
+   if (len != FFCSIZE(n_head-1, n_val))
+      error("Internal error; bad call to stack_filter(); length mismatch (%d,%d)",
+	    len, FFCSIZE(n_head-1, n_val));
+   
+   // Make as many additional copies as necessary
+   while (order-- > 0) {
+      memcpy(p, q, len);
+      p= (FidFilter*)(len + (char*)p);
+   }
+   
+   // List is already terminated due to zeroed allocation
+   return rv;
+}
+
+//
+//	Search for a peak between two given frequencies.  It is
+//	assumed that the gradient goes upwards from 'f0' to the peak,
+//	and then down again to 'f3'.  If there are any other curves,
+//	this routine will get confused and will come up with some
+//	frequency, although probably not the right one.  
+//
+//	Returns the frequency of the peak.
+//
+
+static double 
+search_peak(FidFilter *ff, double f0, double f3) {
+   double f1, f2;
+   double r1, r2;
+   int a;
+   
+   // Binary search, modified, taking two intermediate points.  Do 20
+   // subdivisions, which should give 1/2^20 == 1e-6 accuracy compared
+   // to original range.
+   for (a= 0; a<20; a++) {
+      f1= 0.51 * f0 + 0.49 * f3;
+      f2= 0.49 * f0 + 0.51 * f3;
+      if (f1 == f2) break;		// We're hitting FP limit
+      r1= fid_response(ff, f1);
+      r2= fid_response(ff, f2);
+      if (r1 > r2)	// Peak is either to the left, or between f1/f2
+	 f3= f2;
+      else	 	// Peak is either to the right, or between f1/f2
+	 f0= f1;
+   }
+   return (f0+f3)*0.5;
+}
+
+//
+//	Handle the different 'back-ends' for Bessel, Butterworth and
+//	Chebyshev filters.  First argument selects between bilinear
+//	(0) and matched-Z (non-0).  The BL and MZ macros makes this a
+//	bit more obvious in the code.
+//
+//	Overall filter gain is adjusted to give the peak at 1.0.  This
+//	is easy for all types except for band-pass, where a search is
+//	required to find the precise peak.  This is much slower than
+//	the other types.
+//
+
+#define BL 0
+#define MZ 1
+
+static FidFilter*
+do_lowpass(int mz, double freq) {
+   FidFilter *rv;
+   lowpass(prewarp(freq));
+   if (mz) s2z_matchedZ(); else s2z_bilinear();
+   rv= z2fidfilter(1.0, ~0);	// FIR is constant
+   rv->val[0]= 1.0 / fid_response(rv, 0.0);
+   return rv;
+}   
+
+static FidFilter*
+do_highpass(int mz, double freq) {
+   FidFilter *rv;
+   highpass(prewarp(freq));
+   if (mz) s2z_matchedZ(); else s2z_bilinear();
+   rv= z2fidfilter(1.0, ~0);	// FIR is constant
+   rv->val[0]= 1.0 / fid_response(rv, 0.5);
+   return rv;
+}
+
+static FidFilter*
+do_bandpass(int mz, double f0, double f1) {
+   FidFilter *rv;
+   bandpass(prewarp(f0), prewarp(f1));
+   if (mz) s2z_matchedZ(); else s2z_bilinear();
+   rv= z2fidfilter(1.0, ~0);	// FIR is constant
+   rv->val[0]= 1.0 / fid_response(rv, search_peak(rv, f0, f1));
+   return rv;
+}
+
+static FidFilter*
+do_bandstop(int mz, double f0, double f1) {
+   FidFilter *rv;
+   bandstop(prewarp(f0), prewarp(f1));
+   if (mz) s2z_matchedZ(); else s2z_bilinear();
+   rv= z2fidfilter(1.0, 5);	// FIR second coefficient is *non-const* for bandstop
+   rv->val[0]= 1.0 / fid_response(rv, 0.0);	// Use 0Hz response as reference
+   return rv;
+}   
+
+
+//
+//	Information passed to individual filter design routines:
+//
+//	  double* rout(double rate, double f0, double f1, 
+//		       int order, int n_arg, double *arg);
+//
+//	'rate' is the sampling rate, or 1 if not set
+//	'f0' and 'f1' give the frequency or frequency range as a 
+//	 	proportion of the sampling rate
+//	'order' is the order of the filter (the integer passed immediately 
+//		after the name)
+//	'n_arg' is the number of additional arguments for the filter
+//	'arg' gives the additional argument values: arg[n]
+//
+//	Note that #O #o #F and #R are mapped to the f0/f1/order
+//	arguments, and are not included in the arg[] array.
+//
+//	See the previous description for the required meaning of the
+//	return value FidFilter list.
+//	
+
+//
+//	Filter design routines and supporting code
+//
+
+static FidFilter*
+des_bpre(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   bandpass_res(f0, arg[0]);
+   return z2fidfilter(1.0, ~0);	// FIR constant
+}
+
+static FidFilter*
+des_bsre(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   bandstop_res(f0, arg[0]);
+   return z2fidfilter(1.0, 0);	// FIR not constant, depends on freq
+}
+
+static FidFilter*
+des_apre(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   allpass_res(f0, arg[0]);
+   return z2fidfilter(1.0, 0);	// FIR not constant, depends on freq
+}
+
+static FidFilter*
+des_pi(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   prop_integral(prewarp(f0));
+   s2z_bilinear();
+   return z2fidfilter(1.0, 0);	// FIR not constant, depends on freq
+}
+
+static FidFilter*
+des_piz(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   prop_integral(prewarp(f0));
+   s2z_matchedZ();
+   return z2fidfilter(1.0, 0);	// FIR not constant, depends on freq
+}
+
+static FidFilter*
+des_lpbe(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   bessel(order);
+   return do_lowpass(BL, f0);
+}
+
+static FidFilter*
+des_hpbe(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   bessel(order);
+   return do_highpass(BL, f0);
+}
+
+static FidFilter*
+des_bpbe(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   bessel(order);
+   return do_bandpass(BL, f0, f1);
+}
+
+static FidFilter*
+des_bsbe(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   bessel(order);
+   return do_bandstop(BL, f0, f1);
+}
+
+static FidFilter*
+des_lpbez(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   bessel(order);
+   return do_lowpass(MZ, f0);
+}
+
+static FidFilter*
+des_hpbez(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   bessel(order);
+   return do_highpass(MZ, f0);
+}
+
+static FidFilter*
+des_bpbez(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   bessel(order);
+   return do_bandpass(MZ, f0, f1);
+}
+
+static FidFilter*
+des_bsbez(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   bessel(order);
+   return do_bandstop(MZ, f0, f1);
+}
+
+static FidFilter*	// Butterworth-Bessel cross
+des_lpbube(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double tmp[MAXPZ];
+   int a;
+   bessel(order); memcpy(tmp, pol, order * sizeof(double));
+   butterworth(order); 
+   for (a= 0; a<order; a++) pol[a] += (tmp[a]-pol[a]) * 0.01 * arg[0];
+   //for (a= 1; a<order; a+=2) pol[a] += arg[1] * 0.01;
+   return do_lowpass(BL, f0);
+}
+
+static FidFilter*
+des_lpbu(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   butterworth(order);
+   return do_lowpass(BL, f0);
+}
+
+static FidFilter*
+des_hpbu(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   butterworth(order);
+   return do_highpass(BL, f0);
+}
+
+static FidFilter*
+des_bpbu(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   butterworth(order);
+   return do_bandpass(BL, f0, f1);
+}
+
+static FidFilter*
+des_bsbu(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   butterworth(order);
+   return do_bandstop(BL, f0, f1);
+}
+
+static FidFilter*
+des_lpbuz(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   butterworth(order);
+   return do_lowpass(MZ, f0);
+}
+
+static FidFilter*
+des_hpbuz(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   butterworth(order);
+   return do_highpass(MZ, f0);
+}
+
+static FidFilter*
+des_bpbuz(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   butterworth(order);
+   return do_bandpass(MZ, f0, f1);
+}
+
+static FidFilter*
+des_bsbuz(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   butterworth(order);
+   return do_bandstop(MZ, f0, f1);
+}
+
+static FidFilter*
+des_lpch(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   chebyshev(order, arg[0]);
+   return do_lowpass(BL, f0);
+}
+
+static FidFilter*
+des_hpch(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   chebyshev(order, arg[0]);
+   return do_highpass(BL, f0);
+}
+
+static FidFilter*
+des_bpch(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   chebyshev(order, arg[0]);
+   return do_bandpass(BL, f0, f1);
+}
+
+static FidFilter*
+des_bsch(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   chebyshev(order, arg[0]);
+   return do_bandstop(BL, f0, f1);
+}
+
+static FidFilter*
+des_lpchz(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   chebyshev(order, arg[0]);
+   return do_lowpass(MZ, f0);
+}
+
+static FidFilter*
+des_hpchz(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   chebyshev(order, arg[0]);
+   return do_highpass(MZ, f0);
+}
+
+static FidFilter*
+des_bpchz(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   chebyshev(order, arg[0]);
+   return do_bandpass(MZ, f0, f1);
+}
+
+static FidFilter*
+des_bschz(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   chebyshev(order, arg[0]);
+   return do_bandstop(MZ, f0, f1);
+}
+
+static FidFilter*
+des_lpbq(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double omega= 2 * M_PI * f0;
+   double cosv= cos(omega);
+   double alpha= sin(omega) / 2 / arg[0];
+   return stack_filter(order, 3, 7,
+		       'I', 0x0, 3, 1 + alpha, -2 * cosv, 1 - alpha,
+		       'F', 0x7, 3, 1.0, 2.0, 1.0,
+		       'F', 0x0, 1, (1-cosv) * 0.5);
+}
+
+static FidFilter*
+des_hpbq(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double omega= 2 * M_PI * f0;
+   double cosv= cos(omega);
+   double alpha= sin(omega) / 2 / arg[0];
+   return stack_filter(order, 3, 7,
+		       'I', 0x0, 3, 1 + alpha, -2 * cosv, 1 - alpha,
+		       'F', 0x7, 3, 1.0, -2.0, 1.0,
+		       'F', 0x0, 1, (1+cosv) * 0.5);
+}
+
+static FidFilter*
+des_bpbq(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double omega= 2 * M_PI * f0;
+   double cosv= cos(omega);
+   double alpha= sin(omega) / 2 / arg[0];
+   return stack_filter(order, 3, 7,
+		       'I', 0x0, 3, 1 + alpha, -2 * cosv, 1 - alpha,
+		       'F', 0x7, 3, 1.0, 0.0, -1.0,
+		       'F', 0x0, 1, alpha);
+}
+
+static FidFilter*
+des_bsbq(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double omega= 2 * M_PI * f0;
+   double cosv= cos(omega);
+   double alpha= sin(omega) / 2 / arg[0];
+   return stack_filter(order, 2, 6,
+		       'I', 0x0, 3, 1 + alpha, -2 * cosv, 1 - alpha,
+		       'F', 0x5, 3, 1.0, -2 * cosv, 1.0);
+}
+
+static FidFilter*
+des_apbq(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double omega= 2 * M_PI * f0;
+   double cosv= cos(omega);
+   double alpha= sin(omega) / 2 / arg[0];
+   return stack_filter(order, 2, 6,
+		       'I', 0x0, 3, 1 + alpha, -2 * cosv, 1 - alpha,
+		       'F', 0x0, 3, 1 - alpha, -2 * cosv, 1 + alpha);
+}
+
+static FidFilter*
+des_pkbq(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double omega= 2 * M_PI * f0;
+   double cosv= cos(omega);
+   double alpha= sin(omega) / 2 / arg[0];
+   double A= pow(10, arg[1]/40);
+   return stack_filter(order, 2, 6,
+		       'I', 0x0, 3, 1 + alpha/A, -2 * cosv, 1 - alpha/A,
+		       'F', 0x0, 3, 1 + alpha*A, -2 * cosv, 1 - alpha*A);
+}
+
+static FidFilter*
+des_lsbq(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double omega= 2 * M_PI * f0;
+   double cosv= cos(omega);
+   double sinv= sin(omega);
+   double A= pow(10, arg[1]/40);
+   double beta= sqrt((A*A+1)/arg[0] - (A-1)*(A-1));
+   return stack_filter(order, 2, 6,
+		       'I', 0x0, 3,
+		       (A+1) + (A-1)*cosv + beta*sinv,
+		       -2 * ((A-1) + (A+1)*cosv),
+		       (A+1) + (A-1)*cosv - beta*sinv,
+		       'F', 0x0, 3,
+		       A*((A+1) - (A-1)*cosv + beta*sinv),
+		       2*A*((A-1) - (A+1)*cosv),
+		       A*((A+1) - (A-1)*cosv - beta*sinv));
+}
+
+static FidFilter*
+des_hsbq(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double omega= 2 * M_PI * f0;
+   double cosv= cos(omega);
+   double sinv= sin(omega);
+   double A= pow(10, arg[1]/40);
+   double beta= sqrt((A*A+1)/arg[0] - (A-1)*(A-1));
+   return stack_filter(order, 2, 6,
+		       'I', 0x0, 3,
+		       (A+1) - (A-1)*cosv + beta*sinv,
+		       2 * ((A-1) - (A+1)*cosv),
+		       (A+1) - (A-1)*cosv - beta*sinv,
+		       'F', 0x0, 3,
+		       A*((A+1) + (A-1)*cosv + beta*sinv),
+		       -2*A*((A-1) + (A+1)*cosv),
+		       A*((A+1) + (A-1)*cosv - beta*sinv));
+}
+
+static FidFilter*
+des_lpbl(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double wid= 0.4109205/f0;
+   double tot, adj;
+   int max= (int)floor(wid);
+   int a;
+   FidFilter *ff= (FidFilter*)Alloc(FFCSIZE(1, max*2+1));
+   ff->typ= 'F';
+   ff->cbm= 0;
+   ff->len= max*2+1;
+   ff->val[max]= tot= 1.0;
+   for (a= 1; a<=max; a++) {
+      double val= 0.42 + 
+	 0.5 * cos(M_PI * a / wid) +
+	 0.08 * cos(M_PI * 2.0 * a / wid);
+      ff->val[max-a]= val;
+      ff->val[max+a]= val;
+      tot += val * 2.0;
+   }
+   adj= 1/tot;
+   for (a= 0; a<=max*2; a++) ff->val[a] *= adj;
+   return ff;
+}
+
+static FidFilter*
+des_lphm(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double wid= 0.3262096/f0;
+   double tot, adj;
+   int max= (int)floor(wid);
+   int a;
+   FidFilter *ff= (FidFilter*)Alloc(FFCSIZE(1, max*2+1));
+   ff->typ= 'F';
+   ff->cbm= 0;
+   ff->len= max*2+1;
+   ff->val[max]= tot= 1.0;
+   for (a= 1; a<=max; a++) {
+      double val= 0.54 + 
+	 0.46 * cos(M_PI * a / wid);
+      ff->val[max-a]= val;
+      ff->val[max+a]= val;
+      tot += val * 2.0;
+   }
+   adj= 1/tot;
+   for (a= 0; a<=max*2; a++) ff->val[a] *= adj;
+   return ff;
+}
+
+static FidFilter*
+des_lphn(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double wid= 0.360144/f0;
+   double tot, adj;
+   int max= (int)floor(wid);
+   int a;
+   FidFilter *ff= (FidFilter*)Alloc(FFCSIZE(1, max*2+1));
+   ff->typ= 'F';
+   ff->cbm= 0;
+   ff->len= max*2+1;
+   ff->val[max]= tot= 1.0;
+   for (a= 1; a<=max; a++) {
+      double val= 0.5 + 
+	 0.5 * cos(M_PI * a / wid);
+      ff->val[max-a]= val;
+      ff->val[max+a]= val;
+      tot += val * 2.0;
+   }
+   adj= 1/tot;
+   for (a= 0; a<=max*2; a++) ff->val[a] *= adj;
+   return ff;
+}
+
+static FidFilter*
+des_lpba(double rate, double f0, double f1, int order, int n_arg, double *arg) {
+   double wid= 0.3189435/f0;
+   double tot, adj;
+   int max= (int)floor(wid);
+   int a;
+   FidFilter *ff= (FidFilter*)Alloc(FFCSIZE(1, max*2+1));
+   ff->typ= 'F';
+   ff->cbm= 0;
+   ff->len= max*2+1;
+   ff->val[max]= tot= 1.0;
+   for (a= 1; a<=max; a++) {
+      double val= 1.0 - a/wid;
+      ff->val[max-a]= val;
+      ff->val[max+a]= val;
+      tot += val * 2.0;
+   }
+   adj= 1/tot;
+   for (a= 0; a<=max*2; a++) ff->val[a] *= adj;
+   return ff;
+}
+
+
+//
+//	Filter table
+//
+
+static struct {
+   FidFilter *(*rout)(double,double,double,int,int,double*); // Designer routine address
+   char *fmt;	// Format for spec-string
+   char *txt;	// Human-readable description of filter
+} filter[]= {
+   { des_bpre, "BpRe/#V/#F",
+     "Bandpass resonator, Q=#V (0 means Inf), frequency #F" },
+   { des_bsre, "BsRe/#V/#F",
+     "Bandstop resonator, Q=#V (0 means Inf), frequency #F" },
+   { des_apre, "ApRe/#V/#F",
+     "Allpass resonator, Q=#V (0 means Inf), frequency #F" },
+   { des_pi, "Pi/#F",
+     "Proportional-integral filter, frequency #F" },
+   { des_piz, "PiZ/#F",
+     "Proportional-integral filter, matched z-transform, frequency #F" },
+   { des_lpbe, "LpBe#O/#F", 
+     "Lowpass Bessel filter, order #O, -3.01dB frequency #F" },
+   { des_hpbe, "HpBe#O/#F", 
+     "Highpass Bessel filter, order #O, -3.01dB frequency #F" },
+   { des_bpbe, "BpBe#O/#R", 
+     "Bandpass Bessel filter, order #O, -3.01dB frequencies #R" },
+   { des_bsbe, "BsBe#O/#R", 
+     "Bandstop Bessel filter, order #O, -3.01dB frequencies #R" },
+   { des_lpbu, "LpBu#O/#F", 
+     "Lowpass Butterworth filter, order #O, -3.01dB frequency #F" },
+   { des_hpbu, "HpBu#O/#F", 
+     "Highpass Butterworth filter, order #O, -3.01dB frequency #F" },
+   { des_bpbu, "BpBu#O/#R", 
+     "Bandpass Butterworth filter, order #O, -3.01dB frequencies #R" },
+   { des_bsbu, "BsBu#O/#R", 
+     "Bandstop Butterworth filter, order #O, -3.01dB frequencies #R" },
+   { des_lpch, "LpCh#O/#V/#F",
+     "Lowpass Chebyshev filter, order #O, passband ripple #VdB, -3.01dB frequency #F" },
+   { des_hpch, "HpCh#O/#V/#F", 
+     "Highpass Chebyshev filter, order #O, passband ripple #VdB, -3.01dB frequency #F" },
+   { des_bpch, "BpCh#O/#V/#R", 
+     "Bandpass Chebyshev filter, order #O, passband ripple #VdB, -3.01dB frequencies #R" },
+   { des_bsch, "BsCh#O/#V/#R", 
+     "Bandstop Chebyshev filter, order #O, passband ripple #VdB, -3.01dB frequencies #R" },
+   { des_lpbez, "LpBeZ#O/#F",
+     "Lowpass Bessel filter, matched z-transform, order #O, -3.01dB frequency #F" },
+   { des_hpbez, "HpBeZ#O/#F",
+     "Highpass Bessel filter, matched z-transform, order #O, -3.01dB frequency #F" },
+   { des_bpbez, "BpBeZ#O/#R",
+     "Bandpass Bessel filter, matched z-transform, order #O, -3.01dB frequencies #R" },
+   { des_bsbez, "BsBeZ#O/#R",
+     "Bandstop Bessel filter, matched z-transform, order #O, -3.01dB frequencies #R" },
+   { des_lpbuz, "LpBuZ#O/#F",
+     "Lowpass Butterworth filter, matched z-transform, order #O, -3.01dB frequency #F" },
+   { des_hpbuz, "HpBuZ#O/#F",
+     "Highpass Butterworth filter, matched z-transform, order #O, -3.01dB frequency #F" },
+   { des_bpbuz, "BpBuZ#O/#R",
+     "Bandpass Butterworth filter, matched z-transform, order #O, -3.01dB frequencies #R" },
+   { des_bsbuz, "BsBuZ#O/#R",
+     "Bandstop Butterworth filter, matched z-transform, order #O, -3.01dB frequencies #R" },
+   { des_lpchz, "LpChZ#O/#V/#F",
+     "Lowpass Chebyshev filter, matched z-transform, order #O, "
+     "passband ripple #VdB, -3.01dB frequency #F" },
+   { des_hpchz, "HpChZ#O/#V/#F",
+     "Highpass Chebyshev filter, matched z-transform, order #O, "
+     "passband ripple #VdB, -3.01dB frequency #F" },
+   { des_bpchz, "BpChZ#O/#V/#R",
+     "Bandpass Chebyshev filter, matched z-transform, order #O, "
+     "passband ripple #VdB, -3.01dB frequencies #R" },
+   { des_bschz, "BsChZ#O/#V/#R",
+     "Bandstop Chebyshev filter, matched z-transform, order #O, "
+     "passband ripple #VdB, -3.01dB frequencies #R" },
+   { des_lpbube, "LpBuBe#O/#V/#F",
+     "Lowpass Butterworth-Bessel #V% cross, order #O, -3.01dB frequency #F" },
+   { des_lpbq, "LpBq#o/#V/#F",
+     "Lowpass biquad filter, order #O, Q=#V, -3.01dB frequency #F" },
+   { des_hpbq, "HpBq#o/#V/#F",
+     "Highpass biquad filter, order #O, Q=#V, -3.01dB frequency #F" },
+   { des_bpbq, "BpBq#o/#V/#F",
+     "Bandpass biquad filter, order #O, Q=#V, centre frequency #F" },
+   { des_bsbq, "BsBq#o/#V/#F",
+     "Bandstop biquad filter, order #O, Q=#V, centre frequency #F" },
+   { des_apbq, "ApBq#o/#V/#F",
+     "Allpass biquad filter, order #O, Q=#V, centre frequency #F" },
+   { des_pkbq, "PkBq#o/#V/#V/#F",
+     "Peaking biquad filter, order #O, Q=#V, dBgain=#V, frequency #F" },
+   { des_lsbq, "LsBq#o/#V/#V/#F",
+     "Lowpass shelving biquad filter, S=#V, dBgain=#V, frequency #F" },
+   { des_hsbq, "HsBq#o/#V/#V/#F",
+     "Highpass shelving biquad filter, S=#V, dBgain=#V, frequency #F" },
+   { des_lpbl, "LpBl/#F",
+     "Lowpass Blackman window, -3.01dB frequency #F" },
+   { des_lphm, "LpHm/#F",
+     "Lowpass Hamming window, -3.01dB frequency #F" },
+   { des_lphn, "LpHn/#F",
+     "Lowpass Hann window, -3.01dB frequency #F" },
+   { des_lpba, "LpBa/#F",
+     "Lowpass Bartlet (triangular) window, -3.01dB frequency #F" },
+   { 0, 0, 0 }
+};
+
+//
+//	Design a filter.  Spec and range are passed as arguments.  The
+//	return value is a pointer to a FidFilter as documented earlier
+//	in this file.  This needs to be free()d once finished with.
+//
+//	If 'f_adj' is set, then the frequencies fed to the design code
+//	are adjusted automatically to get true sqrt(0.5) (-3.01dB)
+//	values at the provided frequencies.  (This is obviously a
+//	slower operation)
+//
+//	If 'descp' is non-0, then a long description of the filter is
+//	generated and returned as a strdup'd string at the given
+//	location.
+//
+//	Any problem with the spec causes the program to die with an
+//	error message.
+//
+//	'spec' gives the specification string.  The 'rate' argument
+//	gives the sampling rate for the data that will be passed to
+//	the filter.  This is only used to interpret the frequencies
+//	given in the spec or given in 'freq0' and 'freq1'.  Use 1.0 if
+//	the frequencies are given as a proportion of the sampling
+//	rate, in the range 0 to 0.5.  'freq0' and 'freq1' provide the
+//	default frequency or frequency range if this is not included
+//	in the specification string.  These should be -ve if there is
+//	no default range (causing an error if they are omitted from
+//	the 'spec').
+//
+
+typedef struct Spec Spec;
+static char* parse_spec(Spec*);   
+static FidFilter *auto_adjust_single(Spec *sp, double rate, double f0);
+static FidFilter *auto_adjust_dual(Spec *sp, double rate, double f0, double f1);
+struct Spec {
+#define MAXARG 10
+   char *spec;
+   double in_f0, in_f1;
+   int in_adj;
+   double argarr[MAXARG];
+   double f0, f1;
+   int adj;
+   int n_arg;
+   int order;
+   int minlen;		// Minimum length of spec-string, assuming f0/f1 passed separately
+   int n_freq;		// Number of frequencies provided: 0,1,2
+   int fi;		// Filter index (filter[fi])
+};
+
+FidFilter *
+fid_design(const char *spec, double rate, double freq0, double freq1, int f_adj, char **descp) {
+   FidFilter *rv;
+   Spec sp;
+   double f0, f1;
+   char *err;
+
+   // Parse the filter-spec
+   sp.spec= spec;
+   sp.in_f0= freq0;
+   sp.in_f1= freq1;
+   sp.in_adj= f_adj;
+   err= parse_spec(&sp);
+   if (err) error("%s", err);
+   f0= sp.f0;
+   f1= sp.f1;
+
+   // Adjust frequencies to range 0-0.5, and check them
+   f0 /= rate;
+   if (f0 > 0.5) error("Frequency of %gHz out of range with sampling rate of %gHz", f0*rate, rate);
+   f1 /= rate;
+   if (f1 > 0.5) error("Frequency of %gHz out of range with sampling rate of %gHz", f1*rate, rate);
+
+   // Okay we now have a successful spec-match to filter[sp.fi], and sp.n_arg
+   // args are now in sp.argarr[]
+
+   // Generate the filter
+   if (!sp.adj)
+      rv= filter[sp.fi].rout(rate, f0, f1, sp.order, sp.n_arg, sp.argarr);
+   else if (strstr(filter[sp.fi].fmt, "#R"))
+      rv= auto_adjust_dual(&sp, rate, f0, f1);
+   else 
+      rv= auto_adjust_single(&sp, rate, f0);
+   
+   // Generate a long description if required
+   if (descp) {
+      char *fmt= filter[sp.fi].txt;
+      int max= strlen(fmt) + 60 + sp.n_arg * 20;
+      char *desc= (char*)Alloc(max);
+      char *p= desc;
+      char ch;
+      double *arg= sp.argarr;
+      int n_arg= sp.n_arg;
+      
+      while ((ch= *fmt++)) {
+	 if (ch != '#') {
+	    *p++= ch;
+	    continue;
+	 }
+	 
+	 switch (*fmt++) {
+	  case 'O':
+	     p += sprintf(p, "%d", sp.order);
+	     break;
+	  case 'F':
+	     p += sprintf(p, "%g", f0*rate);
+	     break;
+	  case 'R':
+	     p += sprintf(p, "%g-%g", f0*rate, f1*rate);
+	     break;
+	  case 'V':
+	     if (n_arg <= 0) 
+		error("Internal error -- disagreement between filter short-spec\n"
+		      " and long-description over number of arguments");
+	     n_arg--;
+	     p += sprintf(p, "%g", *arg++);
+	     break;
+	  default:
+	     error("Internal error: unknown format in long description: #%c", fmt[-1]);
+	 }
+      }
+      *p++= 0;
+      if (p-desc >= max) error("Internal error: exceeded estimated description buffer");
+      *descp= desc;
+   }
+
+   return rv;
+}
+
+//
+//	Auto-adjust input frequency to give correct sqrt(0.5)
+//	(~-3.01dB) point to 6 figures
+//
+
+#define M301DB (0.707106781186548)
+
+static FidFilter *
+auto_adjust_single(Spec *sp, double rate, double f0) {
+   double a0, a1, a2;
+   FidFilter *(*design)(double,double,double,int,int,double*)= filter[sp->fi].rout;
+   FidFilter *rv= 0;
+   double resp;
+   double r0, r2;
+   int incr;		// Increasing (1) or decreasing (0)
+   int a;
+
+#define DESIGN(aa) design(rate, aa, aa, sp->order, sp->n_arg, sp->argarr)
+#define TEST(aa) { if (rv) {free(rv);rv= 0;} rv= DESIGN(aa); resp= fid_response(rv, f0); }
+
+   // Try and establish a range within which we can find the point
+   a0= f0; TEST(a0); r0= resp;
+   for (a= 2; 1; a*=2) {
+      a2= f0/a; TEST(a2); r2= resp;
+      if ((r0 < M301DB) != (r2 < M301DB)) break;
+      a2= 0.5-((0.5-f0)/a); TEST(a2); r2= resp;
+      if ((r0 < M301DB) != (r2 < M301DB)) break;
+      if (a == 32) 	// No success
+	 error("auto_adjust_single internal error -- can't establish enclosing range");
+   }
+
+   incr= r2 > r0;
+   if (a0 > a2) { 
+      a1= a0; a0= a2; a2= a1;
+      incr= !incr;
+   }
+   
+   // Binary search
+   while (1) {
+      a1= 0.5 * (a0 + a2);
+      if (a1 == a0 || a1 == a2) break;		// Limit of double, sanity check
+      TEST(a1);
+      if (resp >= 0.9999995 * M301DB && resp < 1.0000005 * M301DB) break;
+      if (incr == (resp > M301DB))
+	 a2= a1;
+      else 
+	 a0= a1;
+   }
+
+#undef TEST
+#undef DESIGN
+
+   return rv;
+}
+
+
+//
+//	Auto-adjust input frequencies to give response of sqrt(0.5)
+//	(~-3.01dB) correct to 6sf at the given frequency-points
+//
+
+static FidFilter *
+auto_adjust_dual(Spec *sp, double rate, double f0, double f1) {
+   double mid= 0.5 * (f0+f1);
+   double wid= 0.5 * fabs(f1-f0);
+   FidFilter *(*design)(double,double,double,int,int,double*)= filter[sp->fi].rout;
+   FidFilter *rv= 0;
+   int bpass= -1;
+   double delta;
+   double mid0, mid1;
+   double wid0, wid1;
+   double r0, r1, err0, err1;
+   double perr;
+   int cnt;
+   int cnt_design= 0;
+
+#define DESIGN(mm,ww) { if (rv) {free(rv);rv= 0;} \
+   rv= design(rate, mm-ww, mm+ww, sp->order, sp->n_arg, sp->argarr); \
+   r0= fid_response(rv, f0); r1= fid_response(rv, f1); \
+   err0= fabs(M301DB-r0); err1= fabs(M301DB-r1); cnt_design++; }
+
+#define INC_WID ((r0+r1 < 1.0) == bpass)
+#define INC_MID ((r0 > r1) == bpass)
+#define MATCH (err0 < 0.000000499 && err1 < 0.000000499)
+#define PERR (err0+err1)
+
+   DESIGN(mid, wid);
+   bpass= (fid_response(rv, 0) < 0.5);
+   delta= wid * 0.5;
+   
+   // Try delta changes until we get there
+   for (cnt= 0; 1; cnt++, delta *= 0.51) {
+      DESIGN(mid, wid);		// I know -- this is redundant
+      perr= PERR;
+
+      mid0= mid;
+      wid0= wid;
+      mid1= mid + (INC_MID ? delta : -delta);
+      wid1= wid + (INC_WID ? delta : -delta);
+      
+      if (mid0 - wid1 > 0.0 && mid0 + wid1 < 0.5) {
+	 DESIGN(mid0, wid1);
+	 if (MATCH) break;
+	 if (PERR < perr) { perr= PERR; mid= mid0; wid= wid1; }
+      }
+	 
+      if (mid1 - wid0 > 0.0 && mid1 + wid0 < 0.5) {
+	 DESIGN(mid1, wid0);
+	 if (MATCH) break;
+	 if (PERR < perr) { perr= PERR; mid= mid1; wid= wid0; }
+      }
+
+      if (mid1 - wid1 > 0.0 && mid1 + wid1 < 0.5) {
+	 DESIGN(mid1, wid1);
+	 if (MATCH) break;
+	 if (PERR < perr) { perr= PERR; mid= mid1; wid= wid1; }
+      }
+
+      if (cnt > 1000)
+	 error("auto_adjust_dual -- design not converging");
+   }
+
+#undef INC_WID
+#undef INC_MID
+#undef MATCH
+#undef PERR
+#undef DESIGN
+
+   return rv;
+}
+
+
+//
+//	Expand a specification string to the given buffer; if out of
+//	space, drops dead
+//
+
+static void 
+expand_spec(char *buf, char *bufend, char *str) {
+   int ch;
+   char *p= buf;
+
+   while ((ch= *str++)) {
+      if (p + 10 >= bufend) 
+	 error("Buffer overflow in fidlib expand_spec()");
+      if (ch == '#') {
+	 switch (*str++) {
+	  case 'o': p += sprintf(p, "<optional-order>"); break;
+	  case 'O': p += sprintf(p, "<order>"); break;
+	  case 'F': p += sprintf(p, "<freq>"); break;
+	  case 'R': p += sprintf(p, "<range>"); break;
+	  case 'V': p += sprintf(p, "<value>"); break;
+	  default: p += sprintf(p, "<%c>", str[-1]); break;
+	 }
+      } else {
+	 *p++= ch;
+      }
+   }
+   *p= 0;
+}
+
+//
+//	Design a filter and reduce it to a list of all the non-const
+//	coefficients.  Arguments are as for fid_filter().  The
+//	coefficients are written into the given double array.  If the
+//	number of coefficients doesn't match the array length given,
+//	then a fatal error is generated.
+//
+//	Note that all 1-element FIRs and IIR first-coefficients are
+//	merged into a single gain coefficient, which is returned
+//	rather than being included in the coefficient list.  This is
+//	to allow it to be merged with other gains within a stack of
+//	filters.
+//
+//	The algorithm used here (merging 1-element FIRs and adjusting
+//	IIR first-coefficients) must match that used in the code-
+//	generating code, or else the coefficients won't match up.  The
+//	'n_coef' argument provides a partial safeguard.
+//
+
+double 
+fid_design_coef(double *coef, int n_coef, const char *spec, double rate, 
+		double freq0, double freq1, int adj) {
+   FidFilter *filt= fid_design(spec, rate, freq0, freq1, adj, 0);
+   FidFilter *ff= filt;
+   int a, len;
+   int cnt= 0;
+   double gain= 1.0;
+   double *iir, *fir, iir_adj;
+   static double const_one= 1;
+   int n_iir, n_fir;
+   int iir_cbm, fir_cbm;
+
+   while (ff->typ) {
+      if (ff->typ == 'F' && ff->len == 1) {
+	 gain *= ff->val[0];
+	 ff= FFNEXT(ff);
+	 continue;
+      }
+
+      if (ff->typ != 'I' && ff->typ != 'F')
+	 error("fid_design_coef can't handle FidFilter type: %c", ff->typ);
+
+      // Initialise to safe defaults
+      iir= fir= &const_one;
+      n_iir= n_fir= 1;
+      iir_cbm= fir_cbm= ~0;
+
+      // See if we have an IIR filter
+      if (ff->typ == 'I') {
+	 iir= ff->val;
+	 n_iir= ff->len;
+	 iir_cbm= ff->cbm;
+	 iir_adj= 1.0 / ff->val[0];
+	 ff= FFNEXT(ff);
+	 gain *= iir_adj;
+      }
+
+      // See if we have an FIR filter
+      if (ff->typ == 'F') {
+	 fir= ff->val;
+	 n_fir= ff->len;
+	 fir_cbm= ff->cbm;
+	 ff= FFNEXT(ff);
+      }
+
+      // Dump out all non-const coefficients in reverse order
+      len= n_fir > n_iir ? n_fir : n_iir;
+      for (a= len-1; a>=0; a--) {
+	 // Output IIR if present and non-const
+	 if (a < n_iir && a>0 && 
+	     !(iir_cbm & (1<<(a<15?a:15)))) {
+	    if (cnt++ < n_coef) *coef++= iir_adj * iir[a];
+	 }
+
+	 // Output FIR if present and non-const
+	 if (a < n_fir && 
+	     !(fir_cbm & (1<<(a<15?a:15)))) {
+	    if (cnt++ < n_coef) *coef++= fir[a];
+	 }
+      }
+   }
+
+   if (cnt != n_coef)
+      error("fid_design_coef called with the wrong number of coefficients.\n"
+	    "  Given %d, expecting %d: (\"%s\",%g,%g,%g,%d)",
+	    n_coef, cnt, spec, rate, freq0, freq1, adj);
+   
+   free(filt);
+   return gain;
+}
+   
+//
+//	List all the known filters to the given file handle
+//
+
+void 
+fid_list_filters(FILE *out) {
+   int a;
+
+   for (a= 0; filter[a].fmt; a++) {
+      char buf[4096];
+      expand_spec(buf, buf+sizeof(buf), filter[a].fmt);
+      fprintf(out, "%s\n    ", buf);
+      expand_spec(buf, buf+sizeof(buf), filter[a].txt);
+      fprintf(out, "%s\n", buf);
+   }
+}
+
+//
+//	List all the known filters to the given buffer; the buffer is
+//	NUL-terminated; returns 1 okay, 0 not enough space
+//
+
+int 
+fid_list_filters_buf(char *buf, char *bufend) {
+   int a, cnt;
+   char tmp[4096];
+
+   for (a= 0; filter[a].fmt; a++) {
+      expand_spec(tmp, tmp+sizeof(tmp), filter[a].fmt);
+      buf += (cnt= snprintf(buf, bufend-buf, "%s\n    ", tmp));
+      if (cnt < 0 || buf >= bufend) return 0;
+      expand_spec(tmp, tmp+sizeof(tmp), filter[a].txt);
+      buf += (cnt= snprintf(buf, bufend-buf, "%s\n", tmp));
+      if (cnt < 0 || buf >= bufend) return 0;
+   }
+   return 1;
+}
+
+//
+//      Do a convolution of parameters in place
+//
+
+STATIC_INLINE int
+convolve(double *dst, int n_dst, double *src, int n_src) {
+   int len= n_dst + n_src - 1;
+   int a, b;
+
+   for (a= len-1; a>=0; a--) {
+      double val= 0;
+      for (b= 0; b<n_src; b++)
+         if (a-b >= 0 && a-b < n_dst)
+            val += src[b] * dst[a-b];
+      dst[a]= val;
+   }
+
+   return len;
+}
+
+//
+//	Generate a combined filter -- merge all the IIR/FIR
+//	sub-filters into a single IIR/FIR pair, and make sure the IIR
+//	first coefficient is 1.0.
+//
+
+FidFilter *
+fid_flatten(FidFilter *filt) {
+   int m_fir= 1;	// Maximum values
+   int m_iir= 1;
+   int n_fir, n_iir;	// Stored counts during convolution
+   FidFilter *ff;
+   FidFilter *rv;
+   double *fir, *iir;
+   double adj;
+   int a;
+
+   // Find the size of the output filter
+   ff= filt;
+   while (ff->len) {
+      if (ff->typ == 'I')
+	 m_iir += ff->len-1;
+      else if (ff->typ == 'F')
+	 m_fir += ff->len-1;
+      else 
+	 error("fid_flatten doesn't know about type %d", ff->typ);
+      ff= FFNEXT(ff);
+   }
+   
+   // Setup the output array
+   rv= FFALLOC(2, m_iir + m_fir);
+   rv->typ= 'I';
+   rv->len= m_iir;
+   iir= rv->val;
+   ff= FFNEXT(rv);
+   ff->typ= 'F';
+   ff->len= m_fir;
+   fir= ff->val;
+
+   iir[0]= 1.0; n_iir= 1;
+   fir[0]= 1.0; n_fir= 1;
+
+   // Do the convolution
+   ff= filt;
+   while (ff->len) {
+      if (ff->typ == 'I') 
+	 n_iir= convolve(iir, n_iir, ff->val, ff->len);
+      else 
+	 n_fir= convolve(fir, n_fir, ff->val, ff->len);
+      ff= FFNEXT(ff);
+   }
+
+   // Sanity check
+   if (n_iir != m_iir ||
+       n_fir != m_fir) 
+      error("Internal error in fid_combine() -- array under/overflow");
+
+   // Fix iir[0]
+   adj= 1.0/iir[0];
+   for (a= 0; a<n_iir; a++) iir[a] *= adj;
+   for (a= 0; a<n_fir; a++) fir[a] *= adj;
+
+   return rv;
+}
+
+//
+//	Parse a filter-spec and freq0/freq1 arguments.  Returns a
+//	strdup'd error string on error, or else 0.
+//
+
+static char *
+parse_spec(Spec *sp) {
+   double *arg;
+   int a;
+
+   arg= sp->argarr;
+   sp->n_arg= 0;
+   sp->order= 0;
+   sp->f0= 0;
+   sp->f1= 0; 
+   sp->adj= 0;
+   sp->minlen= -1;
+   sp->n_freq= 0;
+   
+   for (a= 0; 1; a++) {
+      char *fmt= filter[a].fmt;
+      char *p= sp->spec;
+      char ch, *q;
+
+      if (!fmt) return strdupf("Spec-string \"%s\" matches no known format", sp->spec);
+
+      while (*p && (ch= *fmt++)) {
+	 if (ch != '#') {
+	    if (ch == *p++) continue;
+	    p= 0; break;
+	 }
+
+	 if (isalpha(*p)) { p= 0; break; }
+
+	 // Handling a format character
+	 switch (ch= *fmt++) {
+	  default:
+	     return strdupf("Internal error: Unknown format #%c in format: %s", 
+			    fmt[-1], filter[a].fmt);
+	  case 'o':
+	  case 'O':
+	     sp->order= (int)strtol(p, &q, 10);
+	     if (p == q) {
+		if (ch == 'O') goto bad;
+		sp->order= 1;
+	     }
+	     if (sp->order <= 0) 
+		return strdupf("Bad order %d in spec-string \"%s\"", sp->order, sp->spec);
+	     p= q; break;
+	  case 'V':
+	     sp->n_arg++; 
+	     *arg++= strtod(p, &q);
+	     if (p == q) goto bad; 
+	     p= q; break;
+	  case 'F':
+	     sp->minlen= p-1-sp->spec;
+	     sp->n_freq= 1;
+	     sp->adj= (p[0] == '=');
+	     if (sp->adj) p++;
+	     sp->f0= strtod(p, &q);
+	     sp->f1= 0;
+	     if (p == q) goto bad; 
+	     p= q; break;
+	  case 'R':
+	     sp->minlen= p-1-sp->spec;
+	     sp->n_freq= 2;
+	     sp->adj= (p[0] == '=');
+	     if (sp->adj) p++;
+	     sp->f0= strtod(p, &q);
+	     if (p == q) goto bad; 
+	     p= q;
+	     if (*p++ != '-') goto bad;
+	     sp->f1= strtod(p, &q);
+	     if (p == q) goto bad; 
+	     if (sp->f0 > sp->f1) 
+		return strdupf("Backwards frequency range in spec-string \"%s\"", sp->spec);
+	     p= q; break;
+	 }
+      }
+
+      if (p == 0) continue;
+
+      if (fmt[0] == '/' && fmt[1] == '#' && fmt[2] == 'F') {
+	 sp->minlen= p-sp->spec;
+	 sp->n_freq= 1;
+	 if (sp->in_f0 < 0.0) 
+	    return strdupf("Frequency omitted from filter-spec, and no default provided");
+	 sp->f0= sp->in_f0;
+	 sp->f1= 0;
+	 sp->adj= sp->in_adj;
+	 fmt += 3;
+      } else if (fmt[0] == '/' && fmt[1] == '#' && fmt[2] == 'R') {
+	 sp->minlen= p-sp->spec;
+	 sp->n_freq= 2;
+	 if (sp->in_f0 < 0.0 || sp->in_f1 < 0.0)
+	    return strdupf("Frequency omitted from filter-spec, and no default provided");
+	 sp->f0= sp->in_f0;
+	 sp->f1= sp->in_f1;
+	 sp->adj= sp->in_adj;
+	 fmt += 3;
+      }
+
+      // Check for trailing unmatched format characters
+      if (*fmt) {
+      bad:
+	 return strdupf("Bad match of spec-string \"%s\" to format \"%s\"", 
+			sp->spec, filter[a].fmt);
+      }
+      if (sp->n_arg > MAXARG) 
+	 return strdupf("Internal error -- maximum arguments exceeded");
+      
+      // Set the minlen to the whole string if unset
+      if (sp->minlen < 0) sp->minlen= p-sp->spec;
+      
+      // Save values, return
+      sp->fi= a;
+      return 0;
+   }
+   return 0;
+}
+   
+
+//
+//	Parse a filter-spec and freq0/freq1 arguments and rewrite them
+//	to give an all-in-one filter spec and/or a minimum spec plus
+//	separate freq0/freq1 arguments.  The all-in-one spec is
+//	returned in *spec1p (strdup'd), and the minimum separated-out
+//	spec is returned in *spec2p (strdup'd), *freq0p and *freq1p.
+//	If either of spec1p or spec2p is 0, then that particular
+//	spec-string is not generated.
+//
+
+void 
+fid_rewrite_spec(const char *spec, double freq0, double freq1, int adj,
+		 char **spec1p, 
+		 char **spec2p, double *freq0p, double *freq1p, int *adjp) {
+   Spec sp;
+   char *err;
+   sp.spec= spec;
+   sp.in_f0= freq0;
+   sp.in_f1= freq1;
+   sp.in_adj= adj;
+   err= parse_spec(&sp);
+   if (err) error("%s", err);
+
+   if (spec1p) {
+      char buf[128];
+      int len;
+      char *rv;
+      switch (sp.n_freq) {
+       case 1: sprintf(buf, "/%s%.15g", sp.adj ? "=" : "", sp.f0); break;
+       case 2: sprintf(buf, "/%s%.15g-%.15g", sp.adj ? "=" : "", sp.f0, sp.f1); break;
+       default: buf[0]= 0;
+      }
+      len= strlen(buf);
+      rv= (char*)Alloc(sp.minlen + len + 1);
+      memcpy(rv, spec, sp.minlen);
+      strcpy(rv+sp.minlen, buf);
+      *spec1p= rv;
+   }
+
+   if (spec2p) {
+      char *rv= (char*)Alloc(sp.minlen + 1);
+      memcpy(rv, spec, sp.minlen);
+      *spec2p= rv;
+      *freq0p= sp.f0;
+      *freq1p= sp.f1;
+      *adjp= sp.adj;
+   }
+}
+
+//
+//	Create a FidFilter from the given double array.  The double[]
+//	should contain one or more sections, each starting with the
+//	filter type (either 'I' or 'F', as a double), then a count of
+//	the number of coefficients following, then the coefficients
+//	themselves.  The end of the list is marked with a type of 0.
+//
+//	This is really just a convenience function, allowing a filter
+//	to be conveniently dumped to C source code and then
+//	reconstructed.  
+//
+//	Note that for more general filter generation, FidFilter
+//	instances can be created simply by allocating the memory and
+//	filling them in (see fidlib.h).  
+//
+
+FidFilter *
+fid_cv_array(double *arr) {
+   double *dp;
+   FidFilter *ff, *rv;
+   int n_head= 0;
+   int n_val= 0;
+
+   // Scan through for sizes
+   for (dp= arr; *dp; ) {
+      int len, typ;
+
+      typ= (int)(*dp++);
+      if (typ != 'F' && typ != 'I') 
+	 error("Bad type in array passed to fid_cv_array: %g", dp[-1]);
+
+      len= (int)(*dp++);
+      if (len < 1)
+	 error("Bad length in array passed to fid_cv_array: %g", dp[-1]);
+
+      n_head++;
+      n_val += len;
+      dp += len;
+   }
+
+   rv= ff= (FidFilter*)Alloc(FFCSIZE(n_head, n_val));
+
+   // Scan through to fill in FidFilter
+   for (dp= arr; *dp; ) {
+      int len, typ;
+      typ= (int)(*dp++);
+      len= (int)(*dp++);
+
+      ff->typ= typ;
+      ff->cbm= ~0;
+      ff->len= len;
+      memcpy(ff->val, dp, len * sizeof(double));
+      dp += len;
+      ff= FFNEXT(ff);
+   }
+
+   // Final element already zero'd thanks to allocation
+
+   return rv;
+}
+
+//
+//	Create a single filter from the given list of filters in
+//	order.  If 'freeme' is set, then all the listed filters are
+//	free'd once read; otherwise they are left untouched.  The
+//	newly allocated resultant filter is returned, which should be
+//	released with free() when finished with.
+//      
+
+FidFilter *
+fid_cat(int freeme, ...) {
+   va_list ap;
+   FidFilter *rv, *ff, *ff0;
+   int len= 0;
+   int cnt;
+   char *dst;
+
+   // Find the memory required to store the combined filter
+   va_start(ap, freeme);
+   while ((ff0= va_arg(ap, FidFilter*))) {
+      for (ff= ff0; ff->typ; ff= FFNEXT(ff))
+	 ;
+      len += ((char*)ff) - ((char*)ff0);
+   }
+   va_end(ap);
+
+   rv= (FidFilter*)Alloc(FFCSIZE(0,0) + len);
+   dst= (char*)rv;
+
+   va_start(ap, freeme);
+   while ((ff0= va_arg(ap, FidFilter*))) {
+      for (ff= ff0; ff->typ; ff= FFNEXT(ff))
+	 ;
+      cnt= ((char*)ff) - ((char*)ff0);
+      memcpy(dst, ff0, cnt);
+      dst += cnt;
+      if (freeme) free(ff0);
+   }
+   va_end(ap);
+
+   // Final element already zero'd
+   return rv;
+}
+
+//
+//	Support for fid_parse
+//
+
+// Skip white space (including comments)
+static void 
+skipWS(char **pp) {
+   char *p= *pp;
+
+   while (*p) {
+      if (isspace(*p)) { p++; continue; }
+      if (*p == '#') {
+         while (*p && *p != '\n') p++;
+         continue;
+      }
+      break;
+   }
+   *pp= p;
+}
+
+// Grab a word from the input into the given buffer.  Returns 0: end
+// of file or error, else 1: success.  Error is indicated when the
+// word doesn't fit in the buffer.
+static int 
+grabWord(char **pp, char *buf, int buflen) {
+   char *p, *q;
+   int len; 
+   
+   skipWS(pp);
+   p= *pp;
+   if (!*p) return 0;
+
+   q= p;
+   if (*q == ',' || *q == ';' || *q == ')' || *q == ']' || *q == '}') {
+      q++;
+   } else {
+      while (*q && *q != '#' && !isspace(*q) && 
+	     (*q != ',' && *q != ';' && *q != ')' && *q != ']' && *q != '}'))
+	 q++;
+   }
+   len= q-p;
+   if (len >= buflen) return 0;
+   
+   memcpy(buf, p, len);
+   buf[len]= 0;
+   
+   *pp= q;
+   return 1;
+}
+
+//
+//	Parse an entire filter specification, perhaps consisting of
+//	several FIR, IIR and predefined filters.  Stops at the first
+//	,; or unmatched )]}.  Returns either 0 on success, or else a
+//	strdup'd error string.
+//
+//	This duplicates code from Fiview filter.c, I know, but this
+//	may have to expand in the future to handle '+' operations, and
+//	special filter types like tunable heterodyne filters.  At that
+//	point, the filter.c code will have to be modified to call a
+//	version of this routine.
+//
+
+char *
+fid_parse(double rate, char **pp, FidFilter **ffp) {
+   char buf[128];
+   char *p= *pp, *rew;
+#define INIT_LEN 128
+   char *rv= (char*)Alloc(INIT_LEN);
+   char *rvend= rv + INIT_LEN;
+   char *rvp= rv;
+   char *tmp;
+#undef INIT_LEN
+   FidFilter *curr;
+   int xtra= FFCSIZE(0,0);
+   int typ= -1;		// First time through
+   double val;
+   char dmy;
+
+#define ERR(ptr, msg) { *pp= ptr; *ffp= 0; return msg; }
+#define INCBUF { tmp= (char*)realloc(rv, (rvend-rv) * 2); if (!tmp) error("Out of memory"); \
+ rvend= (rvend-rv) * 2 + tmp; rvp= (rvp-rv) + tmp; \
+ curr= (FidFilter*)(((char*)curr) - rv + tmp); rv= tmp; }
+   
+   while (1) {
+      rew= p;
+      if (!grabWord(&p, buf, sizeof(buf))) {
+	 if (*p) ERR(p, strdupf("Filter element unexpectedly long -- syntax error?"));
+	 buf[0]= 0;
+      }
+      if (!buf[0] || !buf[1]) switch (buf[0]) {
+       default:
+	  break;
+       case 0:
+       case ',':
+       case ';':
+       case ')':
+       case ']':
+       case '}':
+	  // End of filter, return it
+	  tmp= (char*)realloc(rv, (rvp-rv) + xtra);
+	  if (!tmp) error("Out of memory");
+	  curr= (FidFilter*)((rvp-rv) + tmp);
+	  curr->typ= 0; curr->cbm= 0; curr->len= 0;
+	  *pp= buf[0] ? (p-1) : p;
+	  *ffp= (FidFilter*)tmp;
+	  return 0;
+       case '/':
+	  if (typ > 0) ERR(rew, strdupf("Filter syntax error; unexpected '/'"));
+	  typ= 'I';
+	  continue;
+       case 'x':
+	  if (typ > 0) ERR(rew, strdupf("Filter syntax error; unexpected 'x'"));
+	  typ= 'F';
+	  continue;
+      }
+
+      if (typ < 0) typ= 'F';		// Assume 'x' if missing
+      if (!typ) ERR(p, strdupf("Expecting a 'x' or '/' before this"));
+
+      if (1 != sscanf(buf, "%lf %c", &val, &dmy)) {
+	 // Must be a predefined filter
+	 FidFilter *ff;
+	 FidFilter *ff1;
+	 Spec sp;
+	 double f0, f1;
+	 char *err;
+	 int len;
+
+	 if (typ != 'F') ERR(rew, strdupf("Predefined filters cannot be used with '/'"));
+
+	 // Parse the filter-spec
+	 memset(&sp, 0, sizeof(sp));
+	 sp.spec= buf;
+	 sp.in_f0= sp.in_f1= -1;
+	 if ((err= parse_spec(&sp))) ERR(rew, err);
+	 f0= sp.f0;
+	 f1= sp.f1;
+	 
+	 // Adjust frequencies to range 0-0.5, and check them
+	 f0 /= rate;
+	 if (f0 > 0.5) ERR(rew, strdupf("Frequency of %gHz out of range with "
+					"sampling rate of %gHz", f0*rate, rate));
+	 f1 /= rate;
+	 if (f1 > 0.5) ERR(rew, strdupf("Frequency of %gHz out of range with "
+					"sampling rate of %gHz", f1*rate, rate));
+	 
+	 // Okay we now have a successful spec-match to filter[sp.fi], and sp.n_arg
+	 // args are now in sp.argarr[]
+	 
+	 // Generate the filter
+	 if (!sp.adj)
+	    ff= filter[sp.fi].rout(rate, f0, f1, sp.order, sp.n_arg, sp.argarr);
+	 else if (strstr(filter[sp.fi].fmt, "#R"))
+	    ff= auto_adjust_dual(&sp, rate, f0, f1);
+	 else 
+	    ff= auto_adjust_single(&sp, rate, f0);
+
+	 // Append it to our FidFilter to return
+	 for (ff1= ff; ff1->typ; ff1= FFNEXT(ff1)) ;
+	 len= ((char*)ff1-(char*)ff);
+	 while (rvp + len + xtra >= rvend) INCBUF;
+	 memcpy(rvp, ff, len); rvp += len;
+	 free(ff);
+	 typ= 0;
+	 continue;
+      }
+
+      // Must be a list of coefficients
+      curr= (FidFilter*)rvp;
+      rvp += xtra;
+      while (rvp + sizeof(double) >= rvend) INCBUF;
+      curr->typ= typ;
+      curr->cbm= ~0;
+      curr->len= 1;
+      *(double*)rvp= val;
+      rvp += sizeof(double);
+
+      // See how many more coefficients we can pick up
+      while (1) {
+	 rew= p;
+	 if (!grabWord(&p, buf, sizeof(buf))) {
+	    if (*p) ERR(p, strdupf("Filter element unexpectedly long -- syntax error?"));
+	    buf[0]= 0;
+	 }
+	 if (1 != sscanf(buf, "%lf %c", &val, &dmy)) {
+	    p= rew;
+	    break;
+	 }
+	 while (rvp + sizeof(double) >= rvend) INCBUF;
+	 curr->len++;
+	 *(double*)rvp= val;
+	 rvp += sizeof(double);
+      }
+      typ= 0;
+      continue;
+   }
+
+#undef INCBUF
+#undef ERR
+
+   return strdupf("Internal error, shouldn't reach here");
+}
+
+
+//
+//	Filter-running code
+//
+
+#ifdef RF_COMBINED
+#include "fidrf_combined.h"
+#endif
+
+#ifdef RF_CMDLIST
+#include "fidrf_cmdlist.h"
+#endif
+
+#ifdef RF_JIT
+#include "fidrf_jit.h"
+#endif
+
+
+// END //

=== added file 'mixxx/lib/fidlib-0.9.10/fidlib.h'
--- mixxx/lib/fidlib-0.9.10/fidlib.h	1970-01-01 00:00:00 +0000
+++ mixxx/lib/fidlib-0.9.10/fidlib.h	2011-07-25 04:35:51 +0000
@@ -0,0 +1,77 @@
+//
+//	fidlib include file
+//
+#ifndef FIDLIB_H
+#define FIDLIB_H
+typedef struct FidFilter FidFilter;
+struct FidFilter {
+   short typ;		// Type of filter element 'I' IIR, 'F' FIR, or 0 for end of list
+   short cbm;		// Constant bitmap.  Bits 0..14, if set, indicate that val[0..14]
+   			//   is a constant across changes in frequency for this filter type
+   			//   Bit 15, if set, indicates that val[15..inf] are constant.
+   int len;		// Number of doubles stored in val[], or 0 for end of list
+   double val[1];
+};
+
+// Lets you write: for (; ff->typ; ff= FFNEXT(ff)) { ... }
+#define FFNEXT(ff) ((FidFilter*)((ff)->val + (ff)->len))
+
+// Size of a sub-filter with 'cnt' double values attached
+#define FFSIZE(cnt) (sizeof(FidFilter) + ((cnt)-1)*sizeof(double))
+
+// Size required for the memory chunk to contain the given number
+// headers and values, plus termination
+#define FFCSIZE(n_head,n_val) ((sizeof(FidFilter)-sizeof(double))*((n_head)+1) + sizeof(double)*(n_val))
+
+// Allocate the chunk of memory to hold a list of FidFilters, with
+// n_head FidFilters and n_val total double values in the whole list.
+// Includes space for the final termination, and zeros the memory.
+#define FFALLOC(n_head,n_val) (FidFilter*)Alloc(FFCSIZE(n_head, n_val))
+
+// These are so you can use easier names to refer to running filters
+typedef void FidRun;
+typedef double (FidFunc)(void*, double);
+
+
+//
+//	Prototypes
+//
+#ifdef MIXXX
+extern "C" {
+#endif
+
+extern void fid_set_error_handler(void(*rout)(char *));
+extern char *fid_version();
+extern double fid_response_pha(FidFilter *filt, double freq, double *phase);
+extern double fid_response(FidFilter *filt, double freq);
+extern int fid_calc_delay(FidFilter *filt);
+extern FidFilter *fid_design(const char *spec, double rate, double freq0, double freq1, 
+			     int f_adj, char **descp);
+extern double fid_design_coef(double *coef, int n_coef, const char *spec, 
+			      double rate, double freq0, double freq1, int adj);
+extern void fid_list_filters(FILE *out);
+extern int fid_list_filters_buf(char *buf, char *bufend);
+extern FidFilter *fid_flatten(FidFilter *filt);
+extern void fid_rewrite_spec(const char *spec, double freq0, double freq1, int adj, 
+			     char **spec1p, char **spec2p, 
+			     double *freq0p, double *freq1p, int *adjp);
+extern FidFilter *fid_cv_array(double *arr);
+extern FidFilter *fid_cat(int freeme, ...);
+extern char *fid_parse(double rate, char **pp, FidFilter **ffp);
+
+//
+//	Filter running prototypes
+//
+
+extern void *fid_run_new(FidFilter *filt, double(**funcpp)(void *, double));
+extern void *fid_run_newbuf(void *run);
+extern int fid_run_bufsize(void *run);
+extern void fid_run_initbuf(void *run, void *buf);
+extern void fid_run_zapbuf(void *buf);
+extern void fid_run_freebuf(void *runbuf);
+extern void fid_run_free(void *run);
+
+#ifdef MIXXX
+}
+#endif
+#endif

=== added file 'mixxx/lib/fidlib-0.9.10/fidmkf.h'
--- mixxx/lib/fidlib-0.9.10/fidmkf.h	1970-01-01 00:00:00 +0000
+++ mixxx/lib/fidlib-0.9.10/fidmkf.h	2011-07-25 04:35:51 +0000
@@ -0,0 +1,846 @@
+//
+//      mkfilter-derived code
+//      ---------------------
+//
+//        Copyright (c) 2002-2004 Jim Peters <http://uazu.net/>.  This
+//        file is released under the GNU Lesser General Public License
+//        (LGPL) version 2.1 as published by the Free Software
+//        Foundation.  See the file COPYING_LIB for details, or visit
+//        <http://www.fsf.org/licenses/licenses.html>.
+//
+//	This is all code derived from 'mkfilter' by Tony Fisher of the
+//	University of York.  I've rewritten it all in C, and given it
+//	a thorough overhaul, so there is actually none of his code
+//	here any more, but it is all still very strongly based on the
+//	algorithms and techniques that he used in 'mkfilter'.
+//
+//	For those who didn't hear, Tony Fisher died in February 2000
+//	at the age of 43.  See his web-site for information and a
+//	tribute:
+//
+//        http://www-users.cs.york.ac.uk/~fisher/
+//        http://www-users.cs.york.ac.uk/~fisher/tribute.html
+//
+//      The original C++ sources and the rest of the mkfilter tool-set
+//      are still available from his site:
+//
+//        http://www-users.cs.york.ac.uk/~fisher/mkfilter/
+//
+//	
+//	I've made a number of improvements and changes whilst
+//	rewriting the code in C.  For example, I halved the
+//	calculations required in designing the filters by storing only
+//	one complex pole/zero out of each conjugate pair.  This also
+//	made it much easier to output the filter as a list of
+//	sub-filters without lots of searching around to match up
+//	conjugate pairs later on.  Outputting as a list of subfilters
+//	permits greater accuracy in calculation of the response, and
+//	also in the execution of the final filter.  Also, some FIR
+//	coefficients can be marked as 'constant', allowing optimised
+//	routines to be generated for whole classes of filters, with
+//	just the variable coefficients filled in at run-time.
+//
+//	On the down-side, complex numbers are not portably available
+//	in C before C99, so complex calculations here are done on
+//	double[] arrays with inline functions, which ends up looking
+//	more like assembly language than C.  Never mind.
+//
+
+//
+//	LEGAL STUFF
+//	-----------
+//
+//	Tony Fisher released his software on his University of York
+//	pages for free use and free download.  The software itself has
+//	no licence terms attached, nor copyright messages, just the
+//	author's name, E-mail address and date.  Nor are there any
+//	licence terms indicated on the website.  I understand that
+//	under the Berne convention copyright does not have to be
+//	claimed explicitly, so these are in fact copyright files by
+//	legal default.  However, the intention was obviously that
+//	these files should be used by others.
+//
+//	None of this really helps, though, if we're going to try to be
+//	100% legally correct, so I wrote to Anthony Moulds who is the
+//	contact name on Tony Fisher's pages now.  I explained what I
+//	planned to do with the code, and he answered as follows:
+//
+//	(Note that I was planning to use it 'as-is' at that time,
+//	rather than rewrite it as I have done now)
+//
+//      > To: "Jim Peters" <[e-mail]>
+//      > From: "Anthony Moulds" <[e-mail]>
+//      > Subject: RE: mkfilter source
+//      > Date: Tue, 29 Oct 2002 15:30:19 -0000
+//      > 
+//      > Hi Jim,
+//      > 
+//      > Thanks for your email.
+//      > 
+//      > The University will be happy to let you use Dr Fisher's mkfilter
+//      > code since your intention is not to profit financially from his work.
+//      > 
+//      > It would be nice if in some way you could acknowledge his contribution.
+//      > 
+//      > Best wishes and good luck with your work,
+//      > 
+//      > Anthony Moulds
+//      > Senior Experimental Officer, 
+//      > Computer Science Department,  University of York,
+//      > York, England, UK. Tel: [phone]  Fax: [phone]
+//      > ============================================================
+//      > 
+//      > 
+//      > > -----Original Message-----
+//      > > From: Jim Peters [mailto:[e-mail]]
+//      > > Sent: Monday, October 28, 2002 12:36 PM
+//      > > To: [e-mail]
+//      > > Subject: mkfilter source
+//      > > 
+//      > > 
+//      > > I'm very sorry to hear (rather late, I know) that Tony Fisher died --
+//      > > I've always gone straight to the filter page, rather than through his
+//      > > home page.  I hope his work remains available for the future.
+//      > > 
+//      > > Anyway, the reason I'm writing is to clarify the status of the
+//      > > mkfilter source code.  Because copyright is not claimed on the web
+//      > > page nor in the source distribution, I guess that Tony's intention was
+//      > > that this code should be in the public domain.  However, I would like
+//      > > to check this now to avoid complications later.
+//      > > 
+//      > > I am using his code, modified, to provide a library of filter-design
+//      > > routines for a GPL'd filter design app, which is not yet released.
+//      > > The library could also be used standalone, permitting apps to design
+//      > > filters at run-time rather than using hard-coded compile-time filters.
+//      > > My interest in filters is as a part of my work on the OpenEEG project
+//
+//	So this looks pretty clear to me.  I am not planning to profit
+//	from the work, so everything is fine with the University.  I
+//	guess others might profit from the work, indirectly, as with
+//	any free software release, but so long as I don't, we're fine.
+//
+//	I hope this is watertight enough for Debian/etc.  Otherwise
+//	I'll have to go back to Anthony Moulds for clarification.
+//
+//	Even though there is no code cut-and-pasted from 'mkfilter'
+//	here, it is all very obviously based on that code, so it
+//	probably counts as a derived work -- although as ever "I Am
+//	Not A Lawyer".
+//
+
+#ifndef FIDMK_H
+#define FIDMK_H
+
+#ifndef T_MSVC
+ #ifdef HUGE_VAL
+  #define INF HUGE_VAL
+ #else
+  #define INF (1.0/0.0)
+ #endif
+#endif
+
+//Hacks for crappy linker error in MSVC... - Albert
+#ifdef T_MSVC
+ #undef HUGE_VAL
+ #define HUGE_VAL 1.797693134862315E+308
+ #define INF HUGE_VAL
+#endif
+
+#define TWOPI (2*M_PI)
+
+
+//
+//	Complex square root: aa= aa^0.5
+//
+
+STATIC_INLINE double
+my_sqrt(double aa) {
+   return aa <= 0.0 ? 0.0 : sqrt(aa);
+}
+
+// 'csqrt' clashes with builtin in GCC 4, so call it 'c_sqrt'
+STATIC_INLINE void 
+c_sqrt(double *aa) {
+   double mag= hypot(aa[0], aa[1]);
+   double rr= my_sqrt((mag + aa[0]) * 0.5);
+   double ii= my_sqrt((mag - aa[0]) * 0.5);
+   if (aa[1] < 0.0) ii= -ii;
+   aa[0]= rr;
+   aa[1]= ii;
+}
+
+//
+//	Complex imaginary exponent: aa= e^i.theta
+//
+
+STATIC_INLINE void 
+cexpj(double *aa, double theta) {
+   aa[0]= cos(theta);
+   aa[1]= sin(theta);
+}
+
+//
+//	Complex exponent: aa= e^aa
+//
+
+// 'cexp' clashes with builtin in GCC 4, so call it 'c_exp'
+STATIC_INLINE void 
+c_exp(double *aa) {
+   double mag= exp(aa[0]);
+   aa[0]= mag * cos(aa[1]);
+   aa[1]= mag * sin(aa[1]);
+}
+
+//
+//	Global temp buffer for generating filters.  *NOT THREAD SAFE*
+//
+//	Note that the poles and zeros are stored in a strange way.
+//	Rather than storing both a pole (or zero) and its complex
+//	conjugate, I'm storing just one of the pair.  Also, for real
+//	poles, I'm not storing the imaginary part (which is zero).
+//	This results in a list of numbers exactly half the length you
+//	might otherwise expect.  However, since some of these numbers
+//	are in pairs, and some are single, we need a separate flag
+//	array to indicate which is which.  poltyp[] serves this
+//	purpose.  An entry is 1 if the corresponding offset is a real
+//	pole, or 2 if it is the first of a pair of values making up a
+//	complex pole.  The second value of the pair has an entry of 0
+//	attached.  (Similarly for zeros in zertyp[])
+//
+
+#define MAXPZ 64 
+
+static int n_pol;		// Number of poles
+static double pol[MAXPZ];	// Pole values (see above)
+static char poltyp[MAXPZ];	// Pole value types: 1 real, 2 first of complex pair, 0 second
+static int n_zer;		// Same for zeros ...
+static double zer[MAXPZ];
+static char zertyp[MAXPZ];	
+
+
+//
+//	Pre-warp a frequency
+//
+
+STATIC_INLINE double 
+prewarp(double val) {
+   return tan(val * M_PI) / M_PI;
+}
+
+
+//
+//	Bessel poles; final one is a real value for odd numbers of
+//	poles
+//
+
+static double bessel_1[]= {
+ -1.00000000000e+00
+};
+
+static double bessel_2[]= {
+ -1.10160133059e+00, 6.36009824757e-01,
+};
+
+static double bessel_3[]= {
+ -1.04740916101e+00, 9.99264436281e-01,
+ -1.32267579991e+00,
+};
+
+static double bessel_4[]= {
+ -9.95208764350e-01, 1.25710573945e+00,
+ -1.37006783055e+00, 4.10249717494e-01,
+};
+
+static double bessel_5[]= {
+ -9.57676548563e-01, 1.47112432073e+00,
+ -1.38087732586e+00, 7.17909587627e-01,
+ -1.50231627145e+00,
+};
+
+static double bessel_6[]= {
+ -9.30656522947e-01, 1.66186326894e+00,
+ -1.38185809760e+00, 9.71471890712e-01,
+ -1.57149040362e+00, 3.20896374221e-01,
+};
+
+static double bessel_7[]= {
+ -9.09867780623e-01, 1.83645135304e+00,
+ -1.37890321680e+00, 1.19156677780e+00,
+ -1.61203876622e+00, 5.89244506931e-01,
+ -1.68436817927e+00,
+};
+
+static double bessel_8[]= {
+ -8.92869718847e-01, 1.99832584364e+00,
+ -1.37384121764e+00, 1.38835657588e+00,
+ -1.63693941813e+00, 8.22795625139e-01,
+ -1.75740840040e+00, 2.72867575103e-01,
+};
+
+static double bessel_9[]= {
+ -8.78399276161e-01, 2.14980052431e+00,
+ -1.36758830979e+00, 1.56773371224e+00,
+ -1.65239648458e+00, 1.03138956698e+00,
+ -1.80717053496e+00, 5.12383730575e-01,
+ -1.85660050123e+00,
+};
+
+static double bessel_10[]= {
+ -8.65756901707e-01, 2.29260483098e+00,
+ -1.36069227838e+00, 1.73350574267e+00,
+ -1.66181024140e+00, 1.22110021857e+00,
+ -1.84219624443e+00, 7.27257597722e-01,
+ -1.92761969145e+00, 2.41623471082e-01,
+};
+
+static double *bessel_poles[10]= {
+   bessel_1, bessel_2, bessel_3, bessel_4, bessel_5,
+   bessel_6, bessel_7, bessel_8, bessel_9, bessel_10
+};
+
+//
+//	Generate Bessel poles for the given order.
+//
+
+static void 
+bessel(int order) {
+   int a;
+
+   if (order > 10) error("Maximum Bessel order is 10");
+   n_pol= order;
+   memcpy(pol, bessel_poles[order-1], n_pol * sizeof(double));
+
+   for (a= 0; a<order-1; ) {
+      poltyp[a++]= 2;
+      poltyp[a++]= 0;
+   }
+   if (a < order) 
+      poltyp[a++]= 1;
+}
+
+//
+//	Generate Butterworth poles for the given order.  These are
+//	regularly-spaced points on the unit circle to the left of the
+//	real==0 line.
+//
+
+static void 
+butterworth(int order) {
+   int a;
+   if (order > MAXPZ) 
+      error("Maximum butterworth/chebyshev order is %d", MAXPZ);
+   n_pol= order;
+   for (a= 0; a<order-1; a += 2) {
+      poltyp[a]= 2;
+      poltyp[a+1]= 0;
+      cexpj(pol+a, M_PI - (order-a-1) * 0.5 * M_PI / order);
+   }
+   if (a < order) {
+      poltyp[a]= 1;
+      pol[a]= -1.0;
+   }
+}
+
+//
+//	Generate Chebyshev poles for the given order and ripple.
+//
+
+static void 
+chebyshev(int order, double ripple) {
+   double eps, y;
+   double sh, ch;
+   int a;
+
+   butterworth(order);
+   if (ripple >= 0.0) error("Chebyshev ripple in dB should be -ve");
+
+   eps= sqrt(-1.0 + pow(10.0, -0.1 * ripple));
+   y= asinh(1.0 / eps) / order;
+   if (y <= 0.0) error("Internal error; chebyshev y-value <= 0.0: %g", y);
+   sh= sinh(y);
+   ch= cosh(y);
+
+   for (a= 0; a<n_pol; ) {
+      if (poltyp[a] == 1)
+	 pol[a++] *= sh;
+      else {
+	 pol[a++] *= sh;
+	 pol[a++] *= ch;
+      }
+   }
+}
+
+
+//
+//	Adjust raw poles to LP filter
+//
+
+static void 
+lowpass(double freq) {
+   int a;
+
+   // Adjust poles
+   freq *= TWOPI;
+   for (a= 0; a<n_pol; a++)
+      pol[a] *= freq;
+
+   // Add zeros
+   n_zer= n_pol;
+   for (a= 0; a<n_zer; a++) {
+      zer[a]= -INF;
+      zertyp[a]= 1;
+   }
+}
+
+//
+//	Adjust raw poles to HP filter
+//
+
+static void 
+highpass(double freq) {
+   int a;
+
+   // Adjust poles
+   freq *= TWOPI;
+   for (a= 0; a<n_pol; ) {
+      if (poltyp[a] == 1) {
+	 pol[a]= freq / pol[a];
+	 a++;
+      } else {
+	 crecip(pol + a);
+	 pol[a++] *= freq;
+	 pol[a++] *= freq;
+      }
+   }
+
+   // Add zeros
+   n_zer= n_pol;
+   for (a= 0; a<n_zer; a++) {
+      zer[a]= 0.0;
+      zertyp[a]= 1;
+   }
+}
+
+//
+//	Adjust raw poles to BP filter.  The number of poles is
+//	doubled.
+//
+
+static void 
+bandpass(double freq1, double freq2) {
+   double w0= TWOPI * sqrt(freq1*freq2);
+   double bw= 0.5 * TWOPI * (freq2-freq1);
+   int a, b;
+
+   if (n_pol * 2 > MAXPZ) 
+      error("Maximum order for bandpass filters is %d", MAXPZ/2);
+   
+   // Run through the list backwards, expanding as we go
+   for (a= n_pol, b= n_pol*2; a>0; ) {
+      // hba= pole * bw;
+      // temp= c_sqrt(1.0 - square(w0 / hba));
+      // pole1= hba * (1.0 + temp);
+      // pole2= hba * (1.0 - temp);
+
+      if (poltyp[a-1] == 1) {
+	 double hba;
+	 a--; b -= 2;
+	 poltyp[b]= 2; poltyp[b+1]= 0;
+	 hba= pol[a] * bw;
+	 cassz(pol+b, 1.0 - (w0 / hba) * (w0 / hba), 0.0);
+	 c_sqrt(pol+b);
+	 caddz(pol+b, 1.0, 0.0);
+	 cmulr(pol+b, hba);
+      } else {		// Assume poltyp[] data is valid
+	 double hba[2];
+	 a -= 2; b -= 4;
+	 poltyp[b]= 2; poltyp[b+1]= 0;
+	 poltyp[b+2]= 2; poltyp[b+3]= 0;
+	 cass(hba, pol+a);
+	 cmulr(hba, bw);
+	 cass(pol+b, hba);
+	 crecip(pol+b);
+	 cmulr(pol+b, w0);
+	 csqu(pol+b);
+	 cneg(pol+b);
+	 caddz(pol+b, 1.0, 0.0);
+	 c_sqrt(pol+b);
+	 cmul(pol+b, hba);
+	 cass(pol+b+2, pol+b);
+	 cneg(pol+b+2);
+	 cadd(pol+b, hba);
+	 cadd(pol+b+2, hba);
+      } 
+   }
+   n_pol *= 2;
+   
+   // Add zeros
+   n_zer= n_pol; 
+   for (a= 0; a<n_zer; a++) {
+      zertyp[a]= 1;
+      zer[a]= (a<n_zer/2) ? 0.0 : -INF;
+   }
+}
+
+//
+//	Adjust raw poles to BS filter.  The number of poles is
+//	doubled.
+//
+
+static void 
+bandstop(double freq1, double freq2) {
+   double w0= TWOPI * sqrt(freq1*freq2);
+   double bw= 0.5 * TWOPI * (freq2-freq1);
+   int a, b;
+
+   if (n_pol * 2 > MAXPZ) 
+      error("Maximum order for bandstop filters is %d", MAXPZ/2);
+
+   // Run through the list backwards, expanding as we go
+   for (a= n_pol, b= n_pol*2; a>0; ) {
+      // hba= bw / pole;
+      // temp= c_sqrt(1.0 - square(w0 / hba));
+      // pole1= hba * (1.0 + temp);
+      // pole2= hba * (1.0 - temp);
+
+      if (poltyp[a-1] == 1) {
+	 double hba;
+	 a--; b -= 2;
+	 poltyp[b]= 2; poltyp[b+1]= 0;
+	 hba= bw / pol[a];
+	 cassz(pol+b, 1.0 - (w0 / hba) * (w0 / hba), 0.0);
+	 c_sqrt(pol+b);
+	 caddz(pol+b, 1.0, 0.0);
+	 cmulr(pol+b, hba);
+      } else {		// Assume poltyp[] data is valid
+	 double hba[2];
+	 a -= 2; b -= 4;
+	 poltyp[b]= 2; poltyp[b+1]= 0;
+	 poltyp[b+2]= 2; poltyp[b+3]= 0;
+	 cass(hba, pol+a);
+	 crecip(hba);
+	 cmulr(hba, bw);
+	 cass(pol+b, hba);
+	 crecip(pol+b);
+	 cmulr(pol+b, w0);
+	 csqu(pol+b);
+	 cneg(pol+b);
+	 caddz(pol+b, 1.0, 0.0);
+	 c_sqrt(pol+b);
+	 cmul(pol+b, hba);
+	 cass(pol+b+2, pol+b);
+	 cneg(pol+b+2);
+	 cadd(pol+b, hba);
+	 cadd(pol+b+2, hba);
+      } 
+   }
+   n_pol *= 2;
+   
+   // Add zeros
+   n_zer= n_pol; 
+   for (a= 0; a<n_zer; a+=2) {
+      zertyp[a]= 2; zertyp[a+1]= 0;
+      zer[a]= 0.0; zer[a+1]= w0;
+   }
+}
+
+//
+//	Convert list of poles+zeros from S to Z using bilinear
+//	transform
+//
+
+static void 
+s2z_bilinear() {
+   int a;
+   for (a= 0; a<n_pol; ) {
+      // Calculate (2 + val) / (2 - val)
+      if (poltyp[a] == 1) {
+	 if (pol[a] == -INF) 
+	    pol[a]= -1.0;
+	 else 
+	    pol[a]= (2 + pol[a]) / (2 - pol[a]);
+	 a++;
+      } else {
+	 double val[2];
+	 cass(val, pol+a);
+	 cneg(val);
+	 caddz(val, 2, 0);
+	 caddz(pol+a, 2, 0);
+	 cdiv(pol+a, val);
+	 a += 2;
+      }
+   }
+   for (a= 0; a<n_zer; ) {
+      // Calculate (2 + val) / (2 - val)
+      if (zertyp[a] == 1) {
+	 if (zer[a] == -INF) 
+	    zer[a]= -1.0;
+	 else 
+	    zer[a]= (2 + zer[a]) / (2 - zer[a]);
+	 a++;
+      } else {
+	 double val[2];
+	 cass(val, zer+a);
+	 cneg(val);
+	 caddz(val, 2, 0);
+	 caddz(zer+a, 2, 0);
+	 cdiv(zer+a, val);
+	 a += 2;
+      }
+   }
+}
+
+//
+//	Convert S to Z using matched-Z transform
+//
+    
+static void 
+s2z_matchedZ() {
+   int a;
+   
+   for (a= 0; a<n_pol; ) {
+      // Calculate cexp(val)
+      if (poltyp[a] == 1) {
+	 if (pol[a] == -INF) 
+	    pol[a]= 0.0;
+	 else 
+	    pol[a]= exp(pol[a]);
+	 a++;
+      } else {
+	 c_exp(pol+a);
+	 a += 2;
+      }
+   }
+
+   for (a= 0; a<n_zer; ) {
+      // Calculate cexp(val)
+      if (zertyp[a] == 1) {
+	 if (zer[a] == -INF) 
+	    zer[a]= 0.0;
+	 else 
+	    zer[a]= exp(zer[a]);
+	 a++;
+      } else {
+	 c_exp(zer+a);
+	 a += 2;
+      }
+   }
+}
+
+//
+//	Generate a FidFilter for the current set of poles and zeros.
+//	The given gain is inserted at the start of the FidFilter as a
+//	one-coefficient FIR filter.  This is positioned to be easily
+//	adjusted later to correct the filter gain.
+//
+//	'cbm' should be a bitmap indicating which FIR coefficients are
+//	constants for this filter type.  Normal values are ~0 for all
+//	constant, or 0 for none constant, or some other bitmask for a
+//	mixture.  Filters generated with lowpass(), highpass() and
+//	bandpass() above should pass ~0, but bandstop() requires 0x5.
+//
+//	This routine requires that any lone real poles/zeros are at
+//	the end of the list.  All other poles/zeros are handled in
+//	pairs (whether pairs of real poles/zeros, or conjugate pairs).
+//
+
+static FidFilter*
+z2fidfilter(double gain, int cbm) {
+   int n_head, n_val;
+   int a;
+   FidFilter *rv;
+   FidFilter *ff;
+
+   n_head= 1 + n_pol + n_zer;	 // Worst case: gain + 2-element IIR/FIR
+   n_val= 1 + 2 * (n_pol+n_zer); //   for each pole/zero
+
+   rv= ff= FFALLOC(n_head, n_val);
+
+   ff->typ= 'F';
+   ff->len= 1;
+   ff->val[0]= gain;
+   ff= FFNEXT(ff);
+
+   // Output as much as possible as 2x2 IIR/FIR filters
+   for (a= 0; a <= n_pol-2 && a <= n_zer-2; a += 2) {
+      // Look for a pair of values for an IIR
+      if (poltyp[a] == 1 && poltyp[a+1] == 1) {
+	 // Two real values
+         ff->typ= 'I';
+         ff->len= 3;
+         ff->val[0]= 1;
+         ff->val[1]= -(pol[a] + pol[a+1]);
+         ff->val[2]= pol[a] * pol[a+1];
+	 ff= FFNEXT(ff); 
+      } else if (poltyp[a] == 2) {
+	 // A complex value and its conjugate pair
+         ff->typ= 'I';
+         ff->len= 3;
+         ff->val[0]= 1;
+         ff->val[1]= -2 * pol[a];
+         ff->val[2]= pol[a] * pol[a] + pol[a+1] * pol[a+1];
+	 ff= FFNEXT(ff); 
+      } else error("Internal error -- bad poltyp[] values for z2fidfilter()");	 
+
+      // Look for a pair of values for an FIR
+      if (zertyp[a] == 1 && zertyp[a+1] == 1) {
+	 // Two real values
+	 // Skip if constant and 0/0
+	 if (!cbm || zer[a] != 0.0 || zer[a+1] != 0.0) {
+	    ff->typ= 'F';
+	    ff->cbm= cbm;
+	    ff->len= 3;
+	    ff->val[0]= 1;
+	    ff->val[1]= -(zer[a] + zer[a+1]);
+	    ff->val[2]= zer[a] * zer[a+1];
+	    ff= FFNEXT(ff); 
+	 }
+      } else if (zertyp[a] == 2) {
+	 // A complex value and its conjugate pair
+	 // Skip if constant and 0/0
+	 if (!cbm || zer[a] != 0.0 || zer[a+1] != 0.0) {
+	    ff->typ= 'F';
+	    ff->cbm= cbm;
+	    ff->len= 3;
+	    ff->val[0]= 1;
+	    ff->val[1]= -2 * zer[a];
+	    ff->val[2]= zer[a] * zer[a] + zer[a+1] * zer[a+1];
+	    ff= FFNEXT(ff); 
+	 }
+      } else error("Internal error -- bad zertyp[] values");	 
+   }
+
+   // Clear up any remaining bits and pieces.  Should only be a 1x1
+   // IIR/FIR.
+   if (n_pol-a == 0 && n_zer-a == 0) 
+      ;
+   else if (n_pol-a == 1 && n_zer-a == 1) {
+      if (poltyp[a] != 1 || zertyp[a] != 1) 
+	 error("Internal error; bad poltyp or zertyp for final pole/zero");
+      ff->typ= 'I';
+      ff->len= 2;
+      ff->val[0]= 1;
+      ff->val[1]= -pol[a];
+      ff= FFNEXT(ff); 
+
+      // Skip FIR if it is constant and zero
+      if (!cbm || zer[a] != 0.0) {
+	 ff->typ= 'F';
+	 ff->cbm= cbm;
+	 ff->len= 2;
+	 ff->val[0]= 1;
+	 ff->val[1]= -zer[a];
+	 ff= FFNEXT(ff); 
+      }
+   } else 
+      error("Internal error: unexpected poles/zeros at end of list");
+
+   // End of list
+   ff->typ= 0;
+   ff->len= 0;
+   ff= FFNEXT(ff);
+   
+   rv= (FidFilter*)realloc(rv, ((char*)ff)-((char*)rv));
+   if (!rv) error("Out of memory");
+   return rv;
+}
+
+//
+//	Setup poles/zeros for a band-pass resonator.  'qfact' gives
+//	the Q-factor; 0 is a special value indicating +infinity,
+//	giving an oscillator.
+//
+
+static void 
+bandpass_res(double freq, double qfact) {
+   double mag;
+   double th0, th1, th2;
+   double theta= freq * TWOPI;
+   double val[2];
+   double tmp1[2], tmp2[2], tmp3[2], tmp4[2];
+   int cnt;
+
+   n_pol= 2;
+   poltyp[0]= 2; poltyp[1]= 0;
+   n_zer= 2;
+   zertyp[0]= 1; zertyp[1]= 1;
+   zer[0]= 1; zer[1]= -1;
+
+   if (qfact == 0.0) {
+      cexpj(pol, theta);
+      return;
+   }
+
+   // Do a full binary search, rather than seeding it as Tony Fisher does
+   cexpj(val, theta);
+   mag= exp(-theta / (2.0 * qfact));
+   th0= 0; th2= M_PI;
+   for (cnt= 60; cnt > 0; cnt--) {
+      th1= 0.5 * (th0 + th2);
+      cexpj(pol, th1);
+      cmulr(pol, mag);
+      
+      // Evaluate response of filter for Z= val
+      memcpy(tmp1, val, 2*sizeof(double));
+      memcpy(tmp2, val, 2*sizeof(double));
+      memcpy(tmp3, val, 2*sizeof(double));
+      memcpy(tmp4, val, 2*sizeof(double));
+      csubz(tmp1, 1, 0);
+      csubz(tmp2, -1, 0);
+      cmul(tmp1, tmp2);
+      csub(tmp3, pol); cconj(pol);
+      csub(tmp4, pol); cconj(pol);
+      cmul(tmp3, tmp4);
+      cdiv(tmp1, tmp3);
+      
+      if (fabs(tmp1[1] / tmp1[0]) < 1e-10) break;
+
+      //printf("%-24.16g%-24.16g -> %-24.16g%-24.16g\n", th0, th2, tmp1[0], tmp1[1]);
+
+      if (tmp1[1] > 0.0) th2= th1;
+      else th0= th1;
+   }
+
+   if (cnt <= 0) fprintf(stderr, "Resonator binary search failed to converge");
+}
+
+//
+//	Setup poles/zeros for a bandstop resonator
+//
+
+static void 
+bandstop_res(double freq, double qfact) {
+   bandpass_res(freq, qfact);
+   zertyp[0]= 2; zertyp[1]= 0;
+   cexpj(zer, TWOPI * freq);
+}
+
+//
+//	Setup poles/zeros for an allpass resonator
+//
+
+static void 
+allpass_res(double freq, double qfact) {
+   bandpass_res(freq, qfact);
+   zertyp[0]= 2; zertyp[1]= 0;
+   memcpy(zer, pol, 2*sizeof(double));
+   cmulr(zer, 1.0 / (zer[0]*zer[0] + zer[1]*zer[1]));
+}
+
+//
+//	Setup poles/zeros for a proportional-integral filter
+//
+
+static void 
+prop_integral(double freq) {
+   n_pol= 1;
+   poltyp[0]= 1;
+   pol[0]= 0.0;
+   n_zer= 1;
+   zertyp[0]= 1;
+   zer[0]= -TWOPI * freq;
+}
+   
+// END //
+#endif
+

=== added file 'mixxx/lib/fidlib-0.9.10/fidrf_cmdlist.h'
--- mixxx/lib/fidlib-0.9.10/fidrf_cmdlist.h	1970-01-01 00:00:00 +0000
+++ mixxx/lib/fidlib-0.9.10/fidrf_cmdlist.h	2011-07-25 04:35:51 +0000
@@ -0,0 +1,479 @@
+//
+//	Command-list based filter-running code.  
+//
+//        Copyright (c) 2002-2003 Jim Peters <http://uazu.net/>.  This
+//        file is released under the GNU Lesser General Public License
+//        (LGPL) version 2.1 as published by the Free Software
+//        Foundation.  See the file COPYING_LIB for details, or visit
+//        <http://www.fsf.org/licenses/licenses.html>.
+//
+//	This version of the filter-running code is based on getting
+//	the filter to go as fast as possible with a pre-compiled
+//	routine, but without flattening the filter structure.  This
+//	gives greater accuracy than the combined filter.  The result
+//	is mostly faster than the combined filter (tested on ix86 with
+//	gcc -O6), except where the combined filter gets a big
+//	advantage from flattening the filter list.  This code is also
+//	portable (unlike the JIT option).
+//
+
+typedef struct Run {
+   int magic;		// Magic: 0x64966325
+   int buf_size;	// Length of working buffer required in doubles	
+   double *coef;	// Coefficient list
+   char *cmd;		// Command list
+} Run;
+
+typedef struct RunBuf {
+   double *coef;
+   char *cmd;
+   int mov_cnt;		// Number of bytes to memmove
+   double buf[0];
+} RunBuf;
+
+
+//
+//	Filter processing routine.  This is designed to avoid too many
+//	branches, and references are very localized in the code,
+//	keeping the optimizer from trying to store and remember old
+//	values.
+//
+
+//
+//	Step commands:
+//	  0  END
+//	  1  IIR coefficient (1+0)
+//	  2  2x IIR coefficient (2+0)
+//	  3  3x IIR coefficient (3+0)
+//	  4  4Nx IIR coefficient (4N+0)
+//	  5  FIR coefficient (0+1)
+//	  6  2x FIR coefficient (0+2)
+//	  7  3x FIR coefficient (0+3)
+//	  8  4Nx FIR coefficient (0+4N)
+//	  9  IIR+FIR coefficients (1+1)
+//	 10  2x IIR+FIR coefficients (2+2)
+//	 11  3x IIR+FIR coefficients (3+3)
+//	 12  4Nx IIR+FIR coefficients (4N+4N)
+//	 13  End-stage, pure IIR, assume no FIR done at all (1+0)
+//	 14  End-stage with just FIR coeff (0+2)
+//	 15  End-stage with IIR+FIR coeff (1+2)
+//	 16  IIR + pure-IIR endstage (2+0)
+//	 17  FIR + FIR end-stage (0+3)
+//	 18  IIR+FIR + IIR+FIR end-stage (2+3)
+//	 19  Nx (IIR + pure-IIR endstage) (2+0)
+//	 20  Nx (FIR + FIR end-stage) (0+3)
+//	 21  Nx (IIR+FIR + IIR+FIR end-stage) (2+3)
+//	 22  Gain coefficient (0+1)
+//
+//	Most filters are made up of 2x2 IIR/FIR pairs, which means a
+//	list of command 18 bytes.  The other big job would be long FIR
+//	filters.  These have to be handled with a list of 7,6,5
+//	commands, plus a 13 command.
+//
+
+typedef unsigned char uchar;
+
+static double 
+filter_step(void *fbuf, double iir) {
+   double *coef= ((RunBuf*)fbuf)->coef;
+   uchar *cmd= ((RunBuf*)fbuf)->cmd;
+   double *buf= &((RunBuf*)fbuf)->buf[0];
+   uchar ch;
+   double fir= 0;
+   double tmp= buf[0];
+   int cnt;
+
+   // Using a memmove first is faster on gcc -O6 / ix86 than moving
+   // the values whilst working through the buffers.
+   memmove(buf, buf+1, ((RunBuf*)fbuf)->mov_cnt);
+
+#define IIR \
+       iir -= *coef++ * tmp; \
+       tmp= *buf++;
+#define FIR \
+       fir += *coef++ * tmp; \
+       tmp= *buf++;
+#define BOTH \
+       iir -= *coef++ * tmp; \
+       fir += *coef++ * tmp; \
+       tmp= *buf++;
+#define ENDIIR \
+       iir -= *coef++ * tmp; \
+       tmp= *buf++; \
+       buf[-1]= iir;
+#define ENDFIR \
+       fir += *coef++ * tmp; \
+       tmp= *buf++; \
+       buf[-1]= iir; \
+       iir= fir + *coef++ * iir; \
+       fir= 0
+#define ENDBOTH \
+       iir -= *coef++ * tmp; \
+       fir += *coef++ * tmp; \
+       tmp= *buf++; \
+       buf[-1]= iir; \
+       iir= fir + *coef++ * iir; \
+       fir= 0
+#define GAIN \
+       iir *= *coef++
+
+   while ((ch= *cmd++)) switch (ch) {
+    case 1:
+       IIR; break;
+    case 2:
+       IIR; IIR; break;
+    case 3:
+       IIR; IIR; IIR; break;
+    case 4:
+       cnt= *cmd++; 
+       do { IIR; IIR; IIR; IIR; } while (--cnt > 0);
+       break;
+    case 5:
+       FIR; break;
+    case 6:
+       FIR; FIR; break;
+    case 7:
+       FIR; FIR; FIR; break;
+    case 8:
+       cnt= *cmd++; 
+       do { FIR; FIR; FIR; FIR; } while (--cnt > 0);
+       break;
+    case 9:
+       BOTH; break;
+    case 10:
+       BOTH; BOTH; break;
+    case 11:
+       BOTH; BOTH; BOTH; break;
+    case 12:
+       cnt= *cmd++; 
+       do { BOTH; BOTH; BOTH; BOTH; } while (--cnt > 0);
+       break;
+    case 13:
+       ENDIIR; break;
+    case 14:
+       ENDFIR; break;
+    case 15:
+       ENDBOTH; break;
+    case 16:
+       IIR; ENDIIR; break;
+    case 17:
+       FIR; ENDFIR; break;
+    case 18:
+       BOTH; ENDBOTH; break;
+    case 19:
+       cnt= *cmd++; 
+       do { IIR; ENDIIR; } while (--cnt > 0);
+       break;
+    case 20:
+       cnt= *cmd++; 
+       do { FIR; ENDFIR; } while (--cnt > 0);
+       break;
+    case 21:
+       cnt= *cmd++; 
+       do { BOTH; ENDBOTH; } while (--cnt > 0);
+       break;
+    case 22:
+       GAIN; break;
+   }
+
+#undef IIR
+#undef FIR
+#undef BOTH
+#undef ENDIIR
+#undef ENDFIR
+#undef ENDBOTH
+#undef GAIN
+
+   return iir;
+}
+
+
+//
+//	Create an instance of a filter, ready to run.  This returns a
+//	void* handle, and a function to call to execute the filter.
+//	Working buffers for the filter instances must be allocated
+//	separately using fid_run_newbuf().  This allows many
+//	simultaneous instances of the filter to be run.  
+//
+//	The sub-filters are executed in the precise order that they
+//	are given.  This may lead to some inefficiency.  Normally when
+//	an IIR filter is followed by an FIR filter, the buffers can be
+//	shared.  However, if the sub-filters are not in IIR/FIR pairs,
+//	then extra memory accesses are required.
+//
+//	In any case, factors are extracted from IIR filters (so that
+//	the first coefficient is 1), and single-element FIR filters
+//	are merged into the global gain factor, and are ignored.
+//
+//	The returned handle must be released using fid_run_free().
+//
+
+void *
+fid_run_new(FidFilter *filt, double (**funcpp)(void *,double)) {
+   int buf_size= 0;
+   uchar *cp, prev;
+   FidFilter *ff;
+   double *dp;
+   double gain= 1.0;
+   int a;
+   double *coef_tmp;
+   uchar *cmd_tmp;
+   int coef_cnt, coef_max;
+   int cmd_cnt, cmd_max;
+   int filt_cnt= 0;
+   Run *rr;
+
+   for (ff= filt; ff->len; ff= FFNEXT(ff))
+      filt_cnt += ff->len;
+
+   // Allocate worst-case sizes for temporary arrays
+   coef_tmp= ALLOC_ARR(coef_max= filt_cnt + 1, double);
+   cmd_tmp= (uchar*)ALLOC_ARR(cmd_max= filt_cnt + 4, char);
+   dp= coef_tmp;
+   cp= cmd_tmp;
+   prev= 0;
+
+   // Generate command and coefficient lists
+   while (filt->len) {
+      int n_iir, n_fir, cnt;
+      double *iir, *fir;
+      double adj;
+      if (filt->typ == 'F' && filt->len == 1) {
+	 gain *= filt->val[0];
+	 filt= FFNEXT(filt);
+	 continue;
+      }
+      if (filt->typ == 'F') {
+	 iir= 0; n_iir= 0;
+	 fir= filt->val; n_fir= filt->len;
+	 filt= FFNEXT(filt);
+      } else if (filt->typ == 'I') {
+	 iir= filt->val; n_iir= filt->len;
+	 fir= 0; n_fir= 0;
+	 filt= FFNEXT(filt);
+	 while (filt->typ == 'F' && filt->len == 1) {
+	    gain *= filt->val[0]; 
+	    filt= FFNEXT(filt);
+	 }
+	 if (filt->typ == 'F') {
+	    fir= filt->val; n_fir= filt->len;
+	    filt= FFNEXT(filt); 
+	 }
+      } else 
+	 error("Internal error: fid_run_new can only handle IIR + FIR types");
+      
+      // Okay, we now have an IIR/FIR pair to process, possibly with
+      // n_iir or n_fir == 0 if one half is missing
+      cnt= n_iir > n_fir ? n_iir : n_fir;
+      buf_size += cnt-1;
+      if (n_iir) {
+	 adj= 1.0 / iir[0];
+	 gain *= adj;
+      }
+      if (n_fir == 3 && n_iir == 3) {
+	 if (prev == 18) { cp[-1]= prev= 21; *cp++= 2; }
+	 else if (prev == 21) { cp[-1]++; }
+	 else *cp++= prev= 18;
+	 *dp++= iir[2]*adj; *dp++= fir[2];
+	 *dp++= iir[1]*adj; *dp++= fir[1];
+	 *dp++= fir[0];
+      } else if (n_fir == 3 && n_iir == 0) {
+	 if (prev == 17) { cp[-1]= prev= 20; *cp++= 2; }
+	 else if (prev == 20) { cp[-1]++; }
+	 else *cp++= prev= 17;
+	 *dp++= fir[2];
+	 *dp++= fir[1];
+	 *dp++= fir[0];
+      } else if (n_fir == 0 && n_iir == 3) {
+	 if (prev == 16) { cp[-1]= prev= 19; *cp++= 2; }
+	 else if (prev == 19) { cp[-1]++; }
+	 else *cp++= prev= 16;
+	 *dp++= iir[2]*adj;
+	 *dp++= iir[1]*adj;
+      } else {
+	 prev= 0;	// Just cancel 'prev' as we only use it for 16-18,19-21
+	 if (cnt > n_fir) {
+	    a= 0; 
+	    while (cnt > n_fir && cnt > 2) {
+	       *dp++= iir[--cnt] * adj; a++;
+	    }
+	    while (a >= 4) { 
+	       int nn= a/4; if (nn > 255) nn= 255;
+	       *cp++= 4; *cp++= nn; a -= nn*4; 
+	    }
+	    if (a) *cp++= a;
+	 }
+	 if (cnt > n_iir) {
+	    a= 0; 
+	    while (cnt > n_iir && cnt > 2) {
+	       *dp++= fir[--cnt]; a++;
+	    }
+	    while (a >= 4) { 
+	       int nn= a/4; if (nn > 255) nn= 255;
+	       *cp++= 8; *cp++= nn; a -= nn*4; 
+	    }
+	    if (a) *cp++= 4+a;
+	 }
+	 a= 0;
+	 while (cnt > 2) {
+	    cnt--; a++;
+	    *dp++= iir[cnt]*adj; *dp++= fir[cnt];
+	 }
+	 while (a >= 4) { 
+	    int nn= a/4; if (nn > 255) nn= 255;
+	    *cp++= 12; *cp++= nn; a -= nn*4; 
+	 }
+	 if (a) *cp++= 8+a;
+
+	 if (!n_fir) {
+	    *cp++= 13;
+	    *dp++= iir[1];
+	 } else if (!n_iir) {
+	    *cp++= 14;
+	    *dp++= fir[1];
+	    *dp++= fir[0];
+	 } else {
+	    *cp++= 15;
+	    *dp++= iir[1];
+	    *dp++= fir[1];
+	    *dp++= fir[0];
+	 }
+      }
+   }
+   
+   if (gain != 1.0) {
+      *cp++= 22;
+      *dp++= gain;
+   }
+   *cp++= 0;
+
+   // Sanity checks
+   coef_cnt= dp-coef_tmp;
+   cmd_cnt= cp-cmd_tmp;
+   if (coef_cnt > coef_max ||
+       cmd_cnt > cmd_max) 
+      error("fid_run_new internal error; arrays exceeded");
+
+   // Allocate the final Run structure to return
+   rr= (Run*)Alloc(sizeof(Run) +
+		   coef_cnt*sizeof(double) +
+		   cmd_cnt*sizeof(char));
+   rr->magic= 0x64966325;
+   rr->buf_size= buf_size;
+   rr->coef= (double*)(rr+1);
+   rr->cmd= (char*)(rr->coef + coef_cnt);
+   memcpy(rr->coef, coef_tmp, coef_cnt*sizeof(double));
+   memcpy(rr->cmd, cmd_tmp, cmd_cnt*sizeof(char));
+
+   //DEBUG   {
+   //DEBUG      int a;
+   //DEBUG      for (cp= cmd_tmp; *cp; cp++) printf("%d ", *cp);
+   //DEBUG      printf("\n");
+   //DEBUG      //for (a= 0; a<coef_cnt; a++) printf("%g ", coef_tmp[a]);
+   //DEBUG      //printf("\n");
+   //DEBUG   }
+   
+   free(coef_tmp);
+   free(cmd_tmp);
+
+   *funcpp= filter_step;
+   return rr;
+}
+
+//
+//	Create a new instance of the given filter
+//
+
+void *
+fid_run_newbuf(void *run) {
+   Run *rr= (Run*)run;
+   RunBuf *rb;
+   int siz;
+
+   if (rr->magic != 0x64966325)
+      error("Bad handle passed to fid_run_newbuf()");
+   
+   siz= rr->buf_size ? rr->buf_size : 1;   // Minimum one element to avoid problems
+   rb= (RunBuf*)Alloc(sizeof(RunBuf) + siz * sizeof(double));
+   rb->coef= rr->coef;
+   rb->cmd= rr->cmd;
+   rb->mov_cnt= (siz-1) * sizeof(double);
+   // rb->buf[] already zerod
+
+   return rb;
+}
+
+//
+//	Find the space required for a filter buffer
+//
+
+int 
+fid_run_bufsize(void *run) {
+   Run *rr= (Run*)run;
+   int siz;
+
+   if (rr->magic != 0x64966325)
+      error("Bad handle passed to fid_run_bufsize()");
+   
+   siz= rr->buf_size ? rr->buf_size : 1;   // Minimum one element to avoid problems
+   return sizeof(RunBuf) + siz * sizeof(double);
+}
+
+//
+//	Initialise a filter buffer allocated separately.  Usually
+//	fid_run_newbuf() is easier, but in the case where filter
+//	buffers must be allocated as part of a larger structure, a
+//	call to fid_run_newbuf can be replaced with a call to
+//	fid_run_bufsize() to get the space required, and then a call
+//	to fid_run_initbuf() once it has been allocated.
+//
+
+void 
+fid_run_initbuf(void *run, void *buf) {
+   Run *rr= (Run*)run;
+   RunBuf *rb= (RunBuf*)buf;
+   int siz;
+
+   if (rr->magic != 0x64966325)
+      error("Bad handle passed to fid_run_initbuf()");
+   
+   siz= rr->buf_size ? rr->buf_size : 1;   // Minimum one element to avoid problems
+   rb->coef= rr->coef;
+   rb->cmd= rr->cmd;
+   rb->mov_cnt= (siz-1) * sizeof(double);
+   memset(rb->buf, 0, rb->mov_cnt + sizeof(double));
+}
+
+//
+//	Reinitialise an instance of the filter, allowing it to start
+//	afresh.  It assumes that the buffer was correctly initialised
+//	previously, either through a call to fid_run_newbuf() or
+//	fid_run_initbuf().
+//
+
+void 
+fid_run_zapbuf(void *buf) {
+   RunBuf *rb= (RunBuf*)buf;
+   memset(rb->buf, 0, rb->mov_cnt + sizeof(double));
+}   
+   
+
+//
+//	Delete an instance
+//
+
+void 
+fid_run_freebuf(void *runbuf) {
+   free(runbuf);
+}
+
+//
+//	Delete the filter
+//
+
+void 
+fid_run_free(void *run) {
+   free(run);
+}
+
+// END //

=== added file 'mixxx/lib/fidlib-0.9.10/fidrf_combined.h'
--- mixxx/lib/fidlib-0.9.10/fidrf_combined.h	1970-01-01 00:00:00 +0000
+++ mixxx/lib/fidlib-0.9.10/fidrf_combined.h	2011-07-25 04:35:51 +0000
@@ -0,0 +1,151 @@
+//
+//	Combined-filter based filter-running code.  
+//
+//        Copyright (c) 2002-2003 Jim Peters <http://uazu.net/>.  This
+//        file is released under the GNU Lesser General Public License
+//        (LGPL) version 2.1 as published by the Free Software
+//        Foundation.  See the file COPYING_LIB for details, or visit
+//        <http://www.fsf.org/licenses/licenses.html>.
+//
+//	Convolves all the filters into a single IIR/FIR pair, and runs
+//	that directly through static code.  Compiled with GCC -O6 on
+//	ix86 this is surprisingly fast -- at worst half the speed of
+//	assember code, at best matching it.  The downside of
+//	convolving all the sub-filters together like this is loss of
+//	accuracy and instability in some kinds of filters, especially
+//	high-order ones.  The one big advantage of this approach is
+//	that the code is easy to understand.
+//
+
+#ifndef FIDCOMBINED_H
+#define FIDCOMBINED_H
+
+typedef struct Run {
+   int magic;		// Magic: 0x64966325
+   double *fir;         // FIR parameters
+   int n_fir;           // Number of FIR parameters
+   double *iir;         // IIR parameters
+   int n_iir;           // Number of IIR parameters
+   int n_buf;           // Number of entries in buffer
+   FidFilter *filt;	// Combined filter
+} Run;
+
+typedef struct RunBuf {
+   Run *run;
+   double buf[0];
+} RunBuf;
+
+static double 
+filter_step(void *rb, double val) {
+   Run *rr= ((RunBuf*)rb)->run;
+   double *buf= ((RunBuf*)rb)->buf;
+   int a;
+
+   // Shift the whole internal array up one
+   memmove(buf+1, buf, (rr->n_buf-1)*sizeof(buf[0]));
+   
+   // Do IIR
+   for (a= 1; a<rr->n_iir; a++) val -= rr->iir[a] * buf[a];
+   buf[0]= val;
+
+   // Do FIR
+   val= 0;
+   for (a= 0; a<rr->n_fir; a++) val += rr->fir[a] * buf[a];
+
+   return val;
+}
+
+
+//
+//	Create an instance of a filter, ready to run.  This returns a
+//	void* handle, and a function to call to execute the filter.
+//	Working buffers for the filter instances must be allocated
+//	separately using fid_run_newbuf().  This allows many
+//	simultaneous instances of the filter to be run.  
+//
+//	The returned handle must be released using fid_run_free().
+//
+
+void *
+fid_run_new(FidFilter *filt, double (**funcpp)(void *,double)) {
+   Run *rr= ALLOC(Run);
+   FidFilter *ff;
+
+   rr->magic= 0x64966325;
+   rr->filt= fid_flatten(filt);
+
+   ff= rr->filt;
+   if (ff->typ != 'I') goto bad;
+   rr->n_iir= ff->len;
+   rr->iir= ff->val;	
+   ff= FFNEXT(ff);
+   if (ff->typ != 'F') goto bad;
+   rr->n_fir= ff->len;
+   rr->fir= ff->val;
+   ff= FFNEXT(ff);
+   if (ff->len) goto bad;
+   
+   rr->n_buf= rr->n_fir > rr->n_iir ? rr->n_fir : rr->n_iir;
+   
+   *funcpp= filter_step;
+   
+   return rr;
+   
+ bad:
+   error("Internal error: fid_run_new() expecting IIR+FIR in flattened filter");
+   return 0;
+}
+
+//
+//	Create a new instance of the given filter
+//
+
+void *
+fid_run_newbuf(void *run) {
+   Run *rr= run;
+   RunBuf *rb;
+
+   if (rr->magic != 0x64966325)
+      error("Bad handle passed to fid_run_newbuf()");
+   
+   rb= Alloc(sizeof(RunBuf) + rr->n_buf * sizeof(double));
+   rb->run= run;
+   // rb->buf[] already zerod
+
+   return rb;
+}
+
+//
+//	Reinitialise an instance ready to start afresh
+//
+
+void
+fid_run_zapbuf(void *buf) {
+   RunBuf *rb;
+   Run *rr= rb->run;
+   memset(rb->buf, 0, rr->n_buf * sizeof(double));
+}
+
+//
+//	Delete an instance
+//
+
+void 
+fid_run_freebuf(void *runbuf) {
+   free(runbuf);
+}
+
+//
+//	Delete the filter
+//
+
+void 
+fid_run_free(void *run) {
+   Run *rr= run;
+   free(rr->filt);
+   free(rr);
+}
+
+// END //
+#endif
+

=== added file 'mixxx/lib/fidlib-0.9.10/fidrf_jit.h'
--- mixxx/lib/fidlib-0.9.10/fidrf_jit.h	1970-01-01 00:00:00 +0000
+++ mixxx/lib/fidlib-0.9.10/fidrf_jit.h	2011-07-25 04:35:51 +0000
@@ -0,0 +1,792 @@
+#error "JIT code is no longer maintained -- cmdlist is almost as fast on ix86"
+
+//
+//	JIT-compiled filter-running code.  
+//
+//        Copyright (c) 2002-2003 Jim Peters <http://uazu.net/>.  This
+//        file is released under the GNU Lesser General Public License
+//        (LGPL) version 2.1 as published by the Free Software
+//        Foundation.  See the file COPYING_LIB for details, or visit
+//	  <http://www.fsf.org/licenses/licenses.html>.
+//
+//	The aim of this version of the filter-running code is to go as
+//	fast as possible (without flattening the sub-filters together)
+//	by generating the necessary code at run-time.
+//
+//	This runs the filter exactly as specified, without convolving
+//	the sub-filters together or changing their order.  The only
+//	rearrangement performed is making the IIR first coefficient
+//	1.0, and gathering any lone 1-coefficient FIR filters together
+//	into a single initial gain adjustment.  For this reason, the
+//	routine runs fastest if IIR and FIR sub-filters are grouped
+//	together in IIR/FIR pairs, as these can then share common
+//	working buffers.
+//
+//	The generated code is cached, and is reused for more than one
+//	filter if possible.  This means that a bank of 1000s of
+//	filters of similar types will probably all end up sharing the
+//	same generated routine, which improves processor cache and
+//	memory usage.
+//
+//	Probably the generated code could be improved, but it is not
+//	too bad.  Copying the buffer values using 'rep movsl' turned
+//	out to be much faster than loading and storing the floating
+//	point values individually whilst working through the buffer.
+//
+//	The generated code was tested for speed on a Celeron-900 and
+//	on a Pentium-133.  It always beats the RF_CMDLIST option.  It
+//	can be slightly slower than the RF_COMBINED option, but only
+//	where that option gets a big advantage from flattening the
+//	sub-filters.  For pre-flattened filters, it is faster.
+//
+//	The generated code can be dumped out at any point in .s format
+//	using fid_run_dump().  This can be assembled using 'gas' and
+//	then disassembled with 'objdump -d' to see all the generated
+//	code.
+//
+//	Things that could be improved:
+//
+//	- Don't keep the fir running total on the stack at all times.
+//	Instead create it at the first FIR operation.  This means
+//	generating about 10 new special-case macros.  This would save
+//	an add for every filter stage, and some of the messing around
+//	at start and end currently done to set up / clean up this
+//	value on the FP stack.
+//
+
+typedef struct Routine Routine;
+struct Routine {
+   Routine *nxt;	// Next in list, or 0
+   int ref;		// Reference count
+   int hash;		// Hash of routine
+   char *code;		// Routine itself
+   int len;		// Length of code in bytes
+};   
+
+typedef struct Run {
+   int magic;		// Magic: 0x64966325
+   int n_buf;		// Length of working buffer required in doubles	
+   double *coef;	// Coefficient list
+   Routine *rout;	// Routine used
+} Run;
+
+typedef struct RunBuf {
+   double *coef;	// Coefficient array
+   int mov_cnt;		// Number of 4-byte chunks to copy from &buf[1] to &buf[0]
+   double buf[0];	// Buffer itself
+} RunBuf;
+
+static unsigned long int do_hash(unsigned char *, unsigned long int, unsigned long int);
+#define HASH(p,len) ((int)do_hash((unsigned char *)p, (unsigned long int)len, 0))
+
+
+//	Code generation
+//
+//	%edx is the working buffer pointer
+//	%eax is the coefficient pointer
+//	%ecx is the loop counter
+//	floating point stack contains working values at the top, then
+//	  previous buffer value, then running iir total, then running
+//	  fir total
+//
+//	Codes in the add() string:
+//
+//	  %C  4-byte long value count for loop
+//	  %L  Label -- remember this address for looping back to
+//	  %R  1-byte relative jump back to %L address
+//	  %D  1-byte relative address of buffer value.  If zero, this adjusts the 
+//		previous byte by ^=0x40 to make it a pure (%edx) form instead of 0(%edx)
+//	  %D+ 1-byte relative address of buffer value as above, plus increment %edx 
+//		if we are getting close to the end of the range
+//	  %A  1-byte relative address of coefficient value.  If zero does same as for %D.
+//	  %A+ 1-byte relative address of coefficient value, plus %eax inc 
+//		if necessary
+//	  %=  Insert code to update %edx and %eax to point to the given offsets
+//	
+//	Startup code
+//
+//	  pushl %ebp
+//	  movl %esp,%ebp
+//	  movl 8(%ebp),%edx
+//	  movl (%edx),%eax
+//	  movl 4(%edx),%ecx
+//	  fldz
+//	  fldl 12(%ebp)
+//	  fldl 8(%edx)
+//	  fmull (%eax)
+//	  leal 8(%edx),%edi
+//	  leal 16(%edx),%esi
+//	  cld
+//        rep movsl
+
+#define STARTUP add("55 89E5 8B5508 8B02 8B4A04 D9EE DD450C DD4208 DC08 8D7A08 8D7210 FC F3A5")
+
+//	Return
+//
+//	  fstp %st(0)	// pop
+//	  fstp %st(1)
+//	  leave
+//	  ret
+
+#define RETURN add("DDD8 DDD9 C9 C3")
+
+//	Looping
+//
+//	  movl $100,%ecx
+//	.LXX
+//	  ...
+//	  loop .LXX
+//
+//	//WAS  decl %ecx
+//	//WAS  testl %ecx,%ecx
+//	//WAS  jg .LXX
+
+#define FOR(xx, nnd, nna) add("B9%C %= %L", xx, (nnd)*8, (nna)*8)
+//WAS #define NEXT(nnd, nna) add("%= 49 85C9 7F%R", (nnd)*8, (nna)*8)
+#define NEXT(nnd, nna) add("%= E2%R", (nnd)*8, (nna)*8)
+
+//	Fetching/storing buffer values
+//	
+//	tmp= buf[n];
+//	  fldl nn(%edx)
+//	
+//	buf[nn]= iir;
+//	  fld %st(1)
+//	  fstpl nn(%edx)
+
+#define GETB(nn) add("DD42%D+", (nn)*8)
+#define PUTB(nn) add("D9C1 DD5A%D+", (nn)*8)
+
+//	FIR element with following IIR element
+//