Packman Build Service PMBS

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

Changes of Revision 2

vamp-qm-plugins.changes Changed

vamp-qm-plugins.spec Changed

@@ -1,25 +1,36 @@
+# vim: set sw=4 ts=4 et:
+
 # Copyright (c) 2005-2009 oc2pus
-# This file and all modifications and additions to the pristine
-# package are under the same license as the package itself.
+# Copyright (c) 2012 Pascal Bleser <pascal.bleser@opensuse.org>
 #
-# Please submit bugfixes or comments to toni@links2linux.de
-
-# norootforbuild
+# All modifications and additions to the file contributed by third parties
+# remain the property of their copyright owners, unless otherwise agreed
+# upon. The license for this file, and modifications and additions to the
+# file, is the same license as for the pristine package itself (unless the
+# license for the pristine package is not an Open Source License, in which
+# case the license is the MIT License). An "Open Source License" is a
+# license that conforms to the Open Source Definition (Version 1.9)
+# published by the Open Source Initiative.
 
-%define _prefix	/usr
+# Please submit bugfixes or comments via http://bugs.opensuse.org/
 
-Name:			vamp-qm-plugins
-Summary:		A set of binary plugins for feature extraction from audio data
-Group:			Productivity/Multimedia/Sound/Utilities
-Url:			http://isophonics.net/QMVampPlugins
-Version:		1.6.1
-Release:		0.pm.1
-License:		GPL
-Source0:		http://isophonics.net/files/qm-vamp-plugins-1.6.1-i686-linux.tar.gz
-Source1:		http://isophonics.net/files/qm-vamp-plugins-1.6.1-amd64-linux.tar.gz
-BuildRoot:		%{_tmppath}/%{name}-%{version}-%{release}-build
-Requires:		sonic-visualiser
-ExcludeArch:	x86 x86_64
+Name:           vamp-qm-plugins
+Summary:        A set of binary plugins for feature extraction from audio data
+Group:          Productivity/Multimedia/Sound/Utilities
+Url:            http://isophonics.net/QMVampPlugins
+Version:        1.7
+Release:        0.pm.1
+License:        GPL-2.0+
+Source0:        https://code.soundsoftware.ac.uk/attachments/download/109/qm-vamp-plugins-%{version}.tar.gz
+Source1:        https://code.soundsoftware.ac.uk/attachments/download/103/qm-dsp-%{version}.tar.gz
+Patch1:         qm-dsp-size_t.patch
+Patch2:         qm-dsp-add_missing_include_dir.patch
+Patch3:         qm-vamp-plugins-fix_linking.patch
+BuildRoot:      %{_tmppath}/%{name}-%{version}-%{release}-build
+Requires:       sonic-visualiser
+BuildRequires:  gcc-c++
+BuildRequires:  vamp-plugin-sdk-devel
+BuildRequires:  libatlas3-devel
 
 %description
 A set of binary plugins for feature extraction from audio data,
@@ -32,41 +43,36 @@
 For further documentation see:
 http://www.elec.qmul.ac.uk/digitalmusic/downloads/#qm-vamp-plugins
 
-
-
 %prep
-%setup -q -T -c -n %{name}
-%ifarch x86_64
-	%__tar xf %{SOURCE1}
-%else
-	%__tar xf %{SOURCE0}
-%endif
+%setup -q -b 1 -n "qm-vamp-plugins-%{version}"
+pushd "../qm-dsp-%{version}"
+%patch1
+%patch2
+popd
+%patch3
 
 %build
+pushd "../qm-dsp-%{version}"
+%__make %{?_smp_mflags} -f build/linux/Makefile.linux64
+popd
+%__ln_s "qm-dsp-%{version}" ../qm-dsp
+%__ln_s "../qm-dsp-%{version}" qm-dsp
+%__make %{?_smp_mflags} -f build/linux/Makefile.linux64 \
+    LIB="%{_lib}"
 
 %install
-%ifarch x86_64
-pushd qm-vamp-plugins-%{version}-amd64-linux
-%else
-pushd qm-vamp-plugins-%{version}-i686-linux
-%endif
-	%__install -dm 755 %{buildroot}%{_libdir}/vamp
-	%__install -m 644 qm-vamp-plugins.* \
-		%{buildroot}%{_libdir}/vamp
-popd
+%__install -d "%{buildroot}%{_libdir}/vamp"
+%__install qm-vamp-plugins.{so,cat,n3} "%{buildroot}%{_libdir}/vamp/"
 
 %clean
-[ -d "%{buildroot}" -a "%{buildroot}" != "" ] && %__rm -rf "%{buildroot}"
+%{?buildroot:%__rm -rf "%{buildroot}"}
 
 %files
-%defattr(-,root,root,0755)
-%ifarch x86_64
-%doc qm-vamp-plugins-%{version}-amd64-linux/README*
-%else
-%doc qm-vamp-plugins-%{version}-i686-linux/README*
-%endif
+%defattr(-,root,root)
+%doc README.txt COPYING
 %dir %{_libdir}/vamp
-%{_libdir}/vamp/qm-vamp-plugins.*
+%{_libdir}/vamp/qm-vamp-plugins.so
+%{_libdir}/vamp/qm-vamp-plugins.cat
+%{_libdir}/vamp/qm-vamp-plugins.n3
 
 %changelog
-# vim: set sw=4 ts=4 et:

qm-dsp-add_missing_include_dir.patch Added

qm-dsp-size_t.patch Added

@@ -0,0 +1,40 @@
+--- dsp/tempotracking/DownBeat.h.orig	2012-03-15 17:34:27.653619322 +0100
++++ dsp/tempotracking/DownBeat.h	2012-03-15 17:34:41.716618818 +0100
+@@ -16,6 +16,7 @@
+ #ifndef DOWNBEAT_H
+ #define DOWNBEAT_H
+ 
++#include <cstdlib>
+ #include <vector>
+ 
+ #include "dsp/rateconversion/Decimator.h"
+--- dsp/tempotracking/TempoTrackV2.h.orig	2012-03-15 17:34:11.396619903 +0100
++++ dsp/tempotracking/TempoTrackV2.h	2012-03-15 17:34:23.268619482 +0100
+@@ -17,6 +17,7 @@
+ #ifndef TEMPOTRACKV2_H
+ #define TEMPOTRACKV2_H
+ 
++#include <cstdlib>
+ #include <vector>
+ 
+ using std::vector;
+--- dsp/tonal/TCSgram.h.orig	2012-03-15 17:34:46.790618643 +0100
++++ dsp/tonal/TCSgram.h	2012-03-15 17:34:53.404618404 +0100
+@@ -16,6 +16,7 @@
+ #ifndef _TCSGram_
+ #define _TCSGram_
+ 
++#include <cstdlib>
+ #include <vector>
+ #include <valarray>
+ #include <utility>
+--- base/Window.h.orig	2012-03-15 17:35:10.727617788 +0100
++++ base/Window.h	2012-03-15 17:35:17.684617541 +0100
+@@ -15,6 +15,7 @@
+ #ifndef _WINDOW_H_
+ #define _WINDOW_H_
+ 
++#include <cstdlib>
+ #include <cmath>
+ #include <iostream>
+ #include <map>

qm-vamp-plugins-fix_linking.patch Added

qm-vamp-plugins-libdir.patch Added

qm-dsp-1.7.tar.gz Added

qm-vamp-plugins-1.6.1-amd64-linux.tar.gz/qm-vamp-plugins.so Deleted

qm-vamp-plugins-1.6.1-i686-linux.tar.gz Deleted

qm-vamp-plugins-1.7.tar.gz/.hg_archival.txt Added

qm-vamp-plugins-1.7.tar.gz/.hgtags Added

qm-vamp-plugins-1.7.tar.gz/COPYING Added

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

qm-vamp-plugins-1.7.tar.gz/INSTALL_osx.txt Added

qm-vamp-plugins-1.7.tar.gz/INSTALL_win32.txt Added

qm-vamp-plugins-1.6.1-amd64-linux.tar.gz/README.txt -> qm-vamp-plugins-1.7.tar.gz/README.txt Changed

@@ -7,7 +7,7 @@
 
 http://www.elec.qmul.ac.uk/digitalmusic/
 
-Version 1.6.1.
+Version 1.7.
 
 For more information about Vamp plugins, see http://www.vamp-plugins.org/ .
 
@@ -15,9 +15,9 @@
 About This Release
 ==================
 
-This is a bug-fix release, fixing a failure to correctly smooth the
-onset detection function which caused the onset and beat tracking
-plugins occasionally to miss onsets or find spurious ones.
+This release corresponds to a change in the licensing terms under
+which the QM plugins are published (from a closed-source license to
+the GPL).  It contains no new functionality over 1.6.
 
 
 Plugins Included
@@ -51,17 +51,19 @@
 License
 =======
 
-These plugins are provided in binary form only.  You may install and
-use the plugin binaries without fee for any purpose commercial or
-non-commercial.  You may redistribute the plugin binaries provided you
-do so without fee and you retain this README file with your
-distribution.  You may not bundle these plugins with a commercial
-product or distribute them on commercial terms.  If you wish to
-arrange commercial licensing terms, please contact the Centre for
-Digital Music at Queen Mary, University of London.
+These plugins are provided under the terms of the GNU General Public
+License.  You may install and use the plugin binaries without fee for
+any purpose commercial or non-commercial.  You may also modify and
+redistribute the plugins in source or binary form, provided you comply
+with the terms given by the GNU General Public License.  See the file
+COPYING for more details.
 
-Copyright (c) 2006-2009 Queen Mary, University of London.  All rights
-reserved except as described above.
+If you wish to use these plugins in a proprietary application or
+product for which the terms of the GPL are not appropriate, please
+contact the Centre for Digital Music at Queen Mary, University of
+London for further licensing terms.
+
+Copyright (c) 2006-2011 Queen Mary, University of London.
 
 
 To Install
@@ -69,18 +71,17 @@
 
 Installation depends on your operating system.
 
-    Windows -> Copy qm-vamp-plugins.dll and qm-vamp-plugins.cat to
-               C:\Program Files\Vamp Plugins\
+    Win 32  -> Copy qm-vamp-plugins.dll, qm-vamp-plugins.cat and
+               qm-vamp-plugins.n3 to C:\Program Files\Vamp Plugins\
+
+    Win 64  -> Copy qm-vamp-plugins.dll, qm-vamp-plugins.cat and
+               qm-vamp-plugins.n3 to C:\Program Files\Vamp Plugins (x86)\
 
-    OS/X    -> Copy qm-vamp-plugins.dylib and qm-vamp-plugins.cat to
-               $HOME/Library/Audio/Plug-Ins/Vamp/
-               or
-               /Library/Audio/Plug-Ins/Vamp/
+    OS/X    -> Copy qm-vamp-plugins.dylib, qm-vamp-plugins.cat and
+               qm-vamp-plugins.n3 to $HOME/Library/Audio/Plug-Ins/Vamp/
+               or /Library/Audio/Plug-Ins/Vamp/
 
-    Linux   -> Copy qm-vamp-plugins.so and qm-vamp-plugins.cat to
-               $HOME/vamp/
-               or
-               /usr/local/lib/vamp/
-               or 
-               /usr/lib/vamp/
+    Linux   -> Copy qm-vamp-plugins.so, qm-vamp-plugins.cat and
+               qm-vamp-plugins.n3 to $HOME/vamp/ or /usr/local/lib/vamp/
+               or /usr/lib/vamp/

qm-vamp-plugins-1.7.tar.gz/build Added

qm-vamp-plugins-1.7.tar.gz/build/general Added

qm-vamp-plugins-1.7.tar.gz/build/general/Makefile.inc Added

@@ -0,0 +1,51 @@
+
+PLUGIN_EXT	?= .so
+PLUGIN	?= qm-vamp-plugins$(PLUGIN_EXT)
+CXX	?= g++
+CC	?= gcc
+
+CFLAGS	:= $(CFLAGS) -I. -I../qm-dsp
+CXXFLAGS	:= $(CXXFLAGS) -I. -I../qm-dsp
+LDFLAGS		:= -L../qm-dsp $(LDFLAGS)
+
+HEADERS := plugins/AdaptiveSpectrogram.h \
+           plugins/BarBeatTrack.h \
+           plugins/BeatTrack.h \
+           plugins/DWT.h \
+           plugins/OnsetDetect.h \
+           plugins/ChromagramPlugin.h \
+           plugins/ConstantQSpectrogram.h \
+           plugins/KeyDetect.h \
+           plugins/MFCCPlugin.h \
+           plugins/SegmenterPlugin.h \
+           plugins/SimilarityPlugin.h \
+           plugins/TonalChangeDetect.h \
+           plugins/Transcription.h
+
+SOURCES := g2cstubs.c \
+           plugins/AdaptiveSpectrogram.cpp \
+           plugins/BarBeatTrack.cpp \
+           plugins/BeatTrack.cpp \
+           plugins/DWT.cpp \
+           plugins/OnsetDetect.cpp \
+           plugins/ChromagramPlugin.cpp \
+           plugins/ConstantQSpectrogram.cpp \
+           plugins/KeyDetect.cpp \
+           plugins/MFCCPlugin.cpp \
+           plugins/SegmenterPlugin.cpp \
+           plugins/SimilarityPlugin.cpp \
+           plugins/TonalChangeDetect.cpp \
+           plugins/Transcription.cpp \
+           libmain.cpp
+
+OBJECTS := $(SOURCES:.cpp=.o)
+OBJECTS := $(OBJECTS:.c=.o)
+
+$(PLUGIN):	$(OBJECTS)
+		$(CXX) -o $@ $^ $(LDFLAGS)
+
+clean:		
+		rm $(OBJECTS)
+
+distclean:	clean
+		rm $(PLUGIN)

qm-vamp-plugins-1.7.tar.gz/build/linux Added

qm-vamp-plugins-1.7.tar.gz/build/linux/Makefile.linux Added

qm-vamp-plugins-1.7.tar.gz/build/linux/Makefile.linux64 Added

qm-vamp-plugins-1.7.tar.gz/build/osx Added

qm-vamp-plugins-1.7.tar.gz/build/osx/Makefile.osx Added

qm-vamp-plugins-1.7.tar.gz/build/osx/qm-vamp-plugins.pro Added

@@ -0,0 +1,42 @@
+
+TEMPLATE = lib
+QMAKE_MAC_SDK=/Developer/SDKs/MacOSX10.4u.sdk
+QMAKE_CXXFLAGS_RELEASE += -O2 -g0
+
+CONFIG += plugin warn_on release x86 ppc
+CONFIG -= qt
+
+linux-g++:QMAKE_CXXFLAGS_RELEASE += -DNDEBUG -O3 -march=pentium4 -msse -msse2
+
+OBJECTS_DIR = tmp_obj
+MOC_DIR = tmp_moc
+
+INCLUDEPATH += ../vamp-plugin-sdk ../qm-dsp
+LIBPATH += ../vamp-plugin-sdk/vamp-sdk ../qm-dsp
+
+LIBS += -install_name qm-vamp-plugins.dylib -lqm-dsp -lvamp-sdk -lblas -llapack 
+
+DEPENDPATH += plugins
+INCLUDEPATH += . plugins
+
+# Input
+HEADERS += plugins/BeatTrack.h \
+           plugins/OnsetDetect.h \
+           plugins/ChromagramPlugin.h \
+           plugins/ConstantQSpectrogram.h \
+           plugins/KeyDetect.h \
+           plugins/MFCCPlugin.h \
+           plugins/SegmenterPlugin.h \
+           plugins/SimilarityPlugin.h \
+           plugins/TonalChangeDetect.h
+SOURCES += plugins/BeatTrack.cpp \
+           plugins/OnsetDetect.cpp \
+           plugins/ChromagramPlugin.cpp \
+           plugins/ConstantQSpectrogram.cpp \
+           plugins/KeyDetect.cpp \
+           plugins/MFCCPlugin.cpp \
+           plugins/SegmenterPlugin.cpp \
+           plugins/SimilarityPlugin.cpp \
+           plugins/TonalChangeDetect.cpp \
+           ./libmain.cpp
+

qm-vamp-plugins-1.7.tar.gz/g2cstubs.c Added

qm-vamp-plugins-1.7.tar.gz/libmain.cpp Added

@@ -0,0 +1,68 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#include <vamp/vamp.h>
+#include <vamp-sdk/PluginAdapter.h>
+
+#include "plugins/BeatTrack.h"
+#include "plugins/OnsetDetect.h"
+#include "plugins/ChromagramPlugin.h"
+#include "plugins/ConstantQSpectrogram.h"
+#include "plugins/TonalChangeDetect.h"
+#include "plugins/KeyDetect.h"
+#include "plugins/MFCCPlugin.h"
+#include "plugins/SegmenterPlugin.h"
+#include "plugins/SimilarityPlugin.h"
+#include "plugins/BarBeatTrack.h"
+#include "plugins/AdaptiveSpectrogram.h"
+#include "plugins/DWT.h"
+#include "plugins/Transcription.h"
+
+static Vamp::PluginAdapter<BeatTracker> beatTrackerAdapter;
+static Vamp::PluginAdapter<OnsetDetector> onsetDetectorAdapter;
+static Vamp::PluginAdapter<ChromagramPlugin> chromagramPluginAdapter;
+static Vamp::PluginAdapter<ConstantQSpectrogram> constantQAdapter;
+static Vamp::PluginAdapter<TonalChangeDetect> tonalChangeDetectorAdapter;
+static Vamp::PluginAdapter<KeyDetector> keyDetectorAdapter;
+static Vamp::PluginAdapter<MFCCPlugin> mfccPluginAdapter;
+static Vamp::PluginAdapter<SegmenterPlugin> segmenterPluginAdapter;
+static Vamp::PluginAdapter<SimilarityPlugin> similarityPluginAdapter;
+static Vamp::PluginAdapter<BarBeatTracker> barBeatTrackPluginAdapter;
+static Vamp::PluginAdapter<AdaptiveSpectrogram> adaptiveSpectrogramAdapter;
+static Vamp::PluginAdapter<DWT> dwtAdapter;
+static Vamp::PluginAdapter<Transcription> transcriptionAdapter;
+
+const VampPluginDescriptor *vampGetPluginDescriptor(unsigned int vampApiVersion,
+                                                    unsigned int index)
+{
+    if (vampApiVersion < 1) return 0;
+
+    switch (index) {
+    case  0: return beatTrackerAdapter.getDescriptor();
+    case  1: return onsetDetectorAdapter.getDescriptor();
+    case  2: return chromagramPluginAdapter.getDescriptor();
+    case  3: return constantQAdapter.getDescriptor();
+    case  4: return tonalChangeDetectorAdapter.getDescriptor();
+    case  5: return keyDetectorAdapter.getDescriptor();
+    case  6: return segmenterPluginAdapter.getDescriptor();
+    case  7: return similarityPluginAdapter.getDescriptor();
+    case  8: return mfccPluginAdapter.getDescriptor();
+    case  9: return barBeatTrackPluginAdapter.getDescriptor();
+    case 10: return dwtAdapter.getDescriptor();
+    case 11: return adaptiveSpectrogramAdapter.getDescriptor();
+    case 12: return transcriptionAdapter.getDescriptor();
+    default: return 0;
+    }
+}
+

qm-vamp-plugins-1.7.tar.gz/plugins Added

qm-vamp-plugins-1.7.tar.gz/plugins/AdaptiveSpectrogram.cpp Added

@@ -0,0 +1,539 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#include "AdaptiveSpectrogram.h"
+
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <cfloat>
+
+#include <iostream>
+
+#include <dsp/transforms/FFT.h>
+
+using std::string;
+using std::vector;
+using std::cerr;
+using std::endl;
+
+using Vamp::RealTime;
+
+//#define DEBUG_VERBOSE 1
+
+AdaptiveSpectrogram::AdaptiveSpectrogram(float inputSampleRate) :
+    Plugin(inputSampleRate),
+    m_w(8),
+    m_n(2),
+    m_coarse(false),
+    m_threaded(true),
+    m_threadsInUse(false)
+{
+}
+
+AdaptiveSpectrogram::~AdaptiveSpectrogram()
+{
+    for (int i = 0; i < m_cutThreads.size(); ++i) {
+        delete m_cutThreads[i];
+    }
+    m_cutThreads.clear();
+
+    for (FFTMap::iterator i = m_fftThreads.begin();
+         i != m_fftThreads.end(); ++i) {
+        delete i->second;
+    }
+    m_fftThreads.clear();
+}
+
+string
+AdaptiveSpectrogram::getIdentifier() const
+{
+    return "qm-adaptivespectrogram";
+}
+
+string
+AdaptiveSpectrogram::getName() const
+{
+    return "Adaptive Spectrogram";
+}
+
+string
+AdaptiveSpectrogram::getDescription() const
+{
+    return "Produce an adaptive spectrogram by adaptive selection from spectrograms at multiple resolutions";
+}
+
+string
+AdaptiveSpectrogram::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int
+AdaptiveSpectrogram::getPluginVersion() const
+{
+    return 1;
+}
+
+string
+AdaptiveSpectrogram::getCopyright() const
+{
+    return "Plugin by Wen Xue and Chris Cannam.  Copyright (c) 2009 Wen Xue and QMUL - All Rights Reserved";
+}
+
+size_t
+AdaptiveSpectrogram::getPreferredStepSize() const
+{
+    return ((2 << m_w) << m_n) / 2;
+}
+
+size_t
+AdaptiveSpectrogram::getPreferredBlockSize() const
+{
+    return (2 << m_w) << m_n;
+}
+
+bool
+AdaptiveSpectrogram::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+    if (channels < getMinChannelCount() ||
+	channels > getMaxChannelCount()) return false;
+
+    return true;
+}
+
+void
+AdaptiveSpectrogram::reset()
+{
+
+}
+
+AdaptiveSpectrogram::ParameterList
+AdaptiveSpectrogram::getParameterDescriptors() const
+{
+    ParameterList list;
+
+    ParameterDescriptor desc;
+    desc.identifier = "n";
+    desc.name = "Number of resolutions";
+    desc.description = "Number of consecutive powers of two in the range to be used as spectrogram resolutions, starting with the minimum resolution specified";
+    desc.unit = "";
+    desc.minValue = 2;
+    desc.maxValue = 10;
+    desc.defaultValue = 3;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    ParameterDescriptor desc2;
+    desc2.identifier = "w";
+    desc2.name = "Smallest resolution";
+    desc2.description = "Smallest of the consecutive powers of two to use as spectrogram resolutions";
+    desc2.unit = "";
+    desc2.minValue = 1;
+    desc2.maxValue = 14;
+    desc2.defaultValue = 9;
+    desc2.isQuantized = true;
+    desc2.quantizeStep = 1;
+    // I am so lazy
+    desc2.valueNames.push_back("2");
+    desc2.valueNames.push_back("4");
+    desc2.valueNames.push_back("8");
+    desc2.valueNames.push_back("16");
+    desc2.valueNames.push_back("32");
+    desc2.valueNames.push_back("64");
+    desc2.valueNames.push_back("128");
+    desc2.valueNames.push_back("256");
+    desc2.valueNames.push_back("512");
+    desc2.valueNames.push_back("1024");
+    desc2.valueNames.push_back("2048");
+    desc2.valueNames.push_back("4096");
+    desc2.valueNames.push_back("8192");
+    desc2.valueNames.push_back("16384");
+    list.push_back(desc2);
+
+    ParameterDescriptor desc3;
+    desc3.identifier = "coarse";
+    desc3.name = "Omit alternate resolutions";
+    desc3.description = "Generate a coarser spectrogram faster by excluding every alternate resolution (first and last resolution are always retained)";
+    desc3.unit = "";
+    desc3.minValue = 0;
+    desc3.maxValue = 1;
+    desc3.defaultValue = 0;
+    desc3.isQuantized = true;
+    desc3.quantizeStep = 1;
+    list.push_back(desc3);
+
+    desc3.identifier = "threaded";
+    desc3.name = "Multi-threaded processing";
+    desc3.description = "Perform calculations using several threads in parallel";
+    desc3.unit = "";
+    desc3.minValue = 0;
+    desc3.maxValue = 1;
+    desc3.defaultValue = 1;
+    desc3.isQuantized = true;
+    desc3.quantizeStep = 1;
+    list.push_back(desc3);
+
+    return list;
+}
+
+float
+AdaptiveSpectrogram::getParameter(std::string id) const
+{
+    if (id == "n") return m_n+1;
+    else if (id == "w") return m_w+1;
+    else if (id == "threaded") return (m_threaded ? 1 : 0);
+    else if (id == "coarse") return (m_coarse ? 1 : 0);
+    return 0.f;

qm-vamp-plugins-1.7.tar.gz/plugins/AdaptiveSpectrogram.h Added

@@ -0,0 +1,292 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#ifndef _ADAPTIVE_SPECTROGRAM_H_
+#define _ADAPTIVE_SPECTROGRAM_H_
+
+#include <vamp-sdk/Plugin.h>
+#include <cmath>
+#include <vector>
+
+#include <dsp/transforms/FFT.h>
+#include <base/Window.h>
+
+#include "thread/Thread.h"
+#include "thread/AsynchronousTask.h"
+#include "thread/BlockAllocator.h"
+
+class AdaptiveSpectrogram : public Vamp::Plugin
+{
+public:
+    AdaptiveSpectrogram(float inputSampleRate);
+    virtual ~AdaptiveSpectrogram();
+
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+    void reset();
+
+    InputDomain getInputDomain() const { return TimeDomain; }
+
+    std::string getIdentifier() const;
+    std::string getName() const;
+    std::string getDescription() const;
+    std::string getMaker() const;
+    int getPluginVersion() const;
+    std::string getCopyright() const;
+
+    size_t getPreferredStepSize() const;
+    size_t getPreferredBlockSize() const;
+
+    ParameterList getParameterDescriptors() const;
+    float getParameter(std::string id) const;
+    void setParameter(std::string id, float value);
+
+    OutputList getOutputDescriptors() const;
+
+    FeatureSet process(const float *const *inputBuffers,
+                       Vamp::RealTime timestamp);
+
+    FeatureSet getRemainingFeatures();
+
+protected:
+    int m_w;
+    int m_n;
+    bool m_coarse;
+    bool m_threaded;
+
+    struct Spectrogram
+    {
+        int resolution;
+        int width;
+        double **data;
+
+        Spectrogram(int r, int w) :
+            resolution(r), width(w) {
+            data = new double *[width];
+            for (int i = 0; i < width; ++i) data[i] = new double[resolution];
+        }
+
+        ~Spectrogram() {
+            for (int i = 0; i < width; ++i) delete[] data[i];
+            delete[] data;
+        }            
+    };
+
+    struct Spectrograms
+    {
+        int minres;
+        int maxres;
+        int n;
+        Spectrogram **spectrograms;
+
+        Spectrograms(int mn, int mx, int widthofmax) :
+            minres(mn), maxres(mx) {
+            n = log2(maxres/minres) + 1;
+            spectrograms = new Spectrogram *[n];
+            int r = mn;
+            for (int i = 0; i < n; ++i) {
+                spectrograms[i] = new Spectrogram(r, widthofmax * (mx / r));
+                r = r * 2;
+            }
+        }
+        ~Spectrograms() {
+            for (int i = 0; i < n; ++i) {
+                delete spectrograms[i];
+            }
+            delete[] spectrograms;
+        }
+    };
+
+    struct Cutting
+    {
+        enum Cut { Horizontal, Vertical, Finished };
+        Cut cut;
+        Cutting *first;
+        Cutting *second;
+        double cost;
+        double value;
+        BlockAllocator *allocator;
+
+        ~Cutting() {
+            if (first) first->erase();
+            if (second) second->erase();
+        }
+
+        void erase() {
+            if (allocator) {
+                if (first) first->erase();
+                if (second) second->erase();
+                allocator->deallocate(this);
+            } else {
+                delete this;
+            }
+        }
+    };
+
+    class FFTThread : public AsynchronousTask
+    {
+    public:
+        FFTThread(int w) :
+            m_window(HanningWindow, w) {
+            m_w = w;
+            m_fft = new FFTReal(m_w);
+            m_rin = new double[m_w];
+            m_rout = new double[m_w];
+            m_iout = new double[m_w];
+        }
+        ~FFTThread() {
+            delete[] m_rin;
+            delete[] m_rout;
+            delete[] m_iout;
+            delete m_fft;
+        }
+
+        int getW() const { return m_w; }
+
+        void startCalculation(const float *timeDomain, Spectrograms &s,
+                              int res, int maxwidth) {
+            setParameters(timeDomain, s, res, maxwidth);
+            startTask();
+        }
+
+        void await() {
+            awaitTask();
+        }
+
+        void setParameters(const float *timeDomain, Spectrograms &s,
+                           int res, int maxwidth) {
+            m_in = timeDomain;
+            m_s = &s;
+            m_res = res;
+            m_maxwid = maxwidth;
+        }
+
+        void performTask() {
+            for (int i = 0; i < m_maxwid / m_w; ++i) {
+                int origin = m_maxwid/4 - m_w/4; // for 50% overlap
+                for (int j = 0; j < m_w; ++j) {
+                    m_rin[j] = m_in[origin + i * m_w/2 + j];
+                }
+                m_window.cut(m_rin);
+                m_fft->process(false, m_rin, m_rout, m_iout);
+                for (int j = 0; j < m_w/2; ++j) {
+                    int k = j+1; // include Nyquist but not DC
+                    double mag = sqrt(m_rout[k] * m_rout[k] +
+                                      m_iout[k] * m_iout[k]);
+                    double scaled = mag / (m_w/2);
+                    m_s->spectrograms[m_res]->data[i][j] = scaled;
+                }
+            }
+        }
+
+    private:
+        Window<double> m_window;
+        FFTReal *m_fft;
+        const float *m_in;
+        double *m_rin;
+        double *m_rout;
+        double *m_iout;
+        Spectrograms *m_s;

qm-vamp-plugins-1.7.tar.gz/plugins/BarBeatTrack.cpp Added

@@ -0,0 +1,416 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#include "BarBeatTrack.h"
+
+#include <dsp/onsets/DetectionFunction.h>
+#include <dsp/onsets/PeakPicking.h>
+#include <dsp/tempotracking/TempoTrackV2.h>
+#include <dsp/tempotracking/DownBeat.h>
+#include <maths/MathUtilities.h>
+
+using std::string;
+using std::vector;
+using std::cerr;
+using std::endl;
+
+#ifndef __GNUC__
+#include <alloca.h>
+#endif
+
+float BarBeatTracker::m_stepSecs = 0.01161; // 512 samples at 44100
+
+class BarBeatTrackerData
+{
+public:
+    BarBeatTrackerData(float rate, const DFConfig &config) : dfConfig(config) {
+	df = new DetectionFunction(config);
+        // decimation factor aims at resampling to c. 3KHz; must be power of 2
+        int factor = MathUtilities::nextPowerOfTwo(rate / 3000);
+//        std::cerr << "BarBeatTrackerData: factor = " << factor << std::endl;
+        downBeat = new DownBeat(rate, factor, config.stepSize);
+    }
+    ~BarBeatTrackerData() {
+	delete df;
+        delete downBeat;
+    }
+    void reset() {
+	delete df;
+	df = new DetectionFunction(dfConfig);
+	dfOutput.clear();
+        downBeat->resetAudioBuffer();
+        origin = Vamp::RealTime::zeroTime;
+    }
+
+    DFConfig dfConfig;
+    DetectionFunction *df;
+    DownBeat *downBeat;
+    vector<double> dfOutput;
+    Vamp::RealTime origin;
+};
+    
+
+BarBeatTracker::BarBeatTracker(float inputSampleRate) :
+    Vamp::Plugin(inputSampleRate),
+    m_d(0),
+    m_bpb(4)
+{
+}
+
+BarBeatTracker::~BarBeatTracker()
+{
+    delete m_d;
+}
+
+string
+BarBeatTracker::getIdentifier() const
+{
+    return "qm-barbeattracker";
+}
+
+string
+BarBeatTracker::getName() const
+{
+    return "Bar and Beat Tracker";
+}
+
+string
+BarBeatTracker::getDescription() const
+{
+    return "Estimate bar and beat locations";
+}
+
+string
+BarBeatTracker::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int
+BarBeatTracker::getPluginVersion() const
+{
+    return 2;
+}
+
+string
+BarBeatTracker::getCopyright() const
+{
+    return "Plugin by Matthew Davies, Christian Landone and Chris Cannam.  Copyright (c) 2006-2009 QMUL - All Rights Reserved";
+}
+
+BarBeatTracker::ParameterList
+BarBeatTracker::getParameterDescriptors() const
+{
+    ParameterList list;
+
+    ParameterDescriptor desc;
+
+    desc.identifier = "bpb";
+    desc.name = "Beats per Bar";
+    desc.description = "The number of beats in each bar";
+    desc.minValue = 2;
+    desc.maxValue = 16;
+    desc.defaultValue = 4;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    return list;
+}
+
+float
+BarBeatTracker::getParameter(std::string name) const
+{
+    if (name == "bpb") return m_bpb;
+    return 0.0;
+}
+
+void
+BarBeatTracker::setParameter(std::string name, float value)
+{
+    if (name == "bpb") m_bpb = lrintf(value);
+}
+
+bool
+BarBeatTracker::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+    if (m_d) {
+	delete m_d;
+	m_d = 0;
+    }
+
+    if (channels < getMinChannelCount() ||
+	channels > getMaxChannelCount()) {
+        std::cerr << "BarBeatTracker::initialise: Unsupported channel count: "
+                  << channels << std::endl;
+        return false;
+    }
+
+    if (stepSize != getPreferredStepSize()) {
+        std::cerr << "ERROR: BarBeatTracker::initialise: Unsupported step size for this sample rate: "
+                  << stepSize << " (wanted " << (getPreferredStepSize()) << ")" << std::endl;
+        return false;
+    }
+
+    if (blockSize != getPreferredBlockSize()) {
+        std::cerr << "WARNING: BarBeatTracker::initialise: Sub-optimal block size for this sample rate: "
+                  << blockSize << " (wanted " << getPreferredBlockSize() << ")" << std::endl;
+//        return false;
+    }
+
+    DFConfig dfConfig;
+    dfConfig.DFType = DF_COMPLEXSD;
+    dfConfig.stepSize = stepSize;
+    dfConfig.frameLength = blockSize;
+    dfConfig.dbRise = 3;
+    dfConfig.adaptiveWhitening = false;
+    dfConfig.whiteningRelaxCoeff = -1;
+    dfConfig.whiteningFloor = -1;
+    
+    m_d = new BarBeatTrackerData(m_inputSampleRate, dfConfig);
+    m_d->downBeat->setBeatsPerBar(m_bpb);
+    return true;
+}
+
+void
+BarBeatTracker::reset()
+{
+    if (m_d) m_d->reset();
+}
+
+size_t
+BarBeatTracker::getPreferredStepSize() const
+{
+    size_t step = size_t(m_inputSampleRate * m_stepSecs + 0.0001);
+    if (step < 1) step = 1;
+//    std::cerr << "BarBeatTracker::getPreferredStepSize: input sample rate is " << m_inputSampleRate << ", step size is " << step << std::endl;
+    return step;
+}

qm-vamp-plugins-1.7.tar.gz/plugins/BarBeatTrack.h Added

@@ -0,0 +1,62 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#ifndef _BAR_BEAT_TRACK_PLUGIN_H_
+#define _BAR_BEAT_TRACK_PLUGIN_H_
+
+#include <vamp-sdk/Plugin.h>
+
+class BarBeatTrackerData;
+
+class BarBeatTracker : public Vamp::Plugin
+{
+public:
+    BarBeatTracker(float inputSampleRate);
+    virtual ~BarBeatTracker();
+
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+    void reset();
+
+    InputDomain getInputDomain() const { return TimeDomain; }
+
+    std::string getIdentifier() const;
+    std::string getName() const;
+    std::string getDescription() const;
+    std::string getMaker() const;
+    int getPluginVersion() const;
+    std::string getCopyright() const;
+
+    ParameterList getParameterDescriptors() const;
+    float getParameter(std::string) const;
+    void setParameter(std::string, float);
+
+    size_t getPreferredStepSize() const;
+    size_t getPreferredBlockSize() const;
+
+    OutputList getOutputDescriptors() const;
+
+    FeatureSet process(const float *const *inputBuffers,
+                       Vamp::RealTime timestamp);
+
+    FeatureSet getRemainingFeatures();
+
+protected:
+    BarBeatTrackerData *m_d;
+    static float m_stepSecs;
+    int m_bpb;
+    FeatureSet barBeatTrack();
+};
+
+
+#endif

qm-vamp-plugins-1.7.tar.gz/plugins/BeatTrack.cpp Added

@@ -0,0 +1,525 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#include "BeatTrack.h"
+
+#include <dsp/onsets/DetectionFunction.h>
+#include <dsp/onsets/PeakPicking.h>
+#include <dsp/tempotracking/TempoTrack.h>
+#include <dsp/tempotracking/TempoTrackV2.h>
+
+using std::string;
+using std::vector;
+using std::cerr;
+using std::endl;
+
+float BeatTracker::m_stepSecs = 0.01161; // 512 samples at 44100
+
+#define METHOD_OLD 0
+#define METHOD_NEW 1
+
+class BeatTrackerData
+{
+public:
+    BeatTrackerData(const DFConfig &config) : dfConfig(config) {
+	df = new DetectionFunction(config);
+    }
+    ~BeatTrackerData() {
+	delete df;
+    }
+    void reset() {
+	delete df;
+	df = new DetectionFunction(dfConfig);
+	dfOutput.clear();
+        origin = Vamp::RealTime::zeroTime;
+    }
+
+    DFConfig dfConfig;
+    DetectionFunction *df;
+    vector<double> dfOutput;
+    Vamp::RealTime origin;
+};
+    
+
+BeatTracker::BeatTracker(float inputSampleRate) :
+    Vamp::Plugin(inputSampleRate),
+    m_d(0),
+    m_method(METHOD_NEW),
+    m_dfType(DF_COMPLEXSD),
+    m_whiten(false)
+{
+}
+
+BeatTracker::~BeatTracker()
+{
+    delete m_d;
+}
+
+string
+BeatTracker::getIdentifier() const
+{
+    return "qm-tempotracker";
+}
+
+string
+BeatTracker::getName() const
+{
+    return "Tempo and Beat Tracker";
+}
+
+string
+BeatTracker::getDescription() const
+{
+    return "Estimate beat locations and tempo";
+}
+
+string
+BeatTracker::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int
+BeatTracker::getPluginVersion() const
+{
+    return 5;
+}
+
+string
+BeatTracker::getCopyright() const
+{
+    return "Plugin by Christian Landone and Matthew Davies.  Copyright (c) 2006-2009 QMUL - All Rights Reserved";
+}
+
+BeatTracker::ParameterList
+BeatTracker::getParameterDescriptors() const
+{
+    ParameterList list;
+
+    ParameterDescriptor desc;
+
+    desc.identifier = "method";
+    desc.name = "Beat Tracking Method";
+    desc.description = "Basic method to use ";
+    desc.minValue = 0;
+    desc.maxValue = 1;
+    desc.defaultValue = METHOD_NEW;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    desc.valueNames.push_back("Old");
+    desc.valueNames.push_back("New");
+    list.push_back(desc);
+
+    desc.identifier = "dftype";
+    desc.name = "Onset Detection Function Type";
+    desc.description = "Method used to calculate the onset detection function";
+    desc.minValue = 0;
+    desc.maxValue = 4;
+    desc.defaultValue = 3;
+    desc.valueNames.clear();
+    desc.valueNames.push_back("High-Frequency Content");
+    desc.valueNames.push_back("Spectral Difference");
+    desc.valueNames.push_back("Phase Deviation");
+    desc.valueNames.push_back("Complex Domain");
+    desc.valueNames.push_back("Broadband Energy Rise");
+    list.push_back(desc);
+
+    desc.identifier = "whiten";
+    desc.name = "Adaptive Whitening";
+    desc.description = "Normalize frequency bin magnitudes relative to recent peak levels";
+    desc.minValue = 0;
+    desc.maxValue = 1;
+    desc.defaultValue = 0;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    desc.unit = "";
+    desc.valueNames.clear();
+    list.push_back(desc);
+
+    return list;
+}
+
+float
+BeatTracker::getParameter(std::string name) const
+{
+    if (name == "dftype") {
+        switch (m_dfType) {
+        case DF_HFC: return 0;
+        case DF_SPECDIFF: return 1;
+        case DF_PHASEDEV: return 2;
+        default: case DF_COMPLEXSD: return 3;
+        case DF_BROADBAND: return 4;
+        }
+    } else if (name == "method") {
+        return m_method;
+    } else if (name == "whiten") {
+        return m_whiten ? 1.0 : 0.0; 
+    }
+    return 0.0;
+}
+
+void
+BeatTracker::setParameter(std::string name, float value)
+{
+    if (name == "dftype") {
+        switch (lrintf(value)) {
+        case 0: m_dfType = DF_HFC; break;
+        case 1: m_dfType = DF_SPECDIFF; break;
+        case 2: m_dfType = DF_PHASEDEV; break;
+        default: case 3: m_dfType = DF_COMPLEXSD; break;
+        case 4: m_dfType = DF_BROADBAND; break;
+        }
+    } else if (name == "method") {
+        m_method = lrintf(value);
+    } else if (name == "whiten") {
+        m_whiten = (value > 0.5);
+    }
+}
+
+bool
+BeatTracker::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+    if (m_d) {
+	delete m_d;
+	m_d = 0;
+    }
+
+    if (channels < getMinChannelCount() ||
+	channels > getMaxChannelCount()) {

qm-vamp-plugins-1.7.tar.gz/plugins/BeatTrack.h Added

@@ -0,0 +1,65 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#ifndef _BEAT_TRACK_PLUGIN_H_
+#define _BEAT_TRACK_PLUGIN_H_
+
+#include <vamp-sdk/Plugin.h>
+
+class BeatTrackerData;
+
+class BeatTracker : public Vamp::Plugin
+{
+public:
+    BeatTracker(float inputSampleRate);
+    virtual ~BeatTracker();
+
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+    void reset();
+
+    InputDomain getInputDomain() const { return FrequencyDomain; }
+
+    std::string getIdentifier() const;
+    std::string getName() const;
+    std::string getDescription() const;
+    std::string getMaker() const;
+    int getPluginVersion() const;
+    std::string getCopyright() const;
+
+    ParameterList getParameterDescriptors() const;
+    float getParameter(std::string) const;
+    void setParameter(std::string, float);
+
+    size_t getPreferredStepSize() const;
+    size_t getPreferredBlockSize() const;
+
+    OutputList getOutputDescriptors() const;
+
+    FeatureSet process(const float *const *inputBuffers,
+                       Vamp::RealTime timestamp);
+
+    FeatureSet getRemainingFeatures();
+
+protected:
+    BeatTrackerData *m_d;
+    int m_method;
+    int m_dfType;
+    bool m_whiten;
+    static float m_stepSecs;
+    FeatureSet beatTrackOld();
+    FeatureSet beatTrackNew();
+};
+
+
+#endif

qm-vamp-plugins-1.7.tar.gz/plugins/ChromagramPlugin.cpp Added

@@ -0,0 +1,416 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#include "ChromagramPlugin.h"
+
+#include <base/Pitch.h>
+#include <dsp/chromagram/Chromagram.h>
+
+using std::string;
+using std::vector;
+using std::cerr;
+using std::endl;
+
+ChromagramPlugin::ChromagramPlugin(float inputSampleRate) :
+    Vamp::Plugin(inputSampleRate),
+    m_chromagram(0),
+    m_step(0),
+    m_block(0)
+{
+    m_minMIDIPitch = 36;
+    m_maxMIDIPitch = 96;
+    m_tuningFrequency = 440;
+    m_normalise = MathUtilities::NormaliseNone;
+    m_bpo = 12;
+
+    setupConfig();
+}
+
+void
+ChromagramPlugin::setupConfig()
+{
+    m_config.FS = lrintf(m_inputSampleRate);
+    m_config.min = Pitch::getFrequencyForPitch
+        (m_minMIDIPitch, 0, m_tuningFrequency);
+    m_config.max = Pitch::getFrequencyForPitch
+        (m_maxMIDIPitch, 0, m_tuningFrequency);
+    m_config.BPO = m_bpo;
+    m_config.CQThresh = 0.0054;
+    m_config.normalise = m_normalise;
+
+    m_step = 0;
+    m_block = 0;
+}
+
+ChromagramPlugin::~ChromagramPlugin()
+{
+    delete m_chromagram;
+}
+
+string
+ChromagramPlugin::getIdentifier() const
+{
+    return "qm-chromagram";
+}
+
+string
+ChromagramPlugin::getName() const
+{
+    return "Chromagram";
+}
+
+string
+ChromagramPlugin::getDescription() const
+{
+    return "Extract a series of tonal chroma vectors from the audio";
+}
+
+string
+ChromagramPlugin::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int
+ChromagramPlugin::getPluginVersion() const
+{
+    return 4;
+}
+
+string
+ChromagramPlugin::getCopyright() const
+{
+    return "Plugin by Chris Cannam and Christian Landone.  Copyright (c) 2006-2009 QMUL - All Rights Reserved";
+}
+
+ChromagramPlugin::ParameterList
+ChromagramPlugin::getParameterDescriptors() const
+{
+    ParameterList list;
+
+    ParameterDescriptor desc;
+    desc.identifier = "minpitch";
+    desc.name = "Minimum Pitch";
+    desc.unit = "MIDI units";
+    desc.description = "MIDI pitch corresponding to the lowest frequency to be included in the chromagram";
+    desc.minValue = 0;
+    desc.maxValue = 127;
+    desc.defaultValue = 36;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    desc.identifier = "maxpitch";
+    desc.name = "Maximum Pitch";
+    desc.unit = "MIDI units";
+    desc.description = "MIDI pitch corresponding to the highest frequency to be included in the chromagram";
+    desc.minValue = 0;
+    desc.maxValue = 127;
+    desc.defaultValue = 96;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    desc.identifier = "tuning";
+    desc.name = "Tuning Frequency";
+    desc.unit = "Hz";
+    desc.description = "Frequency of concert A";
+    desc.minValue = 360;
+    desc.maxValue = 500;
+    desc.defaultValue = 440;
+    desc.isQuantized = false;
+    list.push_back(desc);
+    
+    desc.identifier = "bpo";
+    desc.name = "Bins per Octave";
+    desc.unit = "bins";
+    desc.description = "Number of constant-Q transform bins per octave, and the number of bins for the chromagram outputs";
+    desc.minValue = 2;
+    desc.maxValue = 480;
+    desc.defaultValue = 12;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    desc.identifier = "normalization";
+    desc.name = "Normalization";
+    desc.unit = "";
+    desc.description = "Normalization for each chromagram output column";
+    desc.minValue = 0;
+    desc.maxValue = 2;
+    desc.defaultValue = 0;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    desc.valueNames.push_back("None");
+    desc.valueNames.push_back("Unit Sum");
+    desc.valueNames.push_back("Unit Maximum");
+    list.push_back(desc);
+
+    return list;
+}
+
+float
+ChromagramPlugin::getParameter(std::string param) const
+{
+    if (param == "minpitch") {
+        return m_minMIDIPitch;
+    }
+    if (param == "maxpitch") {
+        return m_maxMIDIPitch;
+    }
+    if (param == "tuning") {
+        return m_tuningFrequency;
+    }
+    if (param == "bpo") {
+        return m_bpo;
+    }
+    if (param == "normalization") {
+        return int(m_normalise);
+    }
+    std::cerr << "WARNING: ChromagramPlugin::getParameter: unknown parameter \""
+              << param << "\"" << std::endl;
+    return 0.0;
+}
+
+void
+ChromagramPlugin::setParameter(std::string param, float value)
+{
+    if (param == "minpitch") {
+        m_minMIDIPitch = lrintf(value);
+    } else if (param == "maxpitch") {
+        m_maxMIDIPitch = lrintf(value);
+    } else if (param == "tuning") {
+        m_tuningFrequency = value;
+    } else if (param == "bpo") {
+        m_bpo = lrintf(value);
+    } else if (param == "normalization") {
+        m_normalise = MathUtilities::NormaliseType(int(value + 0.0001));
+    } else {

qm-vamp-plugins-1.7.tar.gz/plugins/ChromagramPlugin.h Added

@@ -0,0 +1,72 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#ifndef _CHROMAGRAM_PLUGIN_H_
+#define _CHROMAGRAM_PLUGIN_H_
+
+#include <vamp-sdk/Plugin.h>
+#include <dsp/chromagram/Chromagram.h>
+
+class ChromagramPlugin : public Vamp::Plugin
+{
+public:
+    ChromagramPlugin(float inputSampleRate);
+    virtual ~ChromagramPlugin();
+
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+    void reset();
+
+    InputDomain getInputDomain() const { return FrequencyDomain; }
+
+    std::string getIdentifier() const;
+    std::string getName() const;
+    std::string getDescription() const;
+    std::string getMaker() const;
+    int getPluginVersion() const;
+    std::string getCopyright() const;
+
+    ParameterList getParameterDescriptors() const;
+    float getParameter(std::string) const;
+    void setParameter(std::string, float);
+
+    size_t getPreferredStepSize() const;
+    size_t getPreferredBlockSize() const;
+
+    OutputList getOutputDescriptors() const;
+
+    FeatureSet process(const float *const *inputBuffers,
+                       Vamp::RealTime timestamp);
+
+    FeatureSet getRemainingFeatures();
+
+protected:
+    int m_minMIDIPitch;
+    int m_maxMIDIPitch;
+    float m_tuningFrequency;
+    MathUtilities::NormaliseType m_normalise;
+    int m_bpo;
+
+    void setupConfig();
+
+    ChromaConfig m_config;
+    Chromagram *m_chromagram;
+    mutable size_t m_step;
+    mutable size_t m_block;
+
+    vector<double> m_binsums;
+    size_t m_count;
+};
+
+
+#endif

qm-vamp-plugins-1.7.tar.gz/plugins/ConstantQSpectrogram.cpp Added

@@ -0,0 +1,394 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#include "ConstantQSpectrogram.h"
+
+#include <base/Pitch.h>
+#include <dsp/chromagram/ConstantQ.h>
+
+using std::string;
+using std::vector;
+using std::cerr;
+using std::endl;
+
+ConstantQSpectrogram::ConstantQSpectrogram(float inputSampleRate) :
+    Vamp::Plugin(inputSampleRate),
+    m_bins(1),
+    m_cq(0),
+    m_step(0),
+    m_block(0)
+{
+    m_minMIDIPitch = 36;
+    m_maxMIDIPitch = 84;
+    m_tuningFrequency = 440;
+    m_normalized = false;
+    m_bpo = 12;
+
+    setupConfig();
+}
+
+void
+ConstantQSpectrogram::setupConfig()
+{
+    m_config.FS = lrintf(m_inputSampleRate);
+    m_config.min = Pitch::getFrequencyForPitch
+        (m_minMIDIPitch, 0, m_tuningFrequency);
+    m_config.max = Pitch::getFrequencyForPitch
+        (m_maxMIDIPitch, 0, m_tuningFrequency);
+    m_config.BPO = m_bpo;
+    m_config.CQThresh = 0.0054;
+
+    m_step = 0;
+    m_block = 0;
+}
+
+ConstantQSpectrogram::~ConstantQSpectrogram()
+{
+    delete m_cq;
+}
+
+string
+ConstantQSpectrogram::getIdentifier() const
+{
+    return "qm-constantq";
+}
+
+string
+ConstantQSpectrogram::getName() const
+{
+    return "Constant-Q Spectrogram";
+}
+
+string
+ConstantQSpectrogram::getDescription() const
+{
+    return "Extract a spectrogram with constant ratio of centre frequency to resolution from the input audio";
+}
+
+string
+ConstantQSpectrogram::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int
+ConstantQSpectrogram::getPluginVersion() const
+{
+    return 3;
+}
+
+string
+ConstantQSpectrogram::getCopyright() const
+{
+    return "Plugin by Chris Cannam and Christian Landone.  Copyright (c) 2006-2009 QMUL - All Rights Reserved";
+}
+
+ConstantQSpectrogram::ParameterList
+ConstantQSpectrogram::getParameterDescriptors() const
+{
+    ParameterList list;
+
+    ParameterDescriptor desc;
+    desc.identifier = "minpitch";
+    desc.name = "Minimum Pitch";
+    desc.unit = "MIDI units";
+    desc.description = "MIDI pitch corresponding to the lowest frequency to be included in the constant-Q transform";
+    desc.minValue = 0;
+    desc.maxValue = 127;
+    desc.defaultValue = 36;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    desc.identifier = "maxpitch";
+    desc.name = "Maximum Pitch";
+    desc.unit = "MIDI units";
+    desc.description = "MIDI pitch corresponding to the highest frequency to be included in the constant-Q transform";
+    desc.minValue = 0;
+    desc.maxValue = 127;
+    desc.defaultValue = 84;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    desc.identifier = "tuning";
+    desc.name = "Tuning Frequency";
+    desc.unit = "Hz";
+    desc.description = "Frequency of concert A";
+    desc.minValue = 360;
+    desc.maxValue = 500;
+    desc.defaultValue = 440;
+    desc.isQuantized = false;
+    list.push_back(desc);
+    
+    desc.identifier = "bpo";
+    desc.name = "Bins per Octave";
+    desc.unit = "bins";
+    desc.description = "Number of constant-Q transform bins per octave";
+    desc.minValue = 2;
+    desc.maxValue = 480;
+    desc.defaultValue = 12;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    desc.identifier = "normalized";
+    desc.name = "Normalized";
+    desc.unit = "";
+    desc.description = "Whether to normalize each output column to unit maximum";
+    desc.minValue = 0;
+    desc.maxValue = 1;
+    desc.defaultValue = 0;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    return list;
+}
+
+float
+ConstantQSpectrogram::getParameter(std::string param) const
+{
+    if (param == "minpitch") {
+        return m_minMIDIPitch;
+    }
+    if (param == "maxpitch") {
+        return m_maxMIDIPitch;
+    }
+    if (param == "tuning") {
+        return m_tuningFrequency;
+    }
+    if (param == "bpo") {
+        return m_bpo;
+    }
+    if (param == "normalized") {
+        return m_normalized;
+    }
+    std::cerr << "WARNING: ConstantQSpectrogram::getParameter: unknown parameter \""
+              << param << "\"" << std::endl;
+    return 0.0;
+}
+
+void
+ConstantQSpectrogram::setParameter(std::string param, float value)
+{
+    if (param == "minpitch") {
+        m_minMIDIPitch = lrintf(value);
+    } else if (param == "maxpitch") {
+        m_maxMIDIPitch = lrintf(value);
+    } else if (param == "tuning") {
+        m_tuningFrequency = value;
+    } else if (param == "bpo") {
+        m_bpo = lrintf(value);
+    } else if (param == "normalized") {
+        m_normalized = (value > 0.0001);
+    } else {
+        std::cerr << "WARNING: ConstantQSpectrogram::setParameter: unknown parameter \""
+                  << param << "\"" << std::endl;
+    }

qm-vamp-plugins-1.7.tar.gz/plugins/ConstantQSpectrogram.h Added

@@ -0,0 +1,74 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#ifndef _CONSTANT_Q_SPECTROGRAM_PLUGIN_H_
+#define _CONSTANT_Q_SPECTROGRAM_PLUGIN_H_
+
+#include <vamp-sdk/Plugin.h>
+#include <dsp/chromagram/ConstantQ.h>
+
+#include <queue>
+
+class ConstantQSpectrogram : public Vamp::Plugin
+{
+public:
+    ConstantQSpectrogram(float inputSampleRate);
+    virtual ~ConstantQSpectrogram();
+
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+    void reset();
+
+    InputDomain getInputDomain() const { return FrequencyDomain; }
+
+    std::string getIdentifier() const;
+    std::string getName() const;
+    std::string getDescription() const;
+    std::string getMaker() const;
+    int getPluginVersion() const;
+    std::string getCopyright() const;
+
+    ParameterList getParameterDescriptors() const;
+    float getParameter(std::string) const;
+    void setParameter(std::string, float);
+
+    size_t getPreferredStepSize() const;
+    size_t getPreferredBlockSize() const;
+
+    OutputList getOutputDescriptors() const;
+
+    FeatureSet process(const float *const *inputBuffers,
+                       Vamp::RealTime timestamp);
+
+    FeatureSet getRemainingFeatures();
+
+protected:
+    int m_minMIDIPitch;
+    int m_maxMIDIPitch;
+    float m_tuningFrequency;
+    bool m_normalized;
+    int m_bpo;
+    int m_bins;
+
+    void setupConfig();
+
+    CQConfig m_config;
+    ConstantQ *m_cq;
+    mutable size_t m_step;
+    mutable size_t m_block;
+
+    Feature normalize(const Feature &);
+};
+
+
+#endif

qm-vamp-plugins-1.7.tar.gz/plugins/DWT.cpp Added

@@ -0,0 +1,448 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+  QM Vamp Plugin Set
+
+  Centre for Digital Music, Queen Mary, University of London.
+  This file copyright 2009 Thomas Wilmering.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#include "DWT.h"
+
+#include <cmath>
+
+using std::string;
+using std::vector;
+using std::cerr;
+using std::endl;
+
+DWT::DWT(float inputSampleRate) :
+    Plugin(inputSampleRate),
+    m_stepSize(0),
+    m_blockSize(0)
+{
+    m_scales = 10;
+    m_flength = 0;
+    m_wavelet = Wavelet::Haar;
+    m_threshold = 0;
+    m_absolute = 0;
+}
+
+DWT::~DWT()
+{
+}
+
+string
+DWT::getIdentifier() const
+{
+    return "qm-dwt";
+}
+
+string
+DWT::getName() const
+{
+    return "Discrete Wavelet Transform";
+}
+
+string
+DWT::getDescription() const
+{
+    return "Visualisation by scalogram";
+}
+
+string
+DWT::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int
+DWT::getPluginVersion() const
+{
+    return 1;
+}
+
+string
+DWT::getCopyright() const
+{
+    return "Plugin by Thomas Wilmering.  Copyright (c) 2009 Thomas Wilmering and QMUL - All Rights Reserved";
+}
+
+size_t 
+DWT::getPreferredBlockSize() const 
+{ 
+    size_t s = (1 << m_scales);
+    while (s < 1024) s *= 2;
+    return s;
+} 
+
+size_t 
+DWT::getPreferredStepSize() const 
+{ 
+    return 0;  
+} 
+
+bool
+DWT::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+    if (channels < getMinChannelCount() ||
+        channels > getMaxChannelCount()) return false;
+	
+    if ((1 << m_scales) > blockSize) {
+        std::cerr << "DWT::initialise: ERROR: Block size must be at least 2^scales (specified block size " << blockSize << " < " << (1 << m_scales) << ")" << std::endl;
+        return false;
+    }
+
+    m_stepSize = stepSize;
+    m_blockSize = blockSize;
+
+    Wavelet::createDecompositionFilters(m_wavelet, m_lpd, m_hpd);
+
+    m_flength = m_lpd.size(); // or m_hpd.size()
+	
+    m_samplePass.resize(m_scales);				// resize buffer for samples to pass to next block
+	
+    for (int i=0; i<m_scales; ++i) {
+        m_samplePass[i].resize(m_flength-2, 0.0);
+    }
+
+    return true;	
+}
+
+void
+DWT::reset()
+{
+    m_samplePass.clear();
+
+    m_samplePass.resize(m_scales);
+	
+    for (int i=0; i<m_scales; ++i) {
+        m_samplePass[i].resize(m_flength-2, 0.0);
+    }
+}
+
+DWT::OutputList
+DWT::getOutputDescriptors() const
+{
+    OutputList list;
+	
+    OutputDescriptor sg;
+    sg.identifier = "wcoeff";
+    sg.name = "Wavelet Coefficients";
+    sg.description = "Wavelet coefficients";
+    sg.unit = "";
+    sg.hasFixedBinCount = true;              // depends on block size
+    sg.binCount = m_scales; 	// number of scales
+    sg.hasKnownExtents = false;
+    sg.isQuantized = false;
+    sg.sampleType = OutputDescriptor::FixedSampleRate; 
+    sg.sampleRate = .5 * m_inputSampleRate;
+	
+    list.push_back(sg);
+	
+    return list;
+}
+
+
+DWT::ParameterList
+DWT::getParameterDescriptors() const
+{
+    ParameterList list;
+ 
+    ParameterDescriptor d;
+    d.identifier = "scales";
+    d.name = "Scales";
+    d.description = "Scale depth";
+    d.unit = "";
+    d.minValue = 1.0f;
+    d.maxValue = 16.0f;
+    d.defaultValue = 10.0f;
+    d.isQuantized = true;
+    d.quantizeStep = 1.0f;
+    list.push_back(d);
+ 
+    d.identifier = "wavelet";
+    d.name = "Wavelet";
+    d.description = "Wavelet type to use";
+    d.unit = "";
+    d.minValue = 0.f;
+    d.maxValue = int(Wavelet::LastType);
+    d.defaultValue = int(Wavelet::Haar);
+    d.isQuantized = true;
+    d.quantizeStep = 1.0f;
+
+    for (int i = 0; i <= int(Wavelet::LastType); ++i) {
+        d.valueNames.push_back(Wavelet::getWaveletName(Wavelet::Type(i)));
+    }
+    list.push_back(d);
+    d.valueNames.clear();
+
+    d.identifier = "threshold";
+    d.name = "Threshold";
+    d.description = "Wavelet coefficient threshold";
+    d.unit = "";
+    d.minValue = 0.0f;
+    d.maxValue = 0.01f;
+    d.defaultValue = 0.0f;
+    d.isQuantized = false;
+    list.push_back(d);
+
+    d.identifier = "absolute";
+    d.name = "Absolute values";
+    d.description = "Return absolute values";
+    d.unit = "";

qm-vamp-plugins-1.7.tar.gz/plugins/DWT.h Added

@@ -0,0 +1,73 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+  QM Vamp Plugin Set
+
+  Centre for Digital Music, Queen Mary, University of London.
+  This file copyright 2009 Thomas Wilmering.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#ifndef _DWT_PLUGIN_H_
+#define _DWT_PLUGIN_H_
+
+#include <vamp-sdk/Plugin.h>
+
+#include <dsp/wavelet/Wavelet.h>
+
+using std::vector;
+
+class DWT : public Vamp::Plugin
+{
+public:
+    DWT(float inputSampleRate);
+    virtual ~DWT();
+	
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+    void reset();
+	
+    InputDomain getInputDomain() const { return TimeDomain; }
+	
+    std::string getIdentifier() const;
+    std::string getName() const;
+    std::string getDescription() const;
+    std::string getMaker() const;
+    int getPluginVersion() const;
+    std::string getCopyright() const;
+    size_t getPreferredBlockSize() const;
+    size_t getPreferredStepSize() const;
+	
+    OutputList getOutputDescriptors() const;
+		
+    ParameterList getParameterDescriptors() const;
+    float getParameter(std::string paramid) const;
+    void setParameter(std::string paramid, float newval);
+	 	
+    FeatureSet process(const float *const *inputBuffers,
+                       Vamp::RealTime timestamp);
+	
+    FeatureSet getRemainingFeatures();
+	
+protected:
+    size_t m_stepSize;
+    size_t m_blockSize;
+    
+    int m_scales;
+    int m_flength;
+    Wavelet::Type m_wavelet;
+    float m_threshold;
+    float m_absolute;
+
+    vector<float> m_lpd;
+    vector<float> m_hpd;
+	
+    vector< vector<float> > m_samplePass;	
+};
+
+
+#endif

qm-vamp-plugins-1.7.tar.gz/plugins/KeyDetect.cpp Added

@@ -0,0 +1,407 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#include "KeyDetect.h"
+
+using std::string;
+using std::vector;
+//using std::cerr;
+using std::endl;
+
+#include <cmath>
+
+
+// Order for circle-of-5ths plotting
+static int conversion[24] =
+{ 7, 12, 5, 10, 3, 8, 1, 6, 11, 4, 9, 2,
+  16, 21, 14, 19, 24, 17, 22, 15, 20, 13, 18, 23 };
+
+
+KeyDetector::KeyDetector(float inputSampleRate) :
+    Plugin(inputSampleRate),
+    m_stepSize(0),
+    m_blockSize(0),
+    m_tuningFrequency(440),
+    m_length(10),
+    m_getKeyMode(0),
+    m_inputFrame(0),
+    m_prevKey(-1)
+{
+}
+
+KeyDetector::~KeyDetector()
+{
+    delete m_getKeyMode;
+    if ( m_inputFrame ) {
+        delete [] m_inputFrame;
+    }
+}
+
+string
+KeyDetector::getIdentifier() const
+{
+    return "qm-keydetector";
+}
+
+string
+KeyDetector::getName() const
+{
+    return "Key Detector";
+}
+
+string
+KeyDetector::getDescription() const
+{
+    return "Estimate the key of the music";
+}
+
+string
+KeyDetector::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int
+KeyDetector::getPluginVersion() const
+{
+    return 4;
+}
+
+string
+KeyDetector::getCopyright() const
+{
+    return "Plugin by Katy Noland and Christian Landone.  Copyright (c) 2006-2009 QMUL - All Rights Reserved";
+}
+
+KeyDetector::ParameterList
+KeyDetector::getParameterDescriptors() const
+{
+    ParameterList list;
+
+    ParameterDescriptor desc;
+    desc.identifier = "tuning";
+    desc.name = "Tuning Frequency";
+    desc.description = "Frequency of concert A";
+    desc.unit = "Hz";
+    desc.minValue = 420;
+    desc.maxValue = 460;
+    desc.defaultValue = 440;
+    desc.isQuantized = false;
+    list.push_back(desc);
+    
+    desc.identifier = "length";
+    desc.name = "Window Length";
+    desc.unit = "chroma frames";
+    desc.description = "Number of chroma analysis frames per key estimation";
+    desc.minValue = 1;
+    desc.maxValue = 30;
+    desc.defaultValue = 10;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    return list;
+}
+
+float
+KeyDetector::getParameter(std::string param) const
+{
+    if (param == "tuning") {
+        return m_tuningFrequency;
+    }
+    if (param == "length") {
+        return m_length;
+    }
+    std::cerr << "WARNING: KeyDetector::getParameter: unknown parameter \""
+              << param << "\"" << std::endl;
+    return 0.0;
+}
+
+void
+KeyDetector::setParameter(std::string param, float value)
+{
+    if (param == "tuning") {
+        m_tuningFrequency = value;
+    } else if (param == "length") {
+        m_length = int(value + 0.1);
+    } else {
+        std::cerr << "WARNING: KeyDetector::setParameter: unknown parameter \""
+                  << param << "\"" << std::endl;
+    }
+}
+
+bool
+KeyDetector::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+    if (m_getKeyMode) {
+        delete m_getKeyMode;
+        m_getKeyMode = 0;
+    }
+
+    if (channels < getMinChannelCount() ||
+	channels > getMaxChannelCount()) return false;
+
+    m_getKeyMode = new GetKeyMode(int(m_inputSampleRate + 0.1),
+                                  m_tuningFrequency,
+                                  m_length, m_length);
+
+    m_stepSize = m_getKeyMode->getHopSize();
+    m_blockSize = m_getKeyMode->getBlockSize();
+
+    if (stepSize != m_stepSize || blockSize != m_blockSize) {
+        std::cerr << "KeyDetector::initialise: ERROR: step/block sizes "
+                  << stepSize << "/" << blockSize << " differ from required "
+                  << m_stepSize << "/" << m_blockSize << std::endl;
+        delete m_getKeyMode;
+        m_getKeyMode = 0;
+        return false;
+    }
+
+    m_inputFrame = new double[m_blockSize];
+
+    m_prevKey = -1;
+    m_first = true;
+
+    return true;
+}
+
+void
+KeyDetector::reset()
+{
+    if (m_getKeyMode) {
+        delete m_getKeyMode;
+        m_getKeyMode = new GetKeyMode(int(m_inputSampleRate + 0.1),
+                                      m_tuningFrequency,
+                                      m_length, m_length);
+    }
+
+    if (m_inputFrame) {
+        for( unsigned int i = 0; i < m_blockSize; i++ ) {
+            m_inputFrame[ i ] = 0.0;
+        }
+    }
+
+    m_prevKey = -1;
+    m_first = true;
+}
+
+

qm-vamp-plugins-1.7.tar.gz/plugins/KeyDetect.h Added

@@ -0,0 +1,69 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#ifndef _GETMODE_PLUGIN_H_
+#define _GETMODE_PLUGIN_H_
+
+#include <vamp-sdk/Plugin.h>
+
+#include <dsp/keydetection/GetKeyMode.h>
+
+class KeyDetector : public Vamp::Plugin
+{
+public:
+    KeyDetector(float inputSampleRate);
+    virtual ~KeyDetector();
+
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+    void reset();
+
+    InputDomain getInputDomain() const { return TimeDomain; }
+
+    std::string getIdentifier() const;
+    std::string getName() const;
+    std::string getDescription() const;
+    std::string getMaker() const;
+    int getPluginVersion() const;
+    std::string getCopyright() const;
+
+    ParameterList getParameterDescriptors() const;
+    float getParameter(std::string) const;
+    void setParameter(std::string, float);
+
+    OutputList getOutputDescriptors() const;
+
+    FeatureSet process(const float *const *inputBuffers,
+                       Vamp::RealTime timestamp);
+
+    FeatureSet getRemainingFeatures();
+
+    size_t getPreferredStepSize() const;
+    size_t getPreferredBlockSize() const;
+
+protected:
+    mutable size_t m_stepSize;
+    mutable size_t m_blockSize;
+    float m_tuningFrequency;
+    int m_length;
+
+    std::string getKeyName(int index, bool minor, bool includeMajMin) const;
+
+    GetKeyMode* m_getKeyMode;
+    double* m_inputFrame;
+    int m_prevKey;
+    bool m_first;
+};
+
+
+#endif

qm-vamp-plugins-1.7.tar.gz/plugins/MFCCPlugin.cpp Added

@@ -0,0 +1,311 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#include "MFCCPlugin.h"
+
+#include <dsp/mfcc/MFCC.h>
+#include <maths/MathUtilities.h>
+
+using std::string;
+using std::vector;
+using std::cerr;
+using std::endl;
+
+MFCCPlugin::MFCCPlugin(float inputSampleRate) :
+    Vamp::Plugin(inputSampleRate),
+    m_config(lrintf(inputSampleRate)),
+    m_mfcc(0),
+    m_step(1024),
+    m_block(2048),
+    m_count(0)
+{
+    m_bins = 20;
+    m_wantC0 = true;
+    m_logpower = 1;
+
+    setupConfig();
+}
+
+void
+MFCCPlugin::setupConfig()
+{
+    m_config.FS = lrintf(m_inputSampleRate);
+    m_config.fftsize = m_block;
+    m_config.nceps = (m_wantC0 ? m_bins-1 : m_bins);
+    m_config.want_c0 = m_wantC0;
+    m_config.logpower = m_logpower;
+}
+
+MFCCPlugin::~MFCCPlugin()
+{
+    delete m_mfcc;
+}
+
+string
+MFCCPlugin::getIdentifier() const
+{
+    return "qm-mfcc";
+}
+
+string
+MFCCPlugin::getName() const
+{
+    return "Mel-Frequency Cepstral Coefficients";
+}
+
+string
+MFCCPlugin::getDescription() const
+{
+    return "Calculate a series of MFCC vectors from the audio";
+}
+
+string
+MFCCPlugin::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int
+MFCCPlugin::getPluginVersion() const
+{
+    return 1;
+}
+
+string
+MFCCPlugin::getCopyright() const
+{
+    return "Plugin by Nicolas Chetry and Chris Cannam.  Copyright (c) 2009 QMUL - All Rights Reserved";
+}
+
+MFCCPlugin::ParameterList
+MFCCPlugin::getParameterDescriptors() const
+{
+    ParameterList list;
+
+    ParameterDescriptor desc;
+    desc.identifier = "nceps";
+    desc.name = "Number of Coefficients";
+    desc.unit = "";
+    desc.description = "Number of MFCCs to return, starting from C0 if \"Include C0\" is specified or from C1 otherwise";
+    desc.minValue = 1;
+    desc.maxValue = 40;
+    desc.defaultValue = 20;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    desc.identifier = "logpower";
+    desc.name = "Power for Mel Amplitude Logs";
+    desc.unit = "";
+    desc.description = "Power to raise the amplitude log values to before applying DCT.  Values greater than 1 may reduce contribution of noise";
+    desc.minValue = 0;
+    desc.maxValue = 5;
+    desc.defaultValue = 1;
+    desc.isQuantized = false;
+    desc.quantizeStep = 0;
+    list.push_back(desc);
+
+    desc.identifier = "wantc0";
+    desc.name = "Include C0";
+    desc.unit = "";
+    desc.description = "Whether to include the C0 (energy level) coefficient in the returned results";
+    desc.minValue = 0;
+    desc.maxValue = 1;
+    desc.defaultValue = 1;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    return list;
+}
+
+float
+MFCCPlugin::getParameter(std::string param) const
+{
+    if (param == "nceps") {
+        return m_bins;
+    }
+    if (param == "logpower") {
+        return m_logpower;
+    }
+    if (param == "wantc0") {
+        return m_wantC0 ? 1 : 0;
+    }
+    std::cerr << "WARNING: MFCCPlugin::getParameter: unknown parameter \""
+              << param << "\"" << std::endl;
+    return 0.0;
+}
+
+void
+MFCCPlugin::setParameter(std::string param, float value)
+{
+    if (param == "nceps") {
+        m_bins = lrintf(value);
+    } else if (param == "logpower") {
+        m_logpower = lrintf(value);
+    } else if (param == "wantc0") {
+        m_wantC0 = (value > 0.5);
+    } else {
+        std::cerr << "WARNING: MFCCPlugin::setParameter: unknown parameter \""
+                  << param << "\"" << std::endl;
+    }
+
+    setupConfig();
+}
+
+bool
+MFCCPlugin::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+    if (m_mfcc) {
+	delete m_mfcc;
+	m_mfcc = 0;
+    }
+
+    if (channels < getMinChannelCount() ||
+	channels > getMaxChannelCount()) return false;
+
+//    std::cerr << "MFCCPlugin::initialise: step " << stepSize << ", block "
+//	      << blockSize << std::endl;
+
+    m_step = stepSize;
+    m_block = blockSize;
+    setupConfig();
+
+    m_mfcc = new MFCC(m_config);
+
+    m_binsums = vector<double>(m_bins);
+    for (int i = 0; i < m_bins; ++i) {
+        m_binsums[i] = 0.0;
+    }
+
+    return true;
+}
+
+void
+MFCCPlugin::reset()
+{
+    if (m_mfcc) {
+	delete m_mfcc;

qm-vamp-plugins-1.7.tar.gz/plugins/MFCCPlugin.h Added

@@ -0,0 +1,74 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#ifndef _MFCC_PLUGIN_H_
+#define _MFCC_PLUGIN_H_
+
+#include <vamp-sdk/Plugin.h>
+#include <dsp/mfcc/MFCC.h>
+
+#include <vector>
+
+class MFCCPlugin : public Vamp::Plugin
+{
+public:
+    MFCCPlugin(float inputSampleRate);
+    virtual ~MFCCPlugin();
+
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+    void reset();
+
+    InputDomain getInputDomain() const { return FrequencyDomain; }
+
+    std::string getIdentifier() const;
+    std::string getName() const;
+    std::string getDescription() const;
+    std::string getMaker() const;
+    int getPluginVersion() const;
+    std::string getCopyright() const;
+
+    ParameterList getParameterDescriptors() const;
+    float getParameter(std::string) const;
+    void setParameter(std::string, float);
+
+    size_t getPreferredStepSize() const;
+    size_t getPreferredBlockSize() const;
+
+    OutputList getOutputDescriptors() const;
+
+    FeatureSet process(const float *const *inputBuffers,
+                       Vamp::RealTime timestamp);
+
+    FeatureSet getRemainingFeatures();
+
+protected:
+    int m_bins; // == nceps is m_wantC0 false or nceps+1 if m_wantC0 true
+    bool m_wantC0;
+    float m_logpower;
+
+    void setupConfig();
+
+    MFCCConfig m_config;
+    MFCC *m_mfcc;
+    mutable size_t m_step;
+    mutable size_t m_block;
+
+    std::vector<double> m_binsums;
+    size_t m_count;
+
+    Feature normalize(const Feature &);
+};
+
+
+#endif

qm-vamp-plugins-1.7.tar.gz/plugins/OnsetDetect.cpp Added

@@ -0,0 +1,494 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#include "OnsetDetect.h"
+
+#include <dsp/onsets/DetectionFunction.h>
+#include <dsp/onsets/PeakPicking.h>
+#include <dsp/tempotracking/TempoTrack.h>
+
+using std::string;
+using std::vector;
+using std::cerr;
+using std::endl;
+
+float OnsetDetector::m_preferredStepSecs = 0.01161;
+
+class OnsetDetectorData
+{
+public:
+    OnsetDetectorData(const DFConfig &config) : dfConfig(config) {
+	df = new DetectionFunction(config);
+    }
+    ~OnsetDetectorData() {
+	delete df;
+    }
+    void reset() {
+	delete df;
+	df = new DetectionFunction(dfConfig);
+	dfOutput.clear();
+        origin = Vamp::RealTime::zeroTime;
+    }
+
+    DFConfig dfConfig;
+    DetectionFunction *df;
+    vector<double> dfOutput;
+    Vamp::RealTime origin;
+};
+    
+
+OnsetDetector::OnsetDetector(float inputSampleRate) :
+    Vamp::Plugin(inputSampleRate),
+    m_d(0),
+    m_dfType(DF_COMPLEXSD),
+    m_sensitivity(50),
+    m_whiten(false)
+{
+}
+
+OnsetDetector::~OnsetDetector()
+{
+    delete m_d;
+}
+
+string
+OnsetDetector::getIdentifier() const
+{
+    return "qm-onsetdetector";
+}
+
+string
+OnsetDetector::getName() const
+{
+    return "Note Onset Detector";
+}
+
+string
+OnsetDetector::getDescription() const
+{
+    return "Estimate individual note onset positions";
+}
+
+string
+OnsetDetector::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int
+OnsetDetector::getPluginVersion() const
+{
+    return 3;
+}
+
+string
+OnsetDetector::getCopyright() const
+{
+    return "Plugin by Christian Landone, Chris Duxbury and Juan Pablo Bello.  Copyright (c) 2006-2009 QMUL - All Rights Reserved";
+}
+
+OnsetDetector::ParameterList
+OnsetDetector::getParameterDescriptors() const
+{
+    ParameterList list;
+
+    ParameterDescriptor desc;
+    desc.identifier = "dftype";
+    desc.name = "Onset Detection Function Type";
+    desc.description = "Method used to calculate the onset detection function";
+    desc.minValue = 0;
+    desc.maxValue = 4;
+    desc.defaultValue = 3;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    desc.valueNames.push_back("High-Frequency Content");
+    desc.valueNames.push_back("Spectral Difference");
+    desc.valueNames.push_back("Phase Deviation");
+    desc.valueNames.push_back("Complex Domain");
+    desc.valueNames.push_back("Broadband Energy Rise");
+    list.push_back(desc);
+
+    desc.identifier = "sensitivity";
+    desc.name = "Onset Detector Sensitivity";
+    desc.description = "Sensitivity of peak-picker for onset detection";
+    desc.minValue = 0;
+    desc.maxValue = 100;
+    desc.defaultValue = 50;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    desc.unit = "%";
+    desc.valueNames.clear();
+    list.push_back(desc);
+
+    desc.identifier = "whiten";
+    desc.name = "Adaptive Whitening";
+    desc.description = "Normalize frequency bin magnitudes relative to recent peak levels";
+    desc.minValue = 0;
+    desc.maxValue = 1;
+    desc.defaultValue = 0;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    desc.unit = "";
+    list.push_back(desc);
+
+    return list;
+}
+
+float
+OnsetDetector::getParameter(std::string name) const
+{
+    if (name == "dftype") {
+        switch (m_dfType) {
+        case DF_HFC: return 0;
+        case DF_SPECDIFF: return 1;
+        case DF_PHASEDEV: return 2;
+        default: case DF_COMPLEXSD: return 3;
+        case DF_BROADBAND: return 4;
+        }
+    } else if (name == "sensitivity") {
+        return m_sensitivity;
+    } else if (name == "whiten") {
+        return m_whiten ? 1.0 : 0.0; 
+    }
+    return 0.0;
+}
+
+void
+OnsetDetector::setParameter(std::string name, float value)
+{
+    if (name == "dftype") {
+        int dfType = m_dfType;
+        switch (lrintf(value)) {
+        case 0: dfType = DF_HFC; break;
+        case 1: dfType = DF_SPECDIFF; break;
+        case 2: dfType = DF_PHASEDEV; break;
+        default: case 3: dfType = DF_COMPLEXSD; break;
+        case 4: dfType = DF_BROADBAND; break;
+        }
+        if (dfType == m_dfType) return;
+        m_dfType = dfType;
+        m_program = "";
+    } else if (name == "sensitivity") {
+        if (m_sensitivity == value) return;
+        m_sensitivity = value;
+        m_program = "";
+    } else if (name == "whiten") {
+        if (m_whiten == (value > 0.5)) return;
+        m_whiten = (value > 0.5);
+        m_program = "";
+    }
+}
+
+OnsetDetector::ProgramList
+OnsetDetector::getPrograms() const
+{
+    ProgramList programs;
+    programs.push_back("");
+    programs.push_back("General purpose");
+    programs.push_back("Soft onsets");

qm-vamp-plugins-1.7.tar.gz/plugins/OnsetDetect.h Added

qm-vamp-plugins-1.7.tar.gz/plugins/SegmenterPlugin.cpp Added

@@ -0,0 +1,323 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+ * SegmenterPlugin.cpp
+ *
+ * Created by Mark Levy on 24/03/2006.
+ * Copyright 2006 Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+ */
+
+#include <iostream>
+#include <sstream>
+
+#include "SegmenterPlugin.h"
+#include "dsp/segmentation/ClusterMeltSegmenter.h"
+
+using std::string;
+using std::vector;
+using std::cerr;
+using std::endl;
+using std::ostringstream;
+
+SegmenterPlugin::SegmenterPlugin(float inputSampleRate) :
+    Plugin(inputSampleRate),
+    segmenter(0),
+    nSegmentTypes(10),
+    neighbourhoodLimit(4),
+    featureType(feature_types(1))
+{
+	
+}
+
+SegmenterPlugin::~SegmenterPlugin()
+{
+    delete segmenter;
+}
+
+std::string SegmenterPlugin::getIdentifier() const
+{
+    return "qm-segmenter";
+}
+
+std::string SegmenterPlugin::getName() const
+{
+    return "Segmenter";
+}
+
+std::string SegmenterPlugin::getDescription() const
+{
+    return "Divide the track into a sequence of consistent segments";
+}
+
+string
+SegmenterPlugin::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int
+SegmenterPlugin::getPluginVersion() const
+{
+    return 2;
+}
+
+string
+SegmenterPlugin::getCopyright() const
+{
+    return "Plugin by Mark Levy.  Copyright (c) 2006-2009 QMUL - All Rights Reserved";
+}
+
+bool
+SegmenterPlugin::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+    if (channels < getMinChannelCount() ||
+	channels > getMaxChannelCount()) return false;
+
+    if (!segmenter) makeSegmenter();
+
+    if (stepSize != hopsize) {
+        std::cerr << "SegmenterPlugin::initialise: supplied step size "
+                  << stepSize << " differs from required step size " << hopsize
+                  << std::endl;
+        return false;
+    }
+
+    if (blockSize != windowsize) {
+        std::cerr << "SegmenterPlugin::initialise: supplied block size "
+                  << blockSize << " differs from required block size " << windowsize
+                  << std::endl;
+        return false;
+    }        
+		
+    return true;
+}
+
+void
+SegmenterPlugin::reset()
+{
+    // re-make segmenter only if it has already been made; otherwise
+    // there's nothing to reset
+    if (segmenter) makeSegmenter();
+}
+
+size_t
+SegmenterPlugin::getPreferredStepSize() const
+{
+    if (!segmenter) makeSegmenter();
+    return hopsize;
+}
+
+size_t
+SegmenterPlugin::getPreferredBlockSize() const
+{
+    if (!segmenter) makeSegmenter();
+    return windowsize;
+}
+
+SegmenterPlugin::ParameterList SegmenterPlugin::getParameterDescriptors() const
+{
+    ParameterList list;
+	
+    ParameterDescriptor desc;
+    desc.identifier = "nSegmentTypes";
+    desc.name = "Number of segment-types";
+    desc.description = "Maximum number of different kinds of segment to find";
+    desc.unit = "";
+    desc.minValue = 2;
+    desc.maxValue = 12;
+    desc.defaultValue = 10;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+	
+    ParameterDescriptor desc2;
+    desc2.identifier = "featureType";
+    desc2.name = "Feature Type";
+    desc2.description = "Try Chromatic for acoustic or pre-1980 recordings, otherwise use Hybrid";
+    desc2.unit = "";
+    desc2.minValue = 1;
+    desc2.maxValue = 3;
+    desc2.defaultValue = 1;
+    desc2.isQuantized = true;
+    desc2.quantizeStep = 1;
+    desc2.valueNames.push_back("Hybrid (Constant-Q)");
+    desc2.valueNames.push_back("Chromatic (Chroma)");
+    desc2.valueNames.push_back("Timbral (MFCC)");
+    list.push_back(desc2);	
+	
+    ParameterDescriptor desc3;
+    desc3.identifier = "neighbourhoodLimit";
+    desc3.name = "Minimum segment duration";
+    desc3.description = "Approximate expected minimum duration for each segment";
+    desc3.unit = "s";
+    desc3.minValue = 1;
+    desc3.maxValue = 15;
+    desc3.defaultValue = 4;
+    desc3.isQuantized = true;
+    desc3.quantizeStep = 0.2;
+    list.push_back(desc3);
+
+    return list;
+}
+
+float
+SegmenterPlugin::getParameter(std::string param) const
+{
+    if (param == "nSegmentTypes") {
+        return nSegmentTypes;
+    }
+	
+    if (param == "featureType") {
+        return featureType;
+    }
+
+    if (param == "neighbourhoodLimit") {
+        return neighbourhoodLimit;
+    }
+    
+    std::cerr << "WARNING: SegmenterPlugin::getParameter: unknown parameter \""
+              << param << "\"" << std::endl;
+    return 0.0;
+}
+
+void
+SegmenterPlugin::setParameter(std::string param, float value)
+{
+    if (param == "nSegmentTypes") {
+
+        nSegmentTypes = int(value + 0.0001);
+        return;
+    }
+
+    if (param == "featureType") {
+        if (featureType != feature_types(value)) // feature type changed, create a new segmenter

qm-vamp-plugins-1.7.tar.gz/plugins/SegmenterPlugin.h Added

@@ -0,0 +1,68 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+ * SegmenterPlugin.h
+ *
+ * Created by Mark Levy on 24/03/2006.
+ * Copyright 2006 Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+ */
+
+#ifndef _SEGMENTER_PLUGIN_H_
+#define _SEGMENTER_PLUGIN_H_
+
+#include <vamp-sdk/Plugin.h>
+#include <vamp-sdk/RealTime.h>
+#include "dsp/segmentation/Segmenter.h"
+#include "dsp/segmentation/segment.h"
+
+class Decimator;
+
+class SegmenterPlugin : public Vamp::Plugin
+{
+public:
+    SegmenterPlugin(float inputSampleRate);
+    virtual ~SegmenterPlugin();
+	
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+    void reset();
+	
+    std::string getIdentifier() const;
+    std::string getName() const;
+    std::string getDescription() const;
+    std::string getMaker() const;
+    int getPluginVersion() const;
+    std::string getCopyright() const;
+	
+    size_t getPreferredStepSize() const;
+    size_t getPreferredBlockSize() const;
+    InputDomain getInputDomain() const { return TimeDomain; }
+    
+    SegmenterPlugin::ParameterList getParameterDescriptors() const;
+    float getParameter(std::string param) const;
+    void setParameter(std::string param, float value);
+    
+    OutputList getOutputDescriptors() const;
+    
+    FeatureSet process(const float *const *inputBuffers, Vamp::RealTime timestamp);
+    
+    FeatureSet getRemainingFeatures();
+	
+protected:
+    mutable Segmenter* segmenter;
+    mutable int hopsize;
+    mutable int windowsize;
+    mutable float neighbourhoodLimit; // in sec
+    int nSegmentTypes;
+    feature_types featureType;	// 1 = constant-Q, 2 = chroma
+    
+    void makeSegmenter() const;
+};
+
+#endif
+

qm-vamp-plugins-1.7.tar.gz/plugins/SimilarityPlugin.cpp Added

@@ -0,0 +1,939 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+ * SimilarityPlugin.cpp
+ *
+ * Copyright 2009 Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+ */
+
+#include <iostream>
+#include <cstdio>
+
+#include "SimilarityPlugin.h"
+#include "base/Pitch.h"
+#include "dsp/mfcc/MFCC.h"
+#include "dsp/chromagram/Chromagram.h"
+#include "dsp/rateconversion/Decimator.h"
+#include "dsp/rhythm/BeatSpectrum.h"
+#include "maths/KLDivergence.h"
+#include "maths/CosineDistance.h"
+#include "maths/MathUtilities.h"
+
+using std::string;
+using std::vector;
+using std::cerr;
+using std::endl;
+using std::ostringstream;
+
+const float
+SimilarityPlugin::m_noRhythm = 0.009;
+
+const float
+SimilarityPlugin::m_allRhythm = 0.991;
+
+SimilarityPlugin::SimilarityPlugin(float inputSampleRate) :
+    Plugin(inputSampleRate),
+    m_type(TypeMFCC),
+    m_mfcc(0),
+    m_rhythmfcc(0),
+    m_chromagram(0),
+    m_decimator(0),
+    m_featureColumnSize(20),
+    m_rhythmWeighting(0.5f),
+    m_rhythmClipDuration(4.f), // seconds
+    m_rhythmClipOrigin(40.f), // seconds
+    m_rhythmClipFrameSize(0),
+    m_rhythmClipFrames(0),
+    m_rhythmColumnSize(20),
+    m_blockSize(0),
+    m_channels(0),
+    m_processRate(0),
+    m_frameNo(0),
+    m_done(false)
+{
+    int rate = lrintf(m_inputSampleRate);
+    int internalRate = 22050;
+    int decimationFactor = rate / internalRate;
+    if (decimationFactor < 1) decimationFactor = 1;
+
+    // must be a power of two
+    while (decimationFactor & (decimationFactor - 1)) ++decimationFactor;
+
+    m_processRate = rate / decimationFactor; // may be 22050, 24000 etc
+}
+
+SimilarityPlugin::~SimilarityPlugin()
+{
+    delete m_mfcc;
+    delete m_rhythmfcc;
+    delete m_chromagram;
+    delete m_decimator;
+}
+
+string
+SimilarityPlugin::getIdentifier() const
+{
+    return "qm-similarity";
+}
+
+string
+SimilarityPlugin::getName() const
+{
+    return "Similarity";
+}
+
+string
+SimilarityPlugin::getDescription() const
+{
+    return "Return a distance matrix for similarity between the input audio channels";
+}
+
+string
+SimilarityPlugin::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int
+SimilarityPlugin::getPluginVersion() const
+{
+    return 1;
+}
+
+string
+SimilarityPlugin::getCopyright() const
+{
+    return "Plugin by Mark Levy, Kurt Jacobson and Chris Cannam.  Copyright (c) 2009 QMUL - All Rights Reserved";
+}
+
+size_t
+SimilarityPlugin::getMinChannelCount() const
+{
+    return 1;
+}
+
+size_t
+SimilarityPlugin::getMaxChannelCount() const
+{
+    return 1024;
+}
+
+int
+SimilarityPlugin::getDecimationFactor() const
+{
+    int rate = lrintf(m_inputSampleRate);
+    return rate / m_processRate;
+}
+
+size_t
+SimilarityPlugin::getPreferredStepSize() const
+{
+    if (m_blockSize == 0) calculateBlockSize();
+
+    // there is also an assumption to this effect in process()
+    // (referring to m_fftSize/2 instead of a literal post-decimation
+    // step size):
+    return m_blockSize/2;
+}
+
+size_t
+SimilarityPlugin::getPreferredBlockSize() const
+{
+    if (m_blockSize == 0) calculateBlockSize();
+    return m_blockSize;
+}
+
+void
+SimilarityPlugin::calculateBlockSize() const
+{
+    if (m_blockSize != 0) return;
+    int decimationFactor = getDecimationFactor();
+    m_blockSize = 2048 * decimationFactor;
+}
+
+SimilarityPlugin::ParameterList SimilarityPlugin::getParameterDescriptors() const
+{
+    ParameterList list;
+
+    ParameterDescriptor desc;
+    desc.identifier = "featureType";
+    desc.name = "Feature Type";
+    desc.description = "Audio feature used for similarity measure.  Timbral: use the first 20 MFCCs (19 plus C0).  Chromatic: use 12 bin-per-octave chroma.  Rhythmic: compare beat spectra of short regions.";
+    desc.unit = "";
+    desc.minValue = 0;
+    desc.maxValue = 4;
+    desc.defaultValue = 1;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    desc.valueNames.push_back("Timbre");
+    desc.valueNames.push_back("Timbre and Rhythm");
+    desc.valueNames.push_back("Chroma");
+    desc.valueNames.push_back("Chroma and Rhythm");
+    desc.valueNames.push_back("Rhythm only");
+    list.push_back(desc);	
+/*
+    desc.identifier = "rhythmWeighting";
+    desc.name = "Influence of Rhythm";
+    desc.description = "Proportion of similarity measure made up from rhythmic similarity component, from 0 (entirely timbral or chromatic) to 100 (entirely rhythmic).";
+    desc.unit = "%";
+    desc.minValue = 0;
+    desc.maxValue = 100;
+    desc.defaultValue = 0;
+    desc.isQuantized = false;
+    desc.valueNames.clear();
+    list.push_back(desc);	
+*/
+    return list;
+}
+
+float
+SimilarityPlugin::getParameter(std::string param) const
+{
+    if (param == "featureType") {
+

qm-vamp-plugins-1.7.tar.gz/plugins/SimilarityPlugin.h Added

@@ -0,0 +1,123 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+ * SimilarityPlugin.h
+ *
+ * Copyright 2008 Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+ */
+
+#ifndef _SIMILARITY_PLUGIN_H_
+#define _SIMILARITY_PLUGIN_H_
+
+#include <vamp-sdk/Plugin.h>
+#include <vamp-sdk/RealTime.h>
+
+#include <vector>
+#include <deque>
+
+class MFCC;
+class Chromagram;
+class Decimator;
+
+class SimilarityPlugin : public Vamp::Plugin
+{
+public:
+    SimilarityPlugin(float inputSampleRate);
+    virtual ~SimilarityPlugin();
+	
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+    void reset();
+	
+    std::string getIdentifier() const;
+    std::string getName() const;
+    std::string getDescription() const;
+    std::string getMaker() const;
+    int getPluginVersion() const;
+    std::string getCopyright() const;
+	
+    size_t getPreferredStepSize() const;
+    size_t getPreferredBlockSize() const;
+    InputDomain getInputDomain() const { return TimeDomain; }
+    
+    size_t getMinChannelCount() const;
+    size_t getMaxChannelCount() const;
+
+    SimilarityPlugin::ParameterList getParameterDescriptors() const;
+    float getParameter(std::string param) const;
+    void setParameter(std::string param, float value);
+    
+    OutputList getOutputDescriptors() const;
+    
+    FeatureSet process(const float *const *inputBuffers, Vamp::RealTime timestamp);
+    
+    FeatureSet getRemainingFeatures();
+	
+protected:
+    int getDecimationFactor() const;
+    
+    enum Type {
+        TypeMFCC,
+        TypeChroma
+    };
+
+    void calculateBlockSize() const;
+    bool needRhythm() const { return m_rhythmWeighting > m_noRhythm; }
+    bool needTimbre() const { return m_rhythmWeighting < m_allRhythm; }
+
+    Type m_type;
+    MFCC *m_mfcc;
+    MFCC *m_rhythmfcc;
+    Chromagram *m_chromagram;
+    Decimator *m_decimator;
+    int m_featureColumnSize;
+    float m_rhythmWeighting;
+    float m_rhythmClipDuration;
+    float m_rhythmClipOrigin;
+    int m_rhythmClipFrameSize;
+    int m_rhythmClipFrames;
+    int m_rhythmColumnSize;
+    mutable size_t m_blockSize; // before decimation
+    size_t m_fftSize; // after decimation
+    int m_channels;
+    int m_processRate;
+    int m_frameNo;
+    bool m_done;
+
+    static const float m_noRhythm;
+    static const float m_allRhythm;
+
+    std::vector<int> m_lastNonEmptyFrame; // per channel
+    std::vector<int> m_emptyFrameCount; // per channel
+
+    mutable int m_distanceMatrixOutput;
+    mutable int m_distanceVectorOutput;
+    mutable int m_sortedVectorOutput;
+    mutable int m_meansOutput;
+    mutable int m_variancesOutput;
+    mutable int m_beatSpectraOutput;
+
+    typedef std::vector<double> FeatureColumn;
+    typedef std::vector<FeatureColumn> FeatureMatrix;
+    typedef std::vector<FeatureMatrix> FeatureMatrixSet;
+
+    typedef std::deque<FeatureColumn> FeatureColumnQueue;
+    typedef std::vector<FeatureColumnQueue> FeatureQueueSet;
+
+    FeatureMatrixSet m_values;
+    FeatureQueueSet m_rhythmValues;
+
+    FeatureMatrix calculateTimbral(FeatureSet &returnFeatures);
+    FeatureMatrix calculateRhythmic(FeatureSet &returnFeatures);
+    double getDistance(const FeatureMatrix &timbral,
+                       const FeatureMatrix &rhythmic,
+                       int i, int j);
+};
+
+#endif
+

qm-vamp-plugins-1.7.tar.gz/plugins/TonalChangeDetect.cpp Added

@@ -0,0 +1,443 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#include "TonalChangeDetect.h"
+
+#include <base/Pitch.h>
+#include <dsp/chromagram/Chromagram.h>
+#include <dsp/tonal/ChangeDetectionFunction.h>
+
+TonalChangeDetect::TonalChangeDetect(float fInputSampleRate)	
+    : Vamp::Plugin(fInputSampleRate),
+      m_chromagram(0),
+      m_step(0),
+      m_block(0),
+      m_stepDelay(0),
+      m_origin(Vamp::RealTime::zeroTime),
+      m_haveOrigin(false)
+{
+    m_minMIDIPitch = 32;
+    m_maxMIDIPitch = 108;
+    m_tuningFrequency = 440;	
+    m_iSmoothingWidth = 5;
+
+    setupConfig();
+}
+
+TonalChangeDetect::~TonalChangeDetect()
+{
+}
+
+bool TonalChangeDetect::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+    if (m_chromagram) {
+        delete m_chromagram;
+        m_chromagram = 0;
+    }
+	
+    if (channels < getMinChannelCount() ||
+        channels > getMaxChannelCount()) {
+        std::cerr << "TonalChangeDetect::initialise: Given channel count " << channels << " outside acceptable range (" << getMinChannelCount() << " to " << getMaxChannelCount() << ")" << std::endl;
+        return false;
+    }
+
+    m_chromagram = new Chromagram(m_config);
+    m_step = m_chromagram->getHopSize();
+    m_block = m_chromagram->getFrameSize();
+
+    if (stepSize != m_step) {
+        std::cerr << "TonalChangeDetect::initialise: Given step size " << stepSize << " differs from only acceptable value " << m_step << std::endl;
+        delete m_chromagram;
+        m_chromagram = 0;
+        return false;
+    }
+    if (blockSize != m_block) {
+        std::cerr << "TonalChangeDetect::initialise: Given step size " << stepSize << " differs from only acceptable value " << m_step << std::endl;
+        delete m_chromagram;
+        m_chromagram = 0;
+        return false;
+    }
+	
+    //    m_stepDelay = (blockSize - stepSize) / 2;
+    //    m_stepDelay = m_stepDelay / stepSize;
+    m_stepDelay = (blockSize - stepSize) / stepSize; //!!! why? seems about right to look at, but...
+	
+//    std::cerr << "TonalChangeDetect::initialise: step " << stepSize << ", block "
+//              << blockSize << ", delay " << m_stepDelay << std::endl;
+	
+    m_vaCurrentVector.resize(12, 0.0);
+	
+    return true;
+	
+}
+
+std::string TonalChangeDetect::getIdentifier() const
+{
+    return "qm-tonalchange";
+}
+
+std::string TonalChangeDetect::getName() const
+{
+    return "Tonal Change";
+}
+
+std::string TonalChangeDetect::getDescription() const
+{
+    return "Detect and return the positions of harmonic changes such as chord boundaries";
+}
+
+std::string TonalChangeDetect::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int TonalChangeDetect::getPluginVersion() const
+{
+    return 2;
+}
+
+std::string TonalChangeDetect::getCopyright() const
+{
+    return "Plugin by Martin Gasser and Christopher Harte.  Copyright (c) 2006-2009 QMUL - All Rights Reserved";
+}
+
+TonalChangeDetect::ParameterList TonalChangeDetect::getParameterDescriptors() const
+{
+    ParameterList list;
+
+    ParameterDescriptor desc;
+    desc.identifier = "smoothingwidth";
+    desc.name = "Gaussian smoothing";
+    desc.description = "Window length for the internal smoothing operation, in chroma analysis frames";
+    desc.unit = "frames";
+    desc.minValue = 0;
+    desc.maxValue = 20;
+    desc.defaultValue = 5;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    desc.identifier = "minpitch";
+    desc.name = "Chromagram minimum pitch";
+    desc.unit = "MIDI units";
+    desc.description = "Lowest pitch in MIDI units to be included in the chroma analysis";
+    desc.minValue = 0;
+    desc.maxValue = 127;
+    desc.defaultValue = 32;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    desc.identifier = "maxpitch";
+    desc.name = "Chromagram maximum pitch";
+    desc.unit = "MIDI units";
+    desc.description = "Highest pitch in MIDI units to be included in the chroma analysis";
+    desc.minValue = 0;
+    desc.maxValue = 127;
+    desc.defaultValue = 108;
+    desc.isQuantized = true;
+    desc.quantizeStep = 1;
+    list.push_back(desc);
+
+    desc.identifier = "tuning";
+    desc.name = "Chromagram tuning frequency";
+    desc.unit = "Hz";
+    desc.description = "Frequency of concert A in the music under analysis";
+    desc.minValue = 420;
+    desc.maxValue = 460;
+    desc.defaultValue = 440;
+    desc.isQuantized = false;
+    list.push_back(desc);
+
+    return list;
+}
+
+float
+TonalChangeDetect::getParameter(std::string param) const
+{
+    if (param == "smoothingwidth") {
+        return m_iSmoothingWidth;
+    }
+    if (param == "minpitch") {
+        return m_minMIDIPitch;
+    }
+    if (param == "maxpitch") {
+        return m_maxMIDIPitch;
+    }
+    if (param == "tuning") {
+        return m_tuningFrequency;
+    }
+
+    std::cerr << "WARNING: ChromagramPlugin::getParameter: unknown parameter \""
+              << param << "\"" << std::endl;
+    return 0.0;
+}
+
+void
+TonalChangeDetect::setParameter(std::string param, float value)
+{
+    if (param == "minpitch") {
+        m_minMIDIPitch = lrintf(value);
+    } else if (param == "maxpitch") {
+        m_maxMIDIPitch = lrintf(value);
+    } else if (param == "tuning") {
+        m_tuningFrequency = value;
+    }
+    else if (param == "smoothingwidth") {
+        m_iSmoothingWidth = int(value);
+    } else {

qm-vamp-plugins-1.7.tar.gz/plugins/TonalChangeDetect.h Added

@@ -0,0 +1,84 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+    QM Vamp Plugin Set
+
+    Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+#ifndef _TONALCHANGEDETECT_
+#define _TONALCHANGEDETECT_
+
+#include <vamp-sdk/Plugin.h>
+
+#include <dsp/chromagram/Chromagram.h>
+#include <dsp/tonal/TonalEstimator.h>
+#include <dsp/tonal/TCSgram.h>
+
+#include <queue>
+#include <vector>
+#include <valarray>
+
+class TonalChangeDetect : public Vamp::Plugin
+{
+public:
+	TonalChangeDetect(float fInputSampleRate);
+	virtual ~TonalChangeDetect();
+
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+    void reset();
+
+    InputDomain getInputDomain() const { return TimeDomain; }
+
+    std::string getIdentifier() const;
+    std::string getName() const;
+    std::string getDescription() const;
+    std::string getMaker() const;
+    int getPluginVersion() const;
+    std::string getCopyright() const;
+
+    ParameterList getParameterDescriptors() const;
+    float getParameter(std::string) const;
+    void setParameter(std::string, float);
+
+
+    size_t getPreferredStepSize() const;
+    size_t getPreferredBlockSize() const;
+
+    OutputList getOutputDescriptors() const;
+
+    FeatureSet process(const float *const *inputBuffers,
+                       Vamp::RealTime timestamp);
+
+    FeatureSet getRemainingFeatures();
+	
+private:
+    void setupConfig();
+
+    ChromaConfig m_config;
+    Chromagram *m_chromagram;
+    TonalEstimator m_TonalEstimator;
+    mutable size_t m_step;
+    mutable size_t m_block;
+    size_t m_stepDelay;
+    std::queue<ChromaVector> m_pending;
+    ChromaVector m_vaCurrentVector;
+    TCSGram m_TCSGram;
+	
+    int m_iSmoothingWidth;  // smoothing window size
+    int m_minMIDIPitch;     // chromagram parameters
+    int m_maxMIDIPitch;
+    float m_tuningFrequency;
+
+    Vamp::RealTime m_origin;
+    bool m_haveOrigin;
+};
+
+
+#endif // _TONALCHANGEDETECT_

qm-vamp-plugins-1.7.tar.gz/plugins/Transcription.cpp Added

@@ -0,0 +1,2117 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+  QM Vamp Plugin Set
+
+  Centre for Digital Music, Queen Mary, University of London.
+
+    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.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+/*transcription vamp plugin: Ruohua Zhou, Josh Reiss, josh.reiss@elec.qmul.ac.uk */
+
+#include "Transcription.h"
+#include <vamp-sdk/PluginAdapter.h>
+#include <math.h>
+#include <stdlib.h>
+
+using std::string;
+using std::vector;
+using std::cerr;
+using std::endl;
+
+const double CNum[8] = {
+    3.025328153863e-005,0.0002117729707704,0.0006353189123113, 0.001058864853852,
+    0.001058864853852,0.0006353189123113,0.0002117729707704,3.025328153863e-005
+};
+
+const double CDen[8] = {
+    1,   -4.647847898799,    9.540784706769,   -11.14354542746,
+    7.967285533211,   -3.477244449085,   0.8559660579522, -0.09152610255505
+};
+  
+const int A[10] = {0, 120, 190, 240, 279, 310, 337, 360, 380, 399};
+
+
+
+const double EualCurve960[960] = {
+    83.750025,83.532690,83.315770,83.099260,82.883159,82.667463,82.452170,82.237276,82.022779,81.808675,
+    81.594963,81.381639,81.168699,80.956142,80.743964,80.532163,80.320735,80.109677,79.898987,79.688663,79.478700,79.269096,79.059848,78.850953,
+    78.642408,78.434211,78.226359,78.018848,77.811676,77.604839,77.398336,77.192162,76.986316,76.780794,76.575593,76.370710,76.166143,75.961889,
+    75.757945,75.554307,75.350973,75.147940,74.945205,74.742766,74.540618,74.338761,74.137189,73.935902,73.734895,73.534166,73.333712,73.133529,
+    72.933616,72.733970,72.534586,72.335463,72.136598,71.937987,71.739628,71.541517,71.343653,71.146032,70.948650,70.751506,70.554597,70.357919,
+    70.161469,69.965245,69.769244,69.573462,69.377898,69.182548,68.987408,68.792477,68.597752,68.403228,68.208905,68.014781,67.820873,67.627197,
+    67.433772,67.240617,67.047749,66.855187,66.662949,66.471053,66.279516,66.088358,65.897597,65.707250,65.517336,65.327873,65.138879,64.950373,
+    64.762372,64.574894,64.387959,64.201583,64.015785,63.830584,63.645997,63.462043,63.278739,63.096105,62.914158,62.732915,62.552397,62.372620,
+    62.193602,62.015363,61.837920,61.661291,61.485494,61.310549,61.136471,60.963274,60.790941,60.619447,60.448770,60.278885,60.109770,59.941401,
+    59.773755,59.606807,59.440536,59.274916,59.109924,58.945538,58.781733,58.618486,58.455773,58.293572,58.131858,57.970608,57.809799,57.649407,
+    57.489408,57.329780,57.170498,57.011539,56.852880,56.694496,56.536366,56.378464,56.220768,56.063255,55.905900,55.748680,55.591571,55.434551,
+    55.277595,55.120681,54.963784,54.806886,54.649983,54.493077,54.336169,54.179261,54.022353,53.865448,53.708546,53.551650,53.394759,53.237877,
+    53.081003,52.924139,52.767287,52.610448,52.453624,52.296815,52.140023,51.983250,51.826496,51.669763,51.513053,51.356366,51.199705,51.043070,
+    50.886463,50.729885,50.573337,50.416821,50.260338,50.103890,49.947478,49.791103,49.634766,49.478469,49.322214,49.166001,49.009832,48.853710,
+    48.697648,48.541659,48.385757,48.229958,48.074273,47.918719,47.763308,47.608055,47.452974,47.298080,47.143385,46.988904,46.834652,46.680642,
+    46.526889,46.373405,46.220207,46.067307,45.914720,45.762460,45.610540,45.458976,45.307780,45.156968,45.006553,44.856549,44.706971,44.557832,
+    44.409146,44.260928,44.113192,43.965951,43.819220,43.673013,43.527344,43.382227,43.237676,43.093703,42.950305,42.807478,42.665218,42.523520,
+    42.382381,42.241794,42.101757,41.962264,41.823311,41.684894,41.547008,41.409648,41.272811,41.136491,41.000685,40.865387,40.730594,40.596301,
+    40.462503,40.329195,40.196375,40.064036,39.932175,39.800787,39.669867,39.539412,39.409417,39.279876,39.150787,39.022143,38.893942,38.766178,
+    38.638846,38.511944,38.385465,38.259405,38.133761,38.008525,37.883679,37.759203,37.635076,37.511278,37.387789,37.264588,37.141656,37.018971,
+    36.896513,36.774262,36.652197,36.530298,36.408545,36.286918,36.165395,36.043957,35.922583,35.801253,35.679947,35.558643,35.437322,35.315964,
+    35.194547,35.073052,34.951458,34.829745,34.707892,34.585879,34.463686,34.341293,34.218678,34.095822,33.972704,33.849303,33.725600,33.601574,
+    33.477205,33.352481,33.227425,33.102069,32.976445,32.850585,32.724520,32.598284,32.471906,32.345420,32.218858,32.092250,31.965629,31.839028,
+    31.712477,31.586009,31.459655,31.333448,31.207419,31.081601,30.956024,30.830722,30.705725,30.581067,30.456777,30.332890,30.209436,30.086447,
+    29.963955,29.841993,29.720591,29.599783,29.479599,29.360071,29.241233,29.123114,29.005748,28.889166,28.773400,28.658474,28.544378,28.431095,
+    28.318607,28.206897,28.095947,27.985740,27.876257,27.767481,27.659396,27.551982,27.445224,27.339102,27.233599,27.128699,27.024383,26.920633,
+    26.817433,26.714764,26.612609,26.510951,26.409772,26.309053,26.208779,26.108930,26.009491,25.910442,25.811766,25.713446,25.615465,25.517804,
+    25.420446,25.323374,25.226570,25.130016,25.033695,24.937589,24.841681,24.745955,24.650409,24.555043,24.459856,24.364847,24.270016,24.175363,
+    24.080887,23.986588,23.892466,23.798520,23.704751,23.611156,23.517737,23.424492,23.331422,23.238526,23.145803,23.053253,22.960877,22.868672,
+    22.776640,22.684779,22.593090,22.501572,22.410224,22.319046,22.228038,22.137200,22.046530,21.956029,21.865697,21.775532,21.685535,21.595704,
+    21.506041,21.416544,21.327213,21.238047,21.149047,21.060211,20.971540,20.883034,20.794691,20.706512,20.618496,20.530642,20.442952,20.355423,
+    20.268057,20.180852,20.093808,20.006925,19.920202,19.833640,19.747237,19.660994,19.574910,19.488985,19.403218,19.317610,19.232159,19.146866,
+    19.061729,18.976750,18.891927,18.807260,18.722749,18.638393,18.554193,18.470147,18.386255,18.302518,18.218934,18.135504,18.052227,17.969105,
+    17.886151,17.803379,17.720805,17.638444,17.556310,17.474419,17.392786,17.311425,17.230351,17.149581,17.069127,16.989007,16.909233,16.829822,
+    16.750789,16.672148,16.593914,16.516103,16.438729,16.361808,16.285354,16.209382,16.133907,16.058945,15.984510,15.910617,15.837282,15.764518,
+    15.692342,15.620768,15.549811,15.479486,15.409809,15.340793,15.272455,15.204808,15.137869,15.071646,15.006129,14.941300,14.877144,14.813643,
+    14.750781,14.688540,14.626906,14.565860,14.505386,14.445467,14.386088,14.327231,14.268879,14.211016,14.153626,14.096691,14.040195,13.984121,
+    13.928453,13.873174,13.818267,13.763716,13.709504,13.655615,13.602031,13.548736,13.495714,13.442948,13.390420,13.338115,13.286016,13.234107,
+    13.182369,13.130788,13.079346,13.028026,12.976813,12.925693,12.874671,12.823756,12.772958,12.722285,12.671746,12.621351,12.571107,12.521025,
+    12.471113,12.421380,12.371835,12.322488,12.273346,12.224419,12.175717,12.127248,12.079020,12.031044,11.983328,11.935880,11.888711,11.841828,
+    11.795242,11.748960,11.702993,11.657348,11.612035,11.567063,11.522441,11.478178,11.434282,11.390764,11.347631,11.304893,11.262558,11.220637,
+    11.179137,11.138068,11.097437,11.057252,11.017521,10.978252,10.939452,10.901129,10.863290,10.825944,10.789098,10.752760,10.716937,10.681638,
+    10.646869,10.612640,10.578956,10.545827,10.513259,10.481261,10.449840,10.419004,10.388760,10.359117,10.330082,10.301663,10.273867,10.246702,
+    10.220176,10.194296,10.169071,10.144508,10.120615,10.097399,10.074868,10.053030,10.031892,10.011463,9.991749,9.972762,9.954523,9.937056,9.920385,
+    9.904534,9.889527,9.875389,9.862144,9.849815,9.838428,9.828005,9.818572,9.810152,9.802770,9.796449,9.791214,9.787089,9.784099,9.782266,9.781616,
+    9.782172,9.783959,9.787001,9.791322,9.796946,9.803897,9.812200,9.821878,9.832956,9.845457,9.859407,9.874829,9.891747,9.910185,9.930168,9.951720,
+    9.974864,9.999625,10.026008,10.053933,10.083304,10.114023,10.145991,10.179112,10.213287,10.248419,10.284410,10.321161,10.358576,10.396556,10.435004,
+    10.473821,10.512911,10.552175,10.591516,10.630835,10.670035,10.709018,10.747686,10.785942,10.823688,10.860826,10.897258,10.932886,10.967613,11.001341,
+    11.033972,11.065408,11.095552,11.124305,11.151570,11.177249,11.201245,11.223459,11.243793,11.262151,11.278450,11.292676,11.304827,11.314906,11.322913,
+    11.328848,11.332713,11.334508,11.334233,11.331889,11.327477,11.320998,11.312453,11.301841,11.289164,11.274422,11.257616,11.238747,11.217816,11.194822,
+    11.169767,11.142652,11.113476,11.082241,11.048948,11.013597,10.976189,10.936724,10.895203,10.851627,10.805996,10.758312,10.708574,10.656784,10.602942,
+    10.547049,10.489106,10.429113,10.367082,10.303073,10.237155,10.169399,10.099876,10.028655,9.955807,9.881403,9.805512,9.728206,9.649554,9.569627,9.488495,
+    9.406228,9.322897,9.238573,9.153325,9.067225,8.980341,8.892745,8.804508,8.715698,8.626388,8.536646,8.446544,8.356152,8.265539,8.174778,8.083937,7.993087,
+    7.902299,7.811643,7.721190,7.631008,7.541170,7.451746,7.362804,7.274417,7.186644,7.099504,7.013003,6.927151,6.841956,6.757424,6.673565,6.590385,6.507894,
+    6.426099,6.345008,6.264629,6.184970,6.106039,6.027843,5.950392,5.873692,5.797752,5.722579,5.648183,5.574570,5.501748,5.429727,5.358512,5.288114,5.218538,
+    5.149794,5.081890,5.014832,4.948630,4.883292,4.818824,4.755236,4.692535,4.630729,4.569826,4.509834,4.450761,4.392616,4.335415,4.279172,4.223905,4.169630,
+    4.116362,4.064118,4.012914,3.962766,3.913691,3.865703,3.818820,3.773058,3.728432,3.684960,3.642656,3.601538,3.561621,3.522921,3.485455,3.449239,3.414289,
+    3.380620,3.348250,3.317194,3.287469,3.259090,3.232074,3.206437,3.182194,3.159363,3.137959,3.117999,3.099498,3.082473,3.066939,3.052914,3.040413,3.029451,
+    3.020039,3.012186,3.005904,3.001201,2.998087,2.996571,2.996665,2.998377,3.001718,3.006696,3.013323,3.021607,3.031559,3.043187,3.056503,3.071516,3.088235,
+    3.106671,3.126833,3.148731,3.172374,3.197773,3.224938,3.253877,3.284601,3.317120,3.351444,3.387581,3.425543,3.465339,3.506978,3.550470,3.595826,3.643054,
+    3.692166,3.743169,3.796075,3.850896,3.907655,3.966377,4.027088,4.089815,4.154581,4.221415,4.290340,4.361382,4.434569,4.509924,4.587474,4.667245,4.749261,
+    4.833550,4.920136,5.009046,5.100305,5.193938,5.289972,5.388432,5.489343,5.592732,5.698625,5.807046,5.918022,6.031578,6.147741,6.266535,6.387986,6.512121,
+    6.638964,6.768542,6.900880,7.036004,7.173939,7.314712,7.458348,7.604856,7.754175,7.906227,8.060936,8.218223,8.378012,8.540225,8.704784,8.871612,9.040631,
+    9.211765,9.384934,9.560063,9.737073,9.915888,10.096429,10.278619,10.462380,10.647636,10.834309,11.022321,11.211594,11.402052,11.593616,11.786210,11.979755,
+    12.174175,12.369392,12.565329,12.761907,12.959049,13.156679,13.354718,13.553089,13.751715,13.950518,14.149420,14.348345,14.547211,14.745925,14.944391,
+    15.142512,15.340191,15.537333,15.733840,15.929615,16.124564   
+};
+void Transcribe(int Len,int inputLen,double *SoundIn,double *out,double *outArray2,double *outArray3,double SampleRate);
+
+Transcription::Transcription(float inputSampleRate) :
+    Plugin(inputSampleRate),
+    m_stepSize(0)
+{
+    m_SoundIn=0;
+    m_SampleN=0;
+    m_AllocN = 0;
+    m_Excess = false;
+}
+
+Transcription::~Transcription()
+{
+    free(m_SoundIn);
+}
+
+string
+Transcription::getIdentifier() const
+{
+    return "qm-transcription";
+}
+
+string
+Transcription::getName() const
+{
+    return "Polyphonic Transcription";
+}
+
+string
+Transcription::getDescription() const
+{
+    return "Transcribe the input audio to estimated notes";
+}
+
+string
+Transcription::getMaker() const
+{
+    return "Queen Mary, University of London";
+}
+
+int
+Transcription::getPluginVersion() const
+{
+    return 1;
+}
+
+string
+Transcription::getCopyright() const
+{
+    return "Plugin by Dr. Ruohua Zhou.  Copyright (c) 2008-2009 QMUL - All Rights Reserved";
+}
+
+size_t
+Transcription::getPreferredStepSize() const
+{
+    return 441;
+}
+
+size_t
+Transcription::getPreferredBlockSize() const
+{
+    return 441;
+}
+
+bool
+Transcription::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+    if (channels < getMinChannelCount() ||
+	channels > getMaxChannelCount()) return false;
+
+    if (m_inputSampleRate < 4410 || m_inputSampleRate > 441000) return false;
+
+    m_stepSize = std::min(stepSize, blockSize);
+    m_blockSize=blockSize;
+
+    m_SampleN = 0;
+
+    return true;
+}
+
+void
+Transcription::reset()
+{
+    free(m_SoundIn);
+    m_SoundIn = 0;
+    m_SampleN = 0;
+    m_AllocN = 0;
+    m_Excess = false;
+    m_Base = Vamp::RealTime();
+}

qm-vamp-plugins-1.7.tar.gz/plugins/Transcription.h Added

@@ -0,0 +1,81 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+#ifndef _TRANSCRIPTION_PLUGIN_H_
+#define _TRSNSCRIPTION_PLUGIN_H_
+
+#include <vamp-sdk/Plugin.h>
+
+class Transcription : public Vamp::Plugin
+{
+public:
+    Transcription(float inputSampleRate);
+    virtual ~Transcription();
+
+    bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+    void reset();
+
+    InputDomain getInputDomain() const { return TimeDomain; }
+
+    std::string getIdentifier() const;
+    std::string getName() const;
+    std::string getDescription() const;
+    std::string getMaker() const;
+    int getPluginVersion() const;
+    std::string getCopyright() const;
+	  size_t getPreferredStepSize() const;
+    size_t getPreferredBlockSize() const;
+
+    OutputList getOutputDescriptors() const;
+
+    FeatureSet process(const float *const *inputBuffers,
+                       Vamp::RealTime timestamp);
+
+    FeatureSet getRemainingFeatures();
+
+protected:
+    size_t m_stepSize;
+    size_t m_blockSize;
+    double * m_SoundIn;
+    size_t m_SampleN;
+    size_t m_AllocN;
+    bool m_Excess;
+    Vamp::RealTime m_Base;
+/*
+ void sofacomplexMex(double *y, double *z, int ncols,double StartNote,double NoteInterval1,double NoteNum,double C,double D);
+ void FindMaxN( double *InputArray, int InputLen,int MaxOrder);
+ double SumF(double *InputArray,int Start, int End);
+ int round10(int x) ;
+ void ConToPitch1250(double *In, int InLen);
+ void Norm1(double *In, int InLen);
+ void Smooth(double *In, int InLen,int smoothLen);
+ void FindPeaks(double *In, int InLen,double *Out1,double *Out2, int db, int db2, int db3);
+ void ConFrom1050To960(double *In, double *out, int InputLen);
+ void Move( double *InputArray, int InputLen,int m);
+ double SumArray( double *InputArray, int InputHLen, int InputVLen);
+ double Sum( double *InputArray, int InputHLen);
+ void MeanV2( double *InputArray, int InputHLen, int InputVLen, double *OutArray);
+ void SumV( double *InputArray, int InputHLen, int InputVLen, double *OutArray);
+ void SumV2( double *InputArray, int InputHLen, int InputVLen, double *OutArray);
+ void MaxV( double *InputArray, int InputHLen, int InputVLen, double *OutArray);
+ void MaxV2( double *InputArray, int InputHLen, int InputVLen, double *OutArray);
+ void MinArray( double *InputArray, int InputHLen, int InputVLen, double MinValue);
+  void MaxArray( double *InputArray, int InputHLen, int InputVLen, double MaxValue);
+ double  GetMaxValue( double *InputArray, int InputHLen, int InputVLen);
+ void RemoveNoise( double *InputArray, int InputHLen, int InputVLen);
+ double MeanArray( double *InputArray, int InputHLen, int InputVLen);
+ void Mydiff( double *InputArray, int InputHLen, int InputVLen,int n);
+ void PeakDetect(double *In, int InLen);
+ void MeanV( double *InputArray, int InputHLen, int InputVLen, double *OutArray);
+void Edetect(double *InputArray, int InputHLen, int InputVLen, double MinT, double db1,double *OutOne);
+void OnsetDetection2(double *In,int InputLen,double *OutOne,double a,double b);
+void PitchEstimation(double *In, int InLen, double *OutArray,double *OutArray2);
+void DoMultiPitch(double *In, int RLen,int CLen, double *Out1, double *Out2);
+int OnsetToArray(double *In, int Len, double *OutStart,double *OutEnd);
+void dbfunction( double *InputArray, int InputHLen, int InputVLen,double *OutArray);
+
+void Transcribe(int Len,int inputLen,double *SoundIn,double *out,double *outArray2,double *outArray3);*/
+
+};
+
+
+#endif

qm-vamp-plugins-1.7.tar.gz/qm-vamp-plugins.pro Added

@@ -0,0 +1,87 @@
+
+TEMPLATE = lib
+CONFIG += plugin warn_on release
+CONFIG -= qt
+
+linux-g++* {
+    QMAKE_CXXFLAGS_RELEASE += -DNDEBUG -O3 -fno-exceptions -fPIC -ffast-math -msse -mfpmath=sse -ftree-vectorize -fomit-frame-pointer
+    DEFINES += USE_PTHREADS
+    INCLUDEPATH += ../vamp-plugin-sdk ../qm-dsp
+    LIBPATH += ../vamp-plugin-sdk ../qm-dsp
+}
+
+linux-g++ {
+    LIBS += -static-libgcc -Wl,-Bstatic -lqm-dsp -lvamp-sdk -L/usr/lib/sse2/atlas -L/usr/lib/atlas/sse -llapack -lblas $$system(g++ -print-file-name=libstdc++.a) -lc -Wl,-Bdynamic -lpthread -Wl,--version-script=vamp-plugin.map
+}
+
+linux-g++-64 {
+    QMAKE_CXXFLAGS_RELEASE += -msse2
+    LIBS += -Lbuild/linux/amd64  -Wl,-Bstatic -lqm-dsp -lvamp-sdk -llapack -lcblas -latlas -lc -Wl,-Bdynamic -lpthread -Wl,--version-script=vamp-plugin.map
+}
+
+macx-g++* {
+    QMAKE_MAC_SDK=/Developer/SDKs/MacOSX10.4u.sdk
+    QMAKE_CXXFLAGS_RELEASE += -mmacosx-version-min=10.4 -O2 -g0
+    QMAKE_CFLAGS_RELEASE += -mmacosx-version-min=10.4 
+    CONFIG += x86 ppc x86_64
+    QMAKE_CXX = g++-4.0
+    QMAKE_CC = gcc-4.0
+    QMAKE_LINK = g++-4.0
+    DEFINES += USE_PTHREADS
+    LIBS += -mmacosx-version-min=10.4 -lqm-dsp -L../inst/lib -lvamp-sdk -framework Accelerate -lpthread -exported_symbols_list vamp-plugin.list
+    INCLUDEPATH += ../vamp-plugin-sdk ../qm-dsp
+    LIBPATH += ../include ../lib ../qm-dsp
+}
+
+win32-x-g++ {
+    QMAKE_CXXFLAGS_RELEASE += -DNDEBUG -O2 -march=pentium3 -msse
+    INCLUDEPATH += ../include ../qm-dsp
+    LIBPATH += ./build/mingw32 ../lib ../qm-dsp ../qm-dsp/release 
+    LIBS += -shared -Wl,-Bstatic -lqm-dsp -lvamp-sdk -llapack -lcblas -latlas -lf77blas -lg2cstubs -Wl,-Bdynamic -Wl,--version-script=vamp-plugin.map
+}
+
+solaris* {
+    QMAKE_CXXFLAGS_RELEASE += -DNDEBUG -fast
+    INCLUDEPATH += /usr/local/include ../qm-dsp
+    INCLUDEPATH += /opt/ATLAS3.9.14/include
+    LIBPATH += ../qm-dsp /opt/ATLAS3.9.14/lib
+    DEFINES += USE_PTHREADS
+    LIBS += -Bstatic -lqm-dsp -lvamp-sdk -llapack -lcblas -latlas -Bdynamic -lpthread -Wl,--version-script=vamp-plugin.map -lCstd -lCrun
+}
+
+OBJECTS_DIR = tmp_obj
+MOC_DIR = tmp_moc
+
+DEPENDPATH += plugins
+INCLUDEPATH += . plugins
+
+# Input
+HEADERS += plugins/AdaptiveSpectrogram.h \
+           plugins/BarBeatTrack.h \
+           plugins/BeatTrack.h \
+           plugins/DWT.h \
+           plugins/OnsetDetect.h \
+           plugins/ChromagramPlugin.h \
+           plugins/ConstantQSpectrogram.h \
+           plugins/KeyDetect.h \
+           plugins/MFCCPlugin.h \
+           plugins/SegmenterPlugin.h \
+           plugins/SimilarityPlugin.h \
+           plugins/TonalChangeDetect.h \
+           plugins/Transcription.h
+SOURCES += g2cstubs.c \
+           plugins/AdaptiveSpectrogram.cpp \
+           plugins/BarBeatTrack.cpp \
+           plugins/BeatTrack.cpp \
+           plugins/DWT.cpp \
+           plugins/OnsetDetect.cpp \
+           plugins/ChromagramPlugin.cpp \
+           plugins/ConstantQSpectrogram.cpp \
+           plugins/KeyDetect.cpp \
+           plugins/MFCCPlugin.cpp \
+           plugins/SegmenterPlugin.cpp \
+           plugins/SimilarityPlugin.cpp \
+           plugins/TonalChangeDetect.cpp \
+           plugins/Transcription.cpp \
+           ./libmain.cpp
+

qm-vamp-plugins-1.7.tar.gz/valgrinder.sh Added

qm-vamp-plugins-1.7.tar.gz/vamp-plugin.list Added

qm-vamp-plugins-1.7.tar.gz/vamp-plugin.map Added