Start adding Loris files

96 files changed, 43574 insertions, 0 deletions

diff --git a/src/loris/AiffData.C b/src/loris/AiffData.C
new file mode 100644
index 0000000..6feabbf
--- /dev/null
+++ b/src/loris/AiffData.C
@@ -0,0 +1,952 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * AiffData.C
+ *
+ * Implementation of import and export functions.
+ *
+ * Kelly Fitz, 17 Sept 2003 
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "AiffData.h"
+
+#include "BigEndian.h"
+#include "LorisExceptions.h"
+#include "Marker.h"
+#include "Notifier.h"
+
+#include <climits>
+#include <cmath>
+#include <fstream>
+#include <iostream>
+
+//	begin namespace
+namespace Loris {
+
+
+// ---------------------------------------------------------------------------
+//	extended80
+// ---------------------------------------------------------------------------
+//  IEEE floating point conversions, functions defined at end of file
+//  (used to be in a separate file, but they aren't used anywhere else).
+//
+
+/*	struct extended80 defined below 	*/
+struct extended80;
+
+/*	conversion functions				*/
+extern void ConvertToIeeeExtended(double num, extended80 * x) ;
+extern double ConvertFromIeeeExtended(const extended80 * x) ;
+
+/*	struct extended80 definition, with 
+	constructors and conversion to double 								
+ */
+struct extended80 
+{
+	char data[10];
+	
+	extended80( double x = 0. ) { ConvertToIeeeExtended( x, this ); }
+	operator double( void ) const { return ConvertFromIeeeExtended( this ); }	
+};
+
+// -- AIFF import --
+
+// ---------------------------------------------------------------------------
+//	readChunkHeader
+// ---------------------------------------------------------------------------
+//	Read the id and chunk size from the current file position.
+//
+std::istream & 
+readChunkHeader( std::istream & s, CkHeader & h )
+{	
+    ID id = 0;
+    Uint_32 sz = 0;
+    BigEndian::read( s, 1, sizeof(ID), (char *)&id );
+    BigEndian::read( s, 1, sizeof(Uint_32), (char *)&sz );
+    
+	if ( s )
+	{
+		h.id = id;
+		h.size = sz;
+	}
+
+	return s;
+}
+
+// ---------------------------------------------------------------------------
+//	readApplicationSpecifcData
+// ---------------------------------------------------------------------------
+//	Read the data in the ApplicationSpecific chunk, assume the stream is 
+//	correctly positioned, and that the chunk header has already been read.
+//
+//  Look for data specific to SPC files. Any other kind of Application 
+//	Specific data is ignored.
+//
+std::istream & 
+readApplicationSpecifcData( std::istream & s, SosEnvelopesCk & ck, unsigned long chunkSize )
+{
+    Int_32 tmp_signature;
+    BigEndian::read( s, 1, sizeof(Int_32), (char *)&tmp_signature );
+    
+    if ( tmp_signature == SosEnvelopesId )
+    {
+        ck.header.id = ApplicationSpecificId;	
+        ck.header.size = chunkSize;
+        ck.signature = SosEnvelopesId; 
+        
+        //	lookout! The format of this chunk is a mess, due
+        //	to obsolete stuff lying around!
+        BigEndian::read( s, 1, sizeof(Int_32), (char *)&ck.enhanced );
+        BigEndian::read( s, 1, sizeof(Int_32), (char *)&ck.validPartials );
+        s.ignore( ck.validPartials * sizeof(Int_32) );
+        BigEndian::read( s, 1, sizeof(Int_32), (char *)&ck.resolution );
+        s.ignore( chunkSize - (4 + ck.validPartials) * sizeof(Int_32) );
+    }
+    else
+    {
+        s.ignore( chunkSize - sizeof(Int_32) );
+    }
+
+    if ( !s )
+    {
+        Throw( FileIOException, "Failed to read badly-formatted AIFF file (bad ApplicationSpecific chunk)." );
+    }
+	
+	return s;
+}
+
+// ---------------------------------------------------------------------------
+//	readCommonData
+// ---------------------------------------------------------------------------
+//	Read the data in the Common chunk, assume the stream is correctly
+//	positioned, and that the chunk header has already been read.
+//
+std::istream & 
+readCommonData( std::istream & s, CommonCk & ck, unsigned long chunkSize )
+{
+    BigEndian::read( s, 1, sizeof(Int_16), (char *)&ck.channels );
+    BigEndian::read( s, 1, sizeof(Int_32), (char *)&ck.sampleFrames );
+    BigEndian::read( s, 1, sizeof(Int_16), (char *)&ck.bitsPerSample );
+    
+    if ( !s )
+    {
+        Throw( FileIOException, "Failed to read badly-formatted AIFF file (bad Common chunk)." );
+    }
+                        
+	ck.header.id = CommonId;	
+	ck.header.size = chunkSize;
+
+    //	don't let this get byte-reversed:
+    extended80 read_rate;
+    BigEndian::read( s, sizeof(extended80), sizeof(char), (char *)&read_rate );
+    ck.srate = read_rate;
+
+	return s;
+}
+
+// ---------------------------------------------------------------------------
+//	readContainer
+// ---------------------------------------------------------------------------
+//
+std::istream & 
+readContainer( std::istream & s, ContainerCk & ck, unsigned long chunkSize )
+{
+	ck.header.id = ContainerId;	
+	ck.header.size = chunkSize;
+
+    //	read in the chunk data:
+    BigEndian::read( s, 1, sizeof(ID), (char *)&ck.formType );
+    if ( !s )
+    {
+        Throw( FileIOException, "Failed to read badly-formatted AIFF file (bad Container chunk)." );
+    }
+
+	//	make sure its really AIFF:
+	if ( ck.formType != AiffType )
+	{
+		std::string err("Bad form type in AIFF file: ");
+		err += std::string( ck.formType, 4 );
+		Throw( FileIOException, err );
+	}
+		
+	return s;
+}	
+
+// ---------------------------------------------------------------------------
+//	readInstrumentData
+// ---------------------------------------------------------------------------
+//
+std::istream & 
+readInstrumentData( std::istream & s, InstrumentCk & ck, unsigned long chunkSize )
+{
+	ck.header.id = InstrumentId;	
+	ck.header.size = chunkSize;
+
+    BigEndian::read( s, 1, sizeof(Byte), (char *)&ck.baseNote );
+    BigEndian::read( s, 1, sizeof(Byte), (char *)&ck.detune );
+    BigEndian::read( s, 1, sizeof(Byte), (char *)&ck.lowNote );
+    BigEndian::read( s, 1, sizeof(Byte), (char *)&ck.highNote );
+    BigEndian::read( s, 1, sizeof(Byte), (char *)&ck.lowVelocity );
+    BigEndian::read( s, 1, sizeof(Byte), (char *)&ck.highVelocity );
+    BigEndian::read( s, 1, sizeof(Int_16), (char *)&ck.gain );
+
+    //	AIFFLoop is three Int_16s:
+    BigEndian::read( s, 1, sizeof(Uint_16), (char *)&ck.sustainLoop.playMode );
+    BigEndian::read( s, 1, sizeof(Int_16), (char *)&ck.sustainLoop.beginLoop );
+    BigEndian::read( s, 1, sizeof(Int_16), (char *)&ck.sustainLoop.endLoop );
+    
+    BigEndian::read( s, 1, sizeof(Uint_16), (char *)&ck.releaseLoop.playMode );
+    BigEndian::read( s, 1, sizeof(Int_16), (char *)&ck.releaseLoop.beginLoop );
+    BigEndian::read( s, 1, sizeof(Int_16), (char *)&ck.releaseLoop.endLoop );
+
+    if ( !s )
+    {
+        Throw( FileIOException, "Failed to read badly-formatted AIFF file (bad Common chunk)." );
+    }
+							
+	return s;
+}
+
+// ---------------------------------------------------------------------------
+//	readMarkerData
+// ---------------------------------------------------------------------------
+//
+std::istream & 
+readMarkerData( std::istream & s, MarkerCk & ck, unsigned long chunkSize )
+{
+	ck.header.id = MarkerId;	
+	ck.header.size = chunkSize;
+
+    Uint_32 bytesToRead = chunkSize;
+    
+    //	read in the number of Markers
+    BigEndian::read( s, 1, sizeof(Uint_16), (char *)&ck.numMarkers );
+    bytesToRead -= sizeof(Uint_16);
+    
+    for ( int i = 0; i < ck.numMarkers; ++i )
+    {
+        MarkerCk::Marker marker;
+        BigEndian::read( s, 1, sizeof(Uint_16), (char *)&marker.markerID );
+        bytesToRead -= sizeof(Uint_16);
+        
+        BigEndian::read( s, 1, sizeof(Uint_32), (char *)&marker.position );
+        bytesToRead -= sizeof(Uint_32);
+        
+        //	read the size of the name string, then the characters:
+        unsigned char namelength;
+        BigEndian::read( s, 1, sizeof(unsigned char), (char *)&namelength );
+        bytesToRead -= sizeof(unsigned char);
+        
+        //	need to add one to the length, because, like C-strings,
+        //	Pascal strings are null-terminated, but the null character
+        //	is _not_ counted in the length.
+        //
+        //	Correction? At least one web source says that Pascal strings
+        //	are _not_ null terminated, but are padded (with an extra byte
+        //	that is not part of the count) if necessary to make the total 
+        //	number of bytes even (that is, the char bytes, _plus_ the count). 
+        //
+        //	This way seems to work with all the files I have tried (Kyma and 
+        //	Peak, mostly) for AIFF and Spc.
+        int ncharbytes = namelength;
+        if ( ncharbytes%2 == 0 )
+            ++ncharbytes;
+        static char tmpChars[256];
+        BigEndian::read( s, ncharbytes, sizeof(char), tmpChars );
+        bytesToRead -= ncharbytes * sizeof(char);
+        tmpChars[ namelength ] = '\0';
+    
+        //	convert to a string:
+        marker.markerName = std::string( tmpChars );
+        
+        ck.markers.push_back( marker );
+    }
+    
+    if ( bytesToRead > 0 )
+    {
+        s.ignore( bytesToRead );
+    }
+
+    if ( !s )
+    {
+        Throw( FileIOException, "Failed to read badly-formatted AIFF file (bad Marker chunk)." );
+    }
+        
+	return s;
+}	
+
+// ---------------------------------------------------------------------------
+//	readSamples
+// ---------------------------------------------------------------------------
+//	Let exceptions propogate.
+//
+static std::istream & 
+readSamples( std::istream & s, std::vector< Byte > & bytes )
+{	
+	debugger << "reading " << bytes.size() << " bytes of sample data" << endl;
+
+	//	read integer samples without byte swapping: 
+	BigEndian::read( s, bytes.size(), 1, (char*)(&bytes[0]) );
+	
+	return s;
+}
+
+// ---------------------------------------------------------------------------
+//	readSampleData
+// ---------------------------------------------------------------------------
+//	Read the data in the Sound Data chunk, assume the stream is correctly
+//	positioned, and that the chunk header has already been read.
+//
+std::istream & 
+readSampleData( std::istream & s, SoundDataCk & ck, unsigned long chunkSize )
+{
+	ck.header.id = SoundDataId;	
+	ck.header.size = chunkSize;
+
+    BigEndian::read( s, 1, sizeof(Uint_32), (char *)&ck.offset );
+    BigEndian::read( s, 1, sizeof(Uint_32), (char *)&ck.blockSize );
+    
+    //	compute the actual number of bytes that
+    //	can be read from this chunk:
+    //	(chunkSize is everything after the header)
+    const unsigned long howManyBytes = 
+        ( chunkSize - ck.offset ) - (2 * sizeof(Uint_32));
+        
+    ck.sampleBytes.resize( howManyBytes, 0 );		//	could throw bad_alloc
+
+    //	skip ahead to the samples and read them:
+    s.ignore( ck.offset );
+    readSamples( s, ck.sampleBytes );
+
+    if ( !s )
+    {
+        Throw( FileIOException, "Failed to read badly-formatted AIFF file (bad Sound Data chunk)." );
+    }
+	
+	return s;
+}
+
+// -- Chunk construction --
+
+// ---------------------------------------------------------------------------
+//	configureCommonCk
+// ---------------------------------------------------------------------------
+void 
+configureCommonCk( CommonCk & ck, unsigned long nFrames, unsigned int nChans,
+				   unsigned int bps, double srate  )
+{
+	ck.header.id = CommonId;
+
+	//	size is everything after the header:
+	ck.header.size = sizeof(Int_16) + 			//	num channels
+					 sizeof(Int_32) + 			//	num frames
+					 sizeof(Int_16) + 			//	bits per sample
+					 sizeof(extended80);	//	sample rate
+					 
+	ck.channels = nChans;
+	ck.sampleFrames = nFrames;
+	ck.bitsPerSample = bps;
+	ck.srate = srate;
+	// ConvertToIeeeExtended( srate, &ck.srate );
+	
+}
+
+// ---------------------------------------------------------------------------
+//	configureContainer
+// ---------------------------------------------------------------------------
+//	dataSize is the combined size of all other chunks in file. Configure 
+//	them first, then add their sizes (with headers!).
+//
+void 
+configureContainer( ContainerCk & ck, unsigned long dataSize )
+{	
+	ck.header.id = ContainerId;
+	
+	//	size is everything after the header:
+	ck.header.size = sizeof(Int_32) + dataSize;
+	
+	ck.formType = AiffType;
+}
+
+// ---------------------------------------------------------------------------
+//	configureInstrumentCk
+// ---------------------------------------------------------------------------
+void 
+configureInstrumentCk( InstrumentCk & ck, double midiNoteNum )
+{
+	ck.header.id = InstrumentId;
+
+	//	size is everything after the header:
+	ck.header.size = 
+			sizeof(Byte) +				// baseFrequency
+			sizeof(Byte) +				// detune
+			sizeof(Byte) +				// lowFrequency
+			sizeof(Byte) +				// highFrequency
+			sizeof(Byte) +				// lowVelocity
+			sizeof(Byte) +				// highVelocity
+			sizeof(Int_16) +			// gain
+			2 * sizeof(Int_16) +		// playmode for sustainLoop and releaseLoop
+			2 * sizeof(Uint_16) +		// beginLoop for sustainLoop and releaseLoop
+			2 * sizeof(Uint_16);		// loopEnd for sustainLoop and releaseLoop
+
+	ck.baseNote = Byte( midiNoteNum );
+	ck.detune = Byte(long( 100 * midiNoteNum ) % 100);
+	if (ck.detune > 50)
+	{
+		ck.baseNote++;
+		ck.detune -= 100;
+	}
+	ck.detune *= -1;
+
+	ck.lowNote = 0;	
+	ck.highNote = 127;	
+	ck.lowVelocity = 1;	
+	ck.highVelocity = 127;	
+	ck.gain = 0;	
+	ck.sustainLoop.playMode = 0;		// Sustain looping done by name, not by this
+	ck.sustainLoop.beginLoop = 0;
+	ck.sustainLoop.endLoop = 0;
+	ck.releaseLoop.playMode = 0;		// No Looping
+	ck.releaseLoop.beginLoop = 0;
+	ck.releaseLoop.endLoop = 0;
+}
+
+// ---------------------------------------------------------------------------
+//	configureMarkerCk
+// ---------------------------------------------------------------------------
+void 
+configureMarkerCk( MarkerCk & ck, const std::vector< Marker > & markers, double srate  )
+{
+	ck.header.id = MarkerId;
+
+	//	accumulate data size
+	Uint_32 dataSize = sizeof(Uint_16);	//	num markers
+	
+	ck.numMarkers = markers.size();
+	ck.markers.resize( markers.size() );
+	for ( unsigned int j = 0; j < markers.size(); ++j )
+	{
+		MarkerCk::Marker & m = ck.markers[j];
+		m.markerID = j+1;
+		m.position = Uint_32((markers[j].time() * srate) + 0.5);
+		m.markerName = markers[j].name();
+		
+		#define MAX_PSTRING_CHARS 254
+		if ( m.markerName.size() > MAX_PSTRING_CHARS )
+			m.markerName.resize( MAX_PSTRING_CHARS );
+		
+		//	the size of a pascal string is the number of 
+		//	characters plus the size byte, plus the terminal '\0'.
+		//	
+		//	Actualy, at least one web source indicates that Pascal
+		//	strings are not null-terminated, but that they _are_
+		//	padded with an extra (not part of the count) byte
+		//	if necessary to ensure that the total length (including
+		//	count) is even, and this seems to work better with other
+		//	programs (e.g. Kyma)
+		if ( m.markerName.size()%2 == 0 )
+				m.markerName += '\0';
+		dataSize += sizeof(Uint_16) + sizeof(Uint_32) + (m.markerName.size() + 1);
+	}
+
+	//	must be an even number of bytes
+	if ( dataSize%2 )
+		++dataSize;
+
+	ck.header.size = dataSize;
+}
+
+// ---------------------------------------------------------------------------
+//	configureSoundDataCk
+// ---------------------------------------------------------------------------
+//
+void 
+configureSoundDataCk( SoundDataCk & ck, const std::vector< double > & samples, 
+					  unsigned int bps  )
+{
+	Uint_32 dataSize = samples.size() * (bps/8);
+	//	must be an even number of bytes:
+	if ( dataSize % 2 ) 
+	{
+		++dataSize;
+	}
+
+	ck.header.id = SoundDataId;
+
+	//	size is everything after the header:
+	ck.header.size = sizeof(Uint_32) + 	//	offset
+					 sizeof(Uint_32) + 	//	block size
+					 dataSize;			//	sample data
+
+
+	//	no block alignment:	
+	ck.offset = 0;
+	ck.blockSize = 0;
+	
+	//	convert the samples to integers stored in 
+	//	big endian order in the byte vector:
+	convertSamplesToBytes( samples, ck.sampleBytes, bps );
+}
+
+
+// -- AIFF export --
+
+// ---------------------------------------------------------------------------
+//	writeCommon
+// ---------------------------------------------------------------------------
+//
+std::ostream &
+writeCommonData( std::ostream & s, const CommonCk & ck )
+{
+/*
+	debugger << "writing common chunk: " << endl;
+	debugger << "header id: " << ck.header.id << endl;
+	debugger << "size: " << ck.header.size << endl;
+	debugger << "channels: " << ck.channels << endl;
+	debugger << "sample frames: " << ck.sampleFrames << endl;
+	debugger << "bits per sample: " << ck.bitsPerSample << endl;
+	//debugger << "rate: " << _sampleRate  << endl;
+*/
+	
+	//	write it out:
+	try 
+	{
+		BigEndian::write( s, 1, sizeof(ID), (char *)&ck.header.id );
+		BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.header.size );
+		BigEndian::write( s, 1, sizeof(Int_16), (char *)&ck.channels );
+		BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.sampleFrames );
+		BigEndian::write( s, 1, sizeof(Int_16), (char *)&ck.bitsPerSample );
+		//	don't let this get byte-reversed:
+		extended80 write_rate( ck.srate );
+		//ConvertToIeeeExtended( &ck.srate, write_rate );
+
+		BigEndian::write( s, sizeof(extended80), sizeof(char), (char *)&write_rate );
+	}
+	catch( FileIOException & ex ) 
+	{
+		ex.append( "Failed to write AIFF file Common chunk." );
+		throw;
+	}
+	
+	return s;
+}
+
+// ---------------------------------------------------------------------------
+//	writeContainer
+// ---------------------------------------------------------------------------
+//
+std::ostream &
+writeContainer( std::ostream & s, const ContainerCk & ck )
+{
+/*
+	debugger << "writing container: " << endl;
+	debugger << "header id: " << ck.header.id << endl;
+	debugger << "size: " << ck.header.size << endl;
+	debugger << "type: " << ck.formType << endl;
+*/
+	
+	//	write it out:
+	try 
+	{
+		BigEndian::write( s, 1, sizeof(ID), (char *)&ck.header.id );
+		BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.header.size );
+		BigEndian::write( s, 1, sizeof(ID), (char *)&ck.formType );
+	}
+	catch( FileIOException & ex ) 
+	{
+		ex.append( "Failed to write AIFF file Container chunk." );
+		throw;
+	}
+	
+	return s;
+}
+	
+// ---------------------------------------------------------------------------
+//	writeInstrumentData
+// ---------------------------------------------------------------------------
+std::ostream &
+writeInstrumentData( std::ostream & s, const InstrumentCk & ck )
+{
+	try 
+	{
+		BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.header.id );
+		BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.header.size );
+
+		BigEndian::write( s, 1, sizeof(Byte), (char *)&ck.baseNote );
+		BigEndian::write( s, 1, sizeof(Byte), (char *)&ck.detune );
+		BigEndian::write( s, 1, sizeof(Byte), (char *)&ck.lowNote );
+		BigEndian::write( s, 1, sizeof(Byte), (char *)&ck.highNote );
+		BigEndian::write( s, 1, sizeof(Byte), (char *)&ck.lowVelocity );
+		BigEndian::write( s, 1, sizeof(Byte), (char *)&ck.highVelocity );
+		BigEndian::write( s, 1, sizeof(Int_16), (char *)&ck.gain );
+
+		//	AIFFLoop is three Int_16s:
+		BigEndian::write( s, 3, sizeof(Int_16), (char *)&ck.sustainLoop );
+		BigEndian::write( s, 3, sizeof(Int_16), (char *)&ck.releaseLoop );
+	}
+	catch( FileIOException & ex ) 
+	{
+		ex.append( " Failed to write SPC file Instrument chunk." );
+		throw;
+	}
+
+	return s;
+}
+
+// ---------------------------------------------------------------------------
+//	writeMarkerData
+// ---------------------------------------------------------------------------
+std::ostream &
+writeMarkerData( std::ostream & s, const MarkerCk & ck )
+{
+	try 
+	{
+		BigEndian::write( s, 1, sizeof(ID), (char *)&ck.header.id );
+		BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.header.size );
+		BigEndian::write( s, 1, sizeof(Uint_16), (char *)&ck.numMarkers );
+		
+		int markerbytes = 0;
+		for ( unsigned int j = 0; j < ck.markers.size(); ++j )
+		{
+			const MarkerCk::Marker & m = ck.markers[j];
+			BigEndian::write( s, 1, sizeof(Uint_16), (char *)&m.markerID );
+			BigEndian::write( s, 1, sizeof(Uint_32), (char *)&m.position );
+			
+			//	the size of a pascal string is the number of 
+			//	characters plus the size byte, plus the terminal '\0':
+			//	Actualy, at least one web source indicates that Pascal
+			//	strings are not null-terminated, but that they _are_
+			//	padded with an extra (not part of the count) byte
+			//	if necessary to ensure that the total length (including
+			//	count) is even, and this seems to work better with other
+			//	programs (e.g. Kyma)
+			Uint_32 bytesToWrite = (m.markerName.size() + 1) * sizeof(char);
+
+			// format pascal string:
+			static char tmpChars[256];
+			tmpChars[0] = m.markerName.size();
+			std::copy( m.markerName.begin(), m.markerName.end(), tmpChars + 1 );
+			tmpChars[m.markerName.size()+1] = '\0';
+			
+			BigEndian::write( s, bytesToWrite, sizeof(char), tmpChars );
+			markerbytes += bytesToWrite;
+		}
+		
+		//	be sure to write an even number of bytes
+		if ( markerbytes%2 )
+			BigEndian::write( s, 1, sizeof(char), "\0" );
+		
+	}
+	catch( FileIOException & ex ) 
+	{
+		ex.append( "Failed to write AIFF file Marker chunk." );
+		throw;
+	}
+	
+	return s;
+}
+
+// ---------------------------------------------------------------------------
+//	writeSamples
+// ---------------------------------------------------------------------------
+//	Let exceptions propogate.
+//
+static std::ostream & 
+writeSamples( std::ostream & s, const std::vector< Byte > & bytes )
+{	
+//	debugger << "writing " << bytes.size() << " bytes of sample data" << endl;
+
+	//	write integer samples without byte swapping,
+	//	the bytes were constructed in the correct
+	//	big endian order (see convertSamplesToBytes): 
+	BigEndian::write( s, bytes.size(), 1, (char*)(&bytes[0]) );
+	
+	return s;
+}
+
+// ---------------------------------------------------------------------------
+//	writeSampleData
+// ---------------------------------------------------------------------------
+//
+std::ostream & 
+writeSampleData( std::ostream & s, const SoundDataCk & ck )
+{
+/*
+	debugger << "writing sample data: " << endl;
+	debugger << "header id: " << ck.header.id << endl;
+	debugger << "size: " << ck.header.size << endl;
+	debugger << "offset: " << ck.offset << endl;
+	debugger << "block size: " << ck.blockSize << endl;
+*/
+
+	//	write it out:
+	try 
+	{
+		BigEndian::write( s, 1, sizeof(ID), (char *)&ck.header.id );
+		BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.header.size );
+		BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.offset );
+		BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.blockSize );
+
+		writeSamples( s, ck.sampleBytes );
+	}
+	catch( FileIOException & ex ) 
+	{
+		ex.append( "Failed to write AIFF file Container chunk." );
+		throw;
+	}
+	
+	return s;
+}
+
+// -- sample conversion --
+
+// ---------------------------------------------------------------------------
+//	convertBytesToSamples
+// ---------------------------------------------------------------------------
+//	Convert sample bytes to double precision floating point samples 
+//	(-1.0, 1.0). The samples vector is resized to fit exactly as many
+//	samples as are represented in the bytes vector, and any prior
+//	contents are overwritten.
+//
+void
+convertBytesToSamples( const std::vector< Byte > & bytes, 
+					   std::vector< double > & samples, unsigned int bps )
+{
+	Assert( bps <= 32 );
+	
+	typedef std::vector< double >::size_type size_type;
+
+	const int bytesPerSample = bps / 8;
+	samples.resize( bytes.size() / bytesPerSample );
+
+	debugger << "converting " << samples.size() << " samples of size " 
+			 << bps << " bits" << endl;
+
+	//	shift sample bytes into a long integer, and 
+	//	scale to make a double:
+	const double oneOverMax = std::pow(0.5, double(bps-1));
+	long samp;
+	
+	std::vector< Byte >::const_iterator bytePos = bytes.begin();
+	std::vector< double >::iterator samplePos = samples.begin();
+	while ( samplePos != samples.end() )
+	{
+		//	assign the leading byte, so that the sign
+		//	is preserved:
+		samp = static_cast<char>(*(bytePos++));
+		for ( size_type j = 1; j < bytesPerSample; ++j )
+		{
+			Assert( bytePos != bytes.end() );
+			
+			//	OR bytes after the most significant, so
+			//	that their sign is ignored:
+			samp = (samp << 8) + (unsigned char)*(bytePos++);
+			
+			//	cannot decide why this didn't work,
+			//	instead of the add above.
+			//samp |= (unsigned long)*(bytePos++);
+		}
+
+		*(samplePos++) = oneOverMax * samp;
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	convertSamplesToBytes
+// ---------------------------------------------------------------------------
+//	Convert floating point samples (-1.0, 1.0) to bytes. 
+//	The bytes vector is resized to fit exactly as many
+//	samples as are stored in the samples vector, and any prior
+//	contents are overwritten.
+//
+//	This formats the samples as big endian bytes, that is, the most
+//	significant bytes are stored earlier in the byte vector, so 
+//	no byte-swapping should be performed when this byte array is 
+//	written to disk, and moreover this function is specific to 
+//	big-endian data storage (like AIFF files).
+void
+convertSamplesToBytes( const std::vector< double > & samples, 
+					   std::vector< Byte > & bytes, unsigned int bps )
+{
+	Assert( bps <= 32 );
+
+	typedef std::vector< Byte >::size_type size_type;
+
+	//	grow the bytes vector, must be an even number 
+	//	of bytes:
+	const int bytesPerSample = bps / 8;
+	size_type howManyBytes = samples.size() * bytesPerSample;
+	if ( howManyBytes%2 )
+		++howManyBytes;
+	bytes.resize( howManyBytes );
+
+	debugger << "converting " << samples.size() << " samples to size " 
+			 << bps << " bits" << endl;
+
+	//	shift sample bytes into a long integer, and 
+	//	scale to make a double:
+	const double maxSample = std::pow(2., double(bps-1));
+	long samp;
+	
+	std::vector< Byte >::iterator bytePos = bytes.begin();
+	std::vector< double >::const_iterator samplePos = samples.begin();
+	while ( samplePos != samples.end() )
+	{
+		samp = long(*(samplePos++) * maxSample);
+		
+		//	store the sample bytes in big endian order, 
+		//	most significant byte first:
+		for ( size_type j = bytesPerSample; j > 0; --j )
+		{
+			//Assert( bytePos != bytes.end() );
+			//	mask the lowest byte after shifting:
+			*(bytePos++) = 0xFF & (samp >> (8*(j-1)));
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	extended80
+// ---------------------------------------------------------------------------
+//  IEEE floating point conversions.
+//
+
+#ifndef HUGE_VAL
+# define HUGE_VAL HUGE
+#endif							/* HUGE_VAL */
+
+#define FloatToUnsigned(f)((Int_32)((Int_32(f - 2147483648.0)) + (Int_32)(2147483647)) + 1)
+
+void ConvertToIeeeExtended(double num, extended80 * x)
+{
+	int sign;
+	int expon;
+	double fMant, fsMant;
+	Int_32 hiMant, loMant;
+	char * bytes = x->data;
+
+	if (num < 0) {
+		sign = 0x8000;
+		num *= -1;
+	} else
+		sign = 0;
+
+	if (num == 0) {
+		expon = 0;
+		hiMant = 0;
+		loMant = 0;
+	} else {
+		fMant = frexp(num, &expon);
+		if ((expon > 16384) || !(fMant < 1)) {	/* Infinity or NaN */
+			expon = sign | 0x7FFF;
+			hiMant = 0;
+			loMant = 0;
+		}
+		 /* infinity */ 
+		else {					/* Finite */
+			expon += 16382;
+			if (expon < 0) {	/* denormalized */
+				fMant = ldexp(fMant, expon);
+				expon = 0;
+			}
+			expon |= sign;
+			fMant = ldexp(fMant, 32);
+			fsMant = floor(fMant);
+			hiMant = FloatToUnsigned(fsMant);
+			fMant = ldexp(fMant - fsMant, 32);
+			fsMant = floor(fMant);
+			loMant = FloatToUnsigned(fsMant);
+		}
+	}
+
+	bytes[0] = expon >> 8;
+	bytes[1] = expon;
+
+	bytes[2] = hiMant >> 24;
+	bytes[3] = hiMant >> 16;
+	bytes[4] = hiMant >> 8;
+	bytes[5] = hiMant;
+
+	bytes[6] = loMant >> 24;
+	bytes[7] = loMant >> 16;
+	bytes[8] = loMant >> 8;
+	bytes[9] = loMant;
+	
+}
+
+#ifndef HUGE_VAL
+# define HUGE_VAL HUGE
+#endif							/* HUGE_VAL */
+
+# define UnsignedToFloat(u)(((double)((Int_32)(u - (Int_32)(2147483647) - 1))) + 2147483648.0)
+
+/****************************************************************
+ * Extended precision IEEE floating-point conversion routine.
+ ****************************************************************/
+
+double ConvertFromIeeeExtended(const extended80 * x)
+{								/* LCN */ /* ? */
+	double f;
+	int expon;
+	Int_32 hiMant, loMant;
+	const char * bytes = x->data;
+
+	expon = ((bytes[0] & 0x7F) << 8) | (bytes[1] & 0xFF);
+	hiMant = ((int)(bytes[2] & 0xFF) << 24)
+		| ((int)(bytes[3] & 0xFF) << 16)
+		| ((int)(bytes[4] & 0xFF) << 8)
+		| ((int)(bytes[5] & 0xFF));
+	loMant = ((int)(bytes[6] & 0xFF) << 24)
+		| ((int)(bytes[7] & 0xFF) << 16)
+		| ((int)(bytes[8] & 0xFF) << 8)
+		| ((int)(bytes[9] & 0xFF));
+
+	if (expon == 0 && hiMant == 0 && loMant == 0)
+		f = 0;
+	else {
+		if (expon == 0x7FFF)	/* Infinity or NaN */
+			f = HUGE_VAL;
+		else {
+			expon -= 16383;
+			f = ldexp(UnsignedToFloat(hiMant), expon -= 31);
+			f += ldexp(UnsignedToFloat(loMant), expon -= 32);
+		}
+	}
+
+	if (bytes[0] & 0x80)
+	{
+		f = -f;
+	}
+	
+	return f;
+}
+
+
+}	//	end of namespace Loris
diff --git a/src/loris/AiffData.h b/src/loris/AiffData.h
new file mode 100644
index 0000000..fb07ed2
--- /dev/null
+++ b/src/loris/AiffData.h
@@ -0,0 +1,361 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * AiffData.h
+ *
+ * Declarations of import and export functions.
+ *
+ * Kelly Fitz, 17 Sept 2003 
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "Marker.h"
+
+#include <string>
+#include <vector>
+
+//	in case configure wasn't run (no config.h), 
+//	pick some (hopefully-) reasonable values for
+//	these things and hope for the best...
+#if ! defined( SIZEOF_SHORT )
+#define SIZEOF_SHORT 2
+#endif
+
+#if ! defined( SIZEOF_INT )
+#define SIZEOF_INT 4
+#endif
+
+#if ! defined( SIZEOF_LONG )
+#define SIZEOF_LONG 4	// not for DEC Alpha!
+#endif
+
+
+#if SIZEOF_SHORT == 2
+typedef short 			Int_16;
+typedef unsigned short 	Uint_16;
+#elif SIZEOF_INT == 2
+typedef int 			Int_16;
+typedef unsigned int 	Uint_16;
+#else
+#error "cannot find an appropriate type for 16-bit integers"
+#endif
+
+#if SIZEOF_INT == 4
+typedef int 			Int_32;
+typedef unsigned int 	Uint_32;
+#elif SIZEOF_LONG == 4
+typedef long 			Int_32;
+typedef unsigned long 	Uint_32;
+#else
+#error "cannot find an appropriate type for 32-bit integers"
+#endif
+
+
+//	begin namespace
+namespace Loris {
+
+//	-- chunk types --
+enum 
+{ 
+	ContainerId = 0x464f524d,				// 'FORM' 
+	AiffType = 0x41494646,					// 'AIFF' 
+	CommonId = 0x434f4d4d,					// 'COMM'
+	ApplicationSpecificId = 0x4150504c,		// 'APPL'
+	SosEnvelopesId = 0x534f5365,			// 'SOSe'
+	SoundDataId = 0x53534e44,				// 'SSND'
+	InstrumentId = 0x494e5354,				// 'INST'
+	MarkerId = 0x4d41524b					// 'MARK'
+};
+
+typedef Uint_32 ID;
+typedef char Byte;
+
+struct CkHeader 
+{
+	ID id;
+	Uint_32 size;
+	
+	//	providing this default constructor
+	//	gives clients a way to determine whether
+	//	a chunk has been read and assigned:
+	CkHeader( void ) : id(0), size(0) {}
+};
+
+struct ContainerCk
+{
+	CkHeader header;
+	ID formType;
+};
+
+struct CommonCk
+{
+	CkHeader header;
+	Int_16 channels;			// number of channels 
+	Int_32 sampleFrames;		// channel independent sample frames 
+	Int_16 bitsPerSample;		// number of bits per sample 
+	double srate;				// sampling rate (stored in IEEE 10 byte format)
+};
+
+struct SoundDataCk
+{
+	CkHeader header;	
+	Uint_32 offset;				
+	Uint_32 blockSize;	
+	
+	//	sample frames follow
+	std::vector< Byte > sampleBytes;
+};
+
+struct MarkerCk 
+{ 
+	CkHeader header;	
+	Uint_16  numMarkers; 
+	
+	struct Marker
+	{ 
+		Uint_16  markerID; 
+		Uint_32	 position;	 		// position in uncompressed samples
+		std::string markerName; 
+	}; 
+	
+	std::vector< MarkerCk::Marker > markers;
+}; 
+
+struct InstrumentCk
+{
+	CkHeader header;	
+	Byte	baseNote;		/* all notes are MIDI note numbers */ 
+	Byte	detune;			/* cents off, only -50 to +50 are significant */ 
+	Byte	lowNote; 
+	Byte	highNote; 
+	Byte	lowVelocity;	/* 1 to 127 */ 
+	Byte	highVelocity;	/* 1 to 127 */ 
+	Int_16	gain;			/* in dB, 0 is normal */ 
+
+	struct Loop 
+	{ 
+		Int_16	playMode;	/* 0 - no loop, 1 - forward looping, 2 - backward looping */ 
+		Uint_16 beginLoop;	/* this is a reference to a markerID, so you always 
+	ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊ have to work with MARK and INST together!! */ 
+		Uint_16 endLoop; 
+	}; 
+
+	Loop sustainLoop;
+	Loop releaseLoop; 
+}; 
+
+
+struct SosEnvelopesCk
+{
+	CkHeader header;	
+	Int_32	signature;		// For SOS, should be 'SOSe'
+	Int_32	enhanced;		// 0 for sine-only, 1 for bandwidth-enhanced
+	Int_32	validPartials;	// Number of partials with data in them; the file must
+							// be padded out to the next higher 2**n partials;
+							// this number is doubled for enhanced files
+	
+	//	skip validPartials * sizeof(Int_32) bytes of junk here
+	Int_32	resolution;		// frame duration in microseconds 
+	Int_32	quasiHarmonic;	// how many of the partials are quasiharmonic
+	//	skip 
+	//		(4*LargestLabel + 8 - validPartials - 2) * sizeof(Int_32) 
+	//	bytes of junk here	
+
+/*				
+	//	this stuff is unbelievably nasty!						
+	
+#define initPhaseLth ( 4*LargestLabel + 8 )
+	Int_32	initPhase[initPhaseLth]; // obsolete initial phase array; is VARIABLE LENGTH array 
+							// this is big enough for a max of 512 enhanced partials plus values below
+//	Int_32	resolution;		// frame duration in microseconds 
+	#define SOSresolution( es )   initPhase[ spcEI.enhanced \
+											? 2 * spcEI.numPartials : spcEI.numPartials]	
+							// follows the initPhase[] array
+	
+							
+//	Int_32	quasiHarmonic;	// how many of the partials are quasiharmonic
+	#define SOSquasiHarmonic( es )  initPhase[ spcEI.enhanced \
+											? 2 * spcEI.numPartials + 1 : spcEI.numPartials + 1]	
+							// follows the initPhase[] array
+*/							
+};
+
+// ---------------------------------------------------------------------------
+//	readChunkHeader
+// ---------------------------------------------------------------------------
+//	Read the id and chunk size from the current file position.
+//	Let exceptions propogate.
+//
+std::istream &  
+readChunkHeader( std::istream & s, CkHeader & h );
+
+
+// ---------------------------------------------------------------------------
+//	readApplicationSpecifcData
+// ---------------------------------------------------------------------------
+//	Read the data in the ApplicationSpecific chunk, assume the stream is 
+//	correctly positioned, and that the chunk header has already been read.
+//
+//  Look for data specific to SPC files. Any other kind of Application 
+//	Specific data is ignored.
+//
+std::istream & 
+readApplicationSpecifcData( std::istream & s, SosEnvelopesCk & ck, unsigned long chunkSize );
+
+
+// ---------------------------------------------------------------------------
+//	readCommonData
+// ---------------------------------------------------------------------------
+//	Read the data in the Common chunk, assume the stream is correctly
+//	positioned, and that the chunk header has already been read.
+//
+std::istream & 
+readCommonData( std::istream & s, CommonCk & ck, unsigned long chunkSize );
+
+// ---------------------------------------------------------------------------
+//	readContainer
+// ---------------------------------------------------------------------------
+//
+std::istream & 
+readContainer( std::istream & s, ContainerCk & ck, unsigned long chunkSize );
+
+// ---------------------------------------------------------------------------
+//	readInstrumentData
+// ---------------------------------------------------------------------------
+//
+std::istream & 
+readInstrumentData( std::istream & s, InstrumentCk & ck, unsigned long chunkSize );
+
+// ---------------------------------------------------------------------------
+//	readMarkerData
+// ---------------------------------------------------------------------------
+//
+std::istream & 
+readMarkerData( std::istream & s, MarkerCk & ck, unsigned long chunkSize );
+
+// ---------------------------------------------------------------------------
+//	readSampleData
+// ---------------------------------------------------------------------------
+//	Read the data in the Sound Data chunk, assume the stream is correctly
+//	positioned, and that the chunk header has already been read.
+//
+std::istream & 
+readSampleData( std::istream & s, SoundDataCk & ck, unsigned long chunkSize );
+
+// ---------------------------------------------------------------------------
+//	configureCommonCk
+// ---------------------------------------------------------------------------
+void 
+configureCommonCk( CommonCk & ck, unsigned long nFrames, unsigned int nChans,
+				   unsigned int bps, double srate  );
+				   
+// ---------------------------------------------------------------------------
+//	configureContainer
+// ---------------------------------------------------------------------------
+//	dataSize is the combined size of all other chunks in file. Configure 
+//	them first, then add their sizes (with headers!).
+//
+void 
+configureContainer( ContainerCk & ck, unsigned long dataSize );
+
+// ---------------------------------------------------------------------------
+//	configureInstrumentCk
+// ---------------------------------------------------------------------------
+void 
+configureInstrumentCk( InstrumentCk & ck, double midiNoteNum );
+
+// ---------------------------------------------------------------------------
+//	configureMarkerCk
+// ---------------------------------------------------------------------------
+void 
+configureMarkerCk( MarkerCk & ck, const std::vector< Marker > & markers, 
+				   double srate  );
+
+// ---------------------------------------------------------------------------
+//	configureSoundDataCk
+// ---------------------------------------------------------------------------
+//
+void 
+configureSoundDataCk( SoundDataCk & ck, const std::vector< double > & samples, 
+					  unsigned int bps  );
+
+// ---------------------------------------------------------------------------
+//	writeCommon
+// ---------------------------------------------------------------------------
+//
+std::ostream &
+writeCommonData( std::ostream & s, const CommonCk & ck );
+
+// ---------------------------------------------------------------------------
+//	writeContainer
+// ---------------------------------------------------------------------------
+//
+std::ostream &
+writeContainer( std::ostream & s, const ContainerCk & ck );
+
+// ---------------------------------------------------------------------------
+//	writeInstrumentData
+// ---------------------------------------------------------------------------
+std::ostream &
+writeInstrumentData( std::ostream & s, const InstrumentCk & ck );
+
+// ---------------------------------------------------------------------------
+//	writeMarkerData
+// ---------------------------------------------------------------------------
+std::ostream &
+writeMarkerData( std::ostream & s, const MarkerCk & ck );
+
+// ---------------------------------------------------------------------------
+//	writeSampleData
+// ---------------------------------------------------------------------------
+//
+std::ostream & 
+writeSampleData( std::ostream & s, const SoundDataCk & ck );
+
+// ---------------------------------------------------------------------------
+//	convertBytesToSamples
+// ---------------------------------------------------------------------------
+//	Convert sample bytes to double precision floating point samples 
+//	(-1.0, 1.0). The samples vector is resized to fit exactly as many
+//	samples as are represented in the bytes vector, and any prior
+//	contents are overwritten.
+//
+void
+convertBytesToSamples( const std::vector< Byte > & bytes, 
+					   std::vector< double > & samples, unsigned int bps );
+
+// ---------------------------------------------------------------------------
+//	convertSamplesToBytes
+// ---------------------------------------------------------------------------
+//	Convert floating point samples (-1.0, 1.0) to bytes. 
+//	The bytes vector is resized to fit exactly as many
+//	samples as are stored in the samples vector, and any prior
+//	contents are overwritten.
+//
+void
+convertSamplesToBytes( const std::vector< double > & samples, 
+					   std::vector< Byte > & bytes, unsigned int bps );
+					   
+} // end of namespace
diff --git a/src/loris/AiffFile.C b/src/loris/AiffFile.C
new file mode 100644
index 0000000..a494098
--- /dev/null
+++ b/src/loris/AiffFile.C
@@ -0,0 +1,591 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * AiffFile.C
+ *
+ * Implementation of AiffFile class for sample import and export in Loris.
+ *
+ * Class AiffFile represents sample data in a AIFF-format samples 
+ * file, and manages file I/O and sample conversion. Since the sound
+ * analysis and synthesis algorithms in Loris and the reassigned
+ * bandwidth-enhanced representation are monaural, AiffFile manages
+ * only monaural (single channel) AIFF-format samples files.
+ *
+ * Kelly Fitz, 8 Jan 2003 
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "AiffFile.h"
+
+#include "AiffData.h"
+#include "LorisExceptions.h"
+#include "Marker.h"
+#include "Notifier.h"
+#include "Synthesizer.h"
+
+#include <algorithm>
+#include <climits>
+#include <fstream>
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+
+// -- construction --
+
+// ---------------------------------------------------------------------------
+//	AiffFile constructor from filename
+// ---------------------------------------------------------------------------
+//!	Initialize an instance of AiffFile by importing sample data from
+//!	the file having the specified filename or path.
+//!
+//!	\param filename is the name or path of an AIFF samples file
+//
+AiffFile::AiffFile( const std::string & filename ) :
+	notenum_( 60 ),
+	rate_( 1 ),		// rate will be overwritten on import
+    numchans_( 1 )
+{
+	readAiffData( filename );
+}
+
+// ---------------------------------------------------------------------------
+//	AiffFile constructor from parameters, no samples.
+// ---------------------------------------------------------------------------
+//!	Initialize an instance of AiffFile having the specified sample 
+//!	rate, preallocating numFrames samples, initialized to zero.
+//!
+//!	\param samplerate is the rate at which Partials are rendered
+//!	\param numFrames is the initial number of (zero) samples. If
+//!	unspecified, no samples are preallocated.
+//
+AiffFile::AiffFile( double samplerate, size_type numFrames /* = 0 */, 
+                    unsigned int numChannels /* = 1 */ ) :
+	notenum_( 60 ),
+	rate_( samplerate ),
+    numchans_( numChannels ),
+	samples_( numFrames * numChannels, 0 )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	AiffFile constructor from sample data
+// ---------------------------------------------------------------------------
+//!	Initialize an instance of AiffFile from a buffer of sample
+//!	data, with the specified sample rate.
+//!
+//!	\param buffer is a pointer to a buffer of floating point samples.
+//!	\param bufferlength is the number of samples in the buffer.
+//!	\param samplerate is the sample rate of the samples in the buffer.
+//
+AiffFile::AiffFile( const double * buffer, size_type bufferlength, double samplerate ) :
+	notenum_( 60 ),
+	rate_( samplerate ),
+    numchans_( 1 )
+{
+	samples_.insert( samples_.begin(), buffer, buffer+bufferlength );
+}
+
+// ---------------------------------------------------------------------------
+//	AiffFile constructor from stereo sample data
+// ---------------------------------------------------------------------------
+//!	Initialize an instance of AiffFile from two buffers of sample
+//!	data, with the specified sample rate. Both buffers must store
+//! the same number (bufferLength) of samples.
+//!
+//!	\param buffer_left is a pointer to a buffer of floating point samples 
+//!        representing the left channel samples.
+//!	\param buffer_right is a pointer to a buffer of floating point samples 
+//!        representing the right channel samples.
+//!	\param bufferlength is the number of samples in the buffer.
+//!	\param samplerate is the sample rate of the samples in the buffer.
+//
+AiffFile::AiffFile( const double * buffer_left, const double * buffer_right, 
+                    size_type bufferlength, double samplerate ) :
+	notenum_( 60 ),
+	rate_( samplerate ),
+    numchans_( 2 )
+{
+    //  interleave the two channels in samples_
+    samples_.resize( 2*bufferlength, 0. );
+    size_type idx = 0;
+    while( idx < samples_.size() )
+    {
+        samples_[ idx++ ] = *buffer_left++;
+        samples_[ idx++ ] = *buffer_right++;
+    }    
+}
+
+// ---------------------------------------------------------------------------
+//	AiffFile constructor from sample data
+// ---------------------------------------------------------------------------
+//!	Initialize an instance of AiffFile from a vector of sample
+//!	data, with the specified sample rate.
+//!
+//!	\param vec is a vector of floating point samples.
+//!	\param samplerate is the sample rate of the samples in the vector.
+//
+AiffFile::AiffFile( const std::vector< double > & vec, double samplerate ) :
+	notenum_( 60 ),
+	rate_( samplerate ),
+    numchans_( 1 ),
+	samples_( vec.begin(), vec.end() )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	AiffFile constructor from stereo sample data
+// ---------------------------------------------------------------------------
+//!	Initialize an instance of AiffFile from two vectors of sample
+//!	data, with the specified sample rate. If the two vectors have different
+//! lengths, the shorter one is padded with zeros.
+//!
+//!	\param vec_left is a vector of floating point samples representing the 
+//!        left channel samples.
+//!	\param vec_right is a vector of floating point samples representing the 
+//!        right channel samples.
+//!	\param samplerate is the sample rate of the samples in the vectors.
+//
+AiffFile::AiffFile( const std::vector< double > & vec_left,
+                    const std::vector< double > & vec_right, 
+                    double samplerate ) :
+	notenum_( 60 ),
+	rate_( samplerate ),
+    numchans_( 2 ),
+	samples_( 2 * std::max( vec_left.size(), vec_right.size() ), 0. )
+{
+    //  interleave the two channels in samples_
+    size_type idx = 0;
+    std::vector< double >::const_iterator iter_left = vec_left.begin();
+    std::vector< double >::const_iterator iter_right= vec_right.begin();
+    while( idx < samples_.size() )
+    {
+        if ( iter_left != vec_left.end() )
+        {
+            samples_[ idx ] = *iter_left++;
+        }
+        if ( iter_right != vec_right.end() )
+        {
+            samples_[ idx+1 ] = *iter_right++;
+        }
+        idx += 2;
+    }    
+}
+
+// ---------------------------------------------------------------------------
+//	AiffFile copy constructor 
+// ---------------------------------------------------------------------------
+//!	Initialize this and AiffFile that is an exact copy, having
+//!	all the same sample data, as another AiffFile.
+//!
+//!	\param other is the AiffFile to copy
+//
+AiffFile::AiffFile( const AiffFile & other ) :
+	notenum_( other.notenum_ ),
+	rate_( other.rate_ ),
+    numchans_( other.numchans_ ),
+	markers_( other.markers_ ),
+	samples_( other.samples_ )
+{
+}
+	 
+// ---------------------------------------------------------------------------
+//	AiffFile assignment operator 
+// ---------------------------------------------------------------------------
+//!	Assignment operator: change this AiffFile to be an exact copy
+//!	of the specified AiffFile, rhs, that is, having the same sample
+//!	data.
+//!
+//!	\param rhs is the AiffFile to replicate
+//
+AiffFile & 
+AiffFile::operator= ( const AiffFile & rhs )
+{
+	if ( &rhs != this )
+	{
+		// 	before modifying anything, make
+		//	sure there's enough space:
+		samples_.reserve( rhs.samples_.size() );
+		markers_.reserve( rhs.markers_.size() );
+	
+		notenum_ = rhs.notenum_;
+		rate_ = rhs.rate_;
+        numchans_ = rhs.numchans_;
+		markers_ = rhs.markers_;
+		samples_ = rhs.samples_;
+	}
+	return *this;
+}
+
+// -- export --
+
+// ---------------------------------------------------------------------------
+//	write 
+// ---------------------------------------------------------------------------
+//!	Export the sample data represented by this AiffFile to
+//!	the file having the specified filename or path. Export
+//!	signed integer samples of the specified size, in bits
+//!	(8, 16, 24, or 32).
+//!
+//!	\param filename is the name or path of the AIFF samples file
+//!	to be created or overwritten.
+//!	\param bps is the number of bits per sample to store in the
+//!	samples file (8, 16, 24, or 32).If unspeicified, 16 bits
+//!	is assumed.
+//
+void
+AiffFile::write( const std::string & filename, unsigned int bps )
+{
+	static const unsigned int ValidSizes[] = { 8, 16, 24, 32 };
+	if ( std::find( ValidSizes, ValidSizes+4, bps ) == ValidSizes+4 )
+	{
+		Throw( InvalidArgument, "Invalid bits-per-sample." );
+	}
+
+	std::ofstream s( filename.c_str(), std::ofstream::binary );
+	if ( ! s )
+	{
+		std::string s = "Could not create file \"";
+		s += filename;
+		s += "\". Failed to write AIFF file.";
+		Throw( FileIOException, s );
+	}
+	
+	unsigned long dataSize = 0;
+
+	CommonCk commonChunk;
+	configureCommonCk( commonChunk, samples_.size() / numchans_, numchans_, bps, rate_ );
+	dataSize += commonChunk.header.size + sizeof(CkHeader);
+	
+	SoundDataCk soundDataChunk;
+	configureSoundDataCk( soundDataChunk, samples_, bps );
+	dataSize += soundDataChunk.header.size + sizeof(CkHeader);
+	
+	InstrumentCk instrumentChunk;
+	configureInstrumentCk( instrumentChunk, notenum_ );
+	dataSize += instrumentChunk.header.size + sizeof(CkHeader);
+
+	MarkerCk markerChunk;
+	if ( ! markers_.empty() )
+	{
+		configureMarkerCk( markerChunk, markers_, rate_ );
+		dataSize += markerChunk.header.size + sizeof(CkHeader);
+	}
+	
+	ContainerCk containerChunk;
+	configureContainer( containerChunk, dataSize );
+	
+	try 
+	{
+		writeContainer( s, containerChunk );
+		writeCommonData( s, commonChunk );
+		if ( ! markers_.empty() )
+			writeMarkerData( s, markerChunk );
+		writeInstrumentData( s, instrumentChunk );
+		writeSampleData( s, soundDataChunk );
+		
+		s.close();
+	}
+	catch ( Exception & ex ) 
+	{
+		ex.append( " Failed to write AIFF file." );
+		throw;
+	}
+}
+
+// -- access --
+
+// ---------------------------------------------------------------------------
+//	markers 
+// ---------------------------------------------------------------------------
+//!	Return a reference to the Marker (see Marker.h) container 
+//!	for this AiffFile. 
+//
+AiffFile::markers_type & 
+AiffFile::markers( void )
+{
+	return markers_;
+}
+
+//!	Return a const reference to the Marker (see Marker.h) container 
+//!	for this AiffFile. 
+//
+const AiffFile::markers_type & 
+AiffFile::markers( void ) const
+{
+	return markers_;
+}
+
+// ---------------------------------------------------------------------------
+//	midiNoteNumber 
+// ---------------------------------------------------------------------------
+//!	Return the fractional MIDI note number assigned to this AiffFile. 
+//!	If the sound has no definable pitch, note number 60.0 is used.
+//
+double 
+AiffFile::midiNoteNumber( void ) const
+{
+	return notenum_;
+}
+
+// ---------------------------------------------------------------------------
+//	numChannels 
+// ---------------------------------------------------------------------------
+//!	Return the number of channels of audio samples represented by
+//! this AiffFile, 1 for mono, 2 for stereo.
+//
+unsigned int 
+AiffFile::numChannels( void ) const
+{
+    return numchans_;
+}
+
+// ---------------------------------------------------------------------------
+//	numFrames 
+// ---------------------------------------------------------------------------
+//!	Return the number of sample frames represented in this AiffFile.
+//!	A sample frame contains one sample per channel for a single sample
+//!	interval (e.g. mono and stereo samples files having a sample rate of
+//!	44100 Hz both have 44100 sample frames per second of audio samples).
+//
+ AiffFile::size_type  
+ AiffFile::numFrames( void ) const
+ {
+ 	return samples_.size();
+ }
+
+// ---------------------------------------------------------------------------
+//	sampleRate 
+// ---------------------------------------------------------------------------
+//!	Return the sampling freqency in Hz for the sample data in this
+//!	AiffFile.
+//
+double  
+AiffFile::sampleRate( void ) const
+{
+	return rate_;
+}
+
+// ---------------------------------------------------------------------------
+//	samples 
+// ---------------------------------------------------------------------------
+//!	Return a reference (or const reference) to the vector containing
+//!	the floating-point sample data for this AiffFile.
+//
+AiffFile::samples_type & 
+AiffFile::samples( void )
+{
+	return samples_;
+}
+
+//!	Return a const reference (or const reference) to the vector containing
+//!	the floating-point sample data for this AiffFile.
+//
+const AiffFile::samples_type & 
+AiffFile::samples( void ) const
+{
+	return samples_;
+}
+
+// -- mutation --
+
+// ---------------------------------------------------------------------------
+//	addPartial 
+// ---------------------------------------------------------------------------
+//! Render the specified Partial using the (optionally) specified
+//! Partial fade time (see Synthesizer.h for an examplanation 
+//!	of fade time), and accumulate the resulting samples into
+//! the sample vector for this AiffFile. Other synthesis parameters 
+//!	are taken from the Synthesizer DefaultParameters.
+//!
+//!	\sa Synthesizer::DefaultParameters
+//!
+//!	\param p is the partial to render into this AiffFile
+//!	\param fadeTime is the Partial fade time for rendering
+//!	the Partials on the specified range. If unspecified, the
+//! fade time is taken from the Synthesizer DefaultParameters.
+//
+void 
+AiffFile::addPartial( const Loris::Partial & p, double fadeTime )
+{
+    Synthesizer synth = configureSynthesizer( fadeTime );    
+	synth.synthesize( p );
+}
+
+// ---------------------------------------------------------------------------
+//	setMidiNoteNumber 
+// ---------------------------------------------------------------------------
+//!	Set the fractional MIDI note number assigned to this AiffFile. 
+//!	If the sound has no definable pitch, use note number 60.0 (the default).
+//!
+//!	\param nn is a fractional MIDI note number, 60 is middle C.
+//
+void 
+AiffFile::setMidiNoteNumber( double nn )
+{
+	if ( nn < 0 || nn > 128 )
+	{
+		Throw( InvalidArgument, "MIDI note number outside of the valid range [1,128]" );
+	}
+	notenum_ = nn;
+}
+
+// -- helpers --
+
+// ---------------------------------------------------------------------------
+//	configureSynthesizer 
+// ---------------------------------------------------------------------------
+//	Construct a Synthesizer for rendering Partials and set its fadeTime.
+//	Modify the default synthesizer parameters with this file's sample rate
+//	and, if specified (not equal to FadeTimeUnspecified), the fade time.
+//
+Synthesizer 
+AiffFile::configureSynthesizer( double fadeTime )
+{
+	Synthesizer::Parameters params;
+	params.sampleRate = rate_;
+	
+	if ( FadeTimeUnspecified != fadeTime )
+	{
+		params.fadeTime = fadeTime;
+	}
+	
+	return Synthesizer( params, samples_ );
+}
+
+// ---------------------------------------------------------------------------
+//	readAiffData
+// ---------------------------------------------------------------------------
+//	Import data from an AIFF file on disk.
+//
+void 
+AiffFile::readAiffData( const std::string & filename )
+{
+	ContainerCk containerChunk;
+	CommonCk commonChunk;
+	SoundDataCk soundDataChunk;
+	InstrumentCk instrumentChunk;
+	MarkerCk markerChunk;
+
+	try 
+	{
+		std::ifstream s( filename.c_str(), std::ifstream::binary );
+	
+		//	the Container chunk must be first, read it:
+		readChunkHeader( s, containerChunk.header );
+        if ( !s )
+        {
+			Throw( FileIOException, "File not found, or corrupted." );
+        }
+		if ( containerChunk.header.id != ContainerId )
+        {
+			Throw( FileIOException, "Found no Container chunk." );
+        }
+		readContainer( s, containerChunk, containerChunk.header.size );
+		
+		//	read other chunks, we are only interested in
+		//	the Common chunk, the Sound Data chunk, the Markers: 
+		CkHeader h;
+		while ( readChunkHeader( s, h ) )
+		{			
+			switch (h.id)
+			{
+				case CommonId:
+					readCommonData( s, commonChunk, h.size );
+					if ( commonChunk.channels != 1 )
+					{
+						Throw( FileIOException, 
+							   "Loris only processes single-channel AIFF samples files." );
+					}					
+					if ( commonChunk.bitsPerSample != 8 &&
+						 commonChunk.bitsPerSample != 16 &&
+						 commonChunk.bitsPerSample != 24 &&
+						 commonChunk.bitsPerSample != 32 )
+					{
+						Throw( FileIOException, "Unrecognized sample size." );
+					}										
+					break;
+				case SoundDataId:
+					readSampleData( s, soundDataChunk, h.size );
+					break;
+				case InstrumentId:
+					readInstrumentData( s, instrumentChunk, h.size );
+					break;
+				case MarkerId:
+					readMarkerData( s, markerChunk, h.size );
+					break;
+				default:
+					s.ignore( h.size );
+			}
+		}
+	
+		if ( ! commonChunk.header.id || ! soundDataChunk.header.id )
+		{
+			Throw( FileIOException, 
+				   "Reached end of file before finding both a Common chunk and a Sound Data chunk." );
+		}
+	}
+	catch ( Exception & ex ) 
+	{
+		ex.append( " Failed to read AIFF file." );
+		throw;
+	}
+	
+	
+	//	all the chunks have been read, use them to initialize
+	//	the AiffFile members:
+	rate_ = commonChunk.srate;
+	
+	if ( instrumentChunk.header.id )
+	{
+		notenum_ = instrumentChunk.baseNote;
+		notenum_ -= 0.01 * instrumentChunk.detune;
+	}
+	
+	if ( markerChunk.header.id )
+	{
+		for ( int j = 0; j < markerChunk.numMarkers; ++j )
+		{
+			MarkerCk::Marker & m = markerChunk.markers[j];
+			markers_.push_back( Marker( m.position / rate_, m.markerName ) );
+		}		
+	}
+	
+	convertBytesToSamples( soundDataChunk.sampleBytes, samples_, commonChunk.bitsPerSample );
+	if ( samples_.size() != commonChunk.sampleFrames )
+	{
+		notifier << "Found " << samples_.size() << " frames of "
+				 << commonChunk.bitsPerSample << "-bit sample data." << endl;
+		notifier << "Header says there should be " << commonChunk.sampleFrames 
+				 << "." << endl;
+	}
+}
+
+
+}	//	end of namespace Loris
diff --git a/src/loris/AiffFile.h b/src/loris/AiffFile.h
new file mode 100644
index 0000000..55c2bc7
--- /dev/null
+++ b/src/loris/AiffFile.h
@@ -0,0 +1,388 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * AiffFile.h
+ *
+ * Definition of AiffFile class for sample import and export in Loris.
+ *
+ * Kelly Fitz, 8 Jan 2003 
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#include "Marker.h"
+#include "Synthesizer.h"
+
+#if defined(NO_TEMPLATE_MEMBERS)
+#include "PartialList.h"
+#endif
+
+#include <memory>
+#include <string>
+#include <vector>
+
+//  begin namespace
+namespace Loris {
+
+class Partial;
+
+// ---------------------------------------------------------------------------
+//  class AiffFile
+//
+//! Class AiffFile represents sample data in a AIFF-format samples 
+//! file, and manages file I/O and sample conversion. Since the sound
+//! analysis and synthesis algorithms in Loris and the reassigned
+//! bandwidth-enhanced representation are monaural, AiffFile imports
+//! only monaural (single channel) AIFF-format samples files, though
+//!	it can create and export a new two-channel file from a pair of 
+//!	sample vectors.
+//  
+class AiffFile
+{
+//  -- public interface --
+public:
+
+//  -- types --
+
+    //! The type of the sample storage in an AiffFile.
+    typedef std::vector< double > samples_type;
+    
+    //! The type of all size parameters for AiffFile.
+    typedef samples_type::size_type size_type;
+    
+    //! The type of AIFF marker storage in an AiffFile.
+    typedef std::vector< Marker > markers_type;
+
+//  -- construction --
+
+    //! Initialize an instance of AiffFile by importing sample data from
+    //! the file having the specified filename or path.
+    //!
+    //! \param filename is the name or path of an AIFF samples file
+    explicit AiffFile( const std::string & filename );
+
+    //! Initialize an instance of AiffFile with samples rendered
+    //! from a sequnence of Partials. The Partials in the
+    //! specified half-open (STL-style) range are rendered at 
+    //! the specified sample rate, using the (optionally) 
+    //! specified Partial fade time (see Synthesizer.h
+    //! for an examplanation of fade time). Other synthesis 
+	//!	parameters are taken from the Synthesizer DefaultParameters.
+	//!	
+	//!	\sa Synthesizer::DefaultParameters
+    //!
+    //! \param begin_partials is the beginning of a sequence of Partials
+    //! \param end_partials is (one-past) the end of a sequence of
+    //! Partials
+    //! \param samplerate is the rate (Hz) at which Partials are rendered
+    //! \param fadeTime is the Partial fade time (seconds) for rendering
+    //! the Partials on the specified range. If unspecified, the
+    //! fade time is taken from the Synthesizer DefaultParameters.
+    //!
+    //! If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+    //! only PartialList::const_iterator arguments.
+#if !defined(NO_TEMPLATE_MEMBERS)
+    template<typename Iter>
+    AiffFile( Iter begin_partials, Iter end_partials, 
+              double samplerate, double fadeTime = FadeTimeUnspecified );
+#else
+    AiffFile( PartialList::const_iterator begin_partials, 
+              PartialList::const_iterator end_partials,
+              double samplerate, double fadeTime = FadeTimeUnspecified ); 
+#endif
+
+    //! Initialize an instance of AiffFile having the specified sample 
+    //! rate, preallocating numFrames samples, initialized to zero.
+    //!
+    //! \param samplerate is the rate at which Partials are rendered
+    //! \param numFrames is the initial number of (zero) samples. If
+    //!        unspecified, no samples are preallocated.
+    //! \param numChannels is the number of channels of audio data
+    //!        to preallocate (default 1 channel)
+    AiffFile( double samplerate, size_type numFrames = 0, 
+              unsigned int numChannels = 1 );
+    
+    //! Initialize an instance of AiffFile from a buffer of sample
+    //! data, with the specified sample rate.
+    //!
+    //! \param buffer is a pointer to a buffer of floating point samples.
+    //! \param bufferlength is the number of samples in the buffer.
+    //! \param samplerate is the sample rate of the samples in the buffer.
+    AiffFile( const double * buffer, size_type bufferlength, double samplerate );
+
+    //! Initialize an instance of AiffFile from two buffers of sample
+    //! data, with the specified sample rate. Both buffers must store
+    //! the same number (bufferLength) of samples.
+    //!
+    //! \param buffer_left is a pointer to a buffer of floating point samples 
+    //!        representing the left channel samples.
+    //! \param buffer_right is a pointer to a buffer of floating point samples 
+    //!        representing the right channel samples.
+    //! \param bufferlength is the number of samples in the buffer.
+    //! \param samplerate is the sample rate of the samples in the buffer.
+    //
+    AiffFile( const double * buffer_left, const double * buffer_right, 
+              size_type bufferlength, double samplerate );
+     
+    //! Initialize an instance of AiffFile from a vector of sample
+    //! data, with the specified sample rate.
+    //!
+    //! \param vec is a vector of floating point samples.
+    //! \param samplerate is the sample rate of the samples in the vector.
+    AiffFile( const std::vector< double > & vec, double samplerate );
+    
+    //! Initialize an instance of AiffFile from two vectors of sample
+    //! data, with the specified sample rate. If the two vectors have different
+    //! lengths, the shorter one is padded with zeros.
+    //!
+    //! \param vec_left is a vector of floating point samples representing the 
+    //!        left channel samples.
+    //! \param vec_right is a vector of floating point samples representing the 
+    //!        right channel samples.
+    //! \param samplerate is the sample rate of the samples in the vectors.
+    //
+    AiffFile( const std::vector< double > & vec_left,
+              const std::vector< double > & vec_right, 
+              double samplerate );    
+     
+    //! Initialize this and AiffFile that is an exact copy, having
+    //! all the same sample data, as another AiffFile.
+    //!
+    //! \param other is the AiffFile to copy
+    AiffFile( const AiffFile & other );
+     
+    //! Assignment operator: change this AiffFile to be an exact copy
+    //! of the specified AiffFile, rhs, that is, having the same sample
+    //! data.
+    //!
+    //! \param rhs is the AiffFile to replicate
+    AiffFile & operator= ( const AiffFile & rhs );
+
+//  -- access --
+
+    //! Return a reference to the Marker (see Marker.h) container 
+    //! for this AiffFile. 
+    markers_type & markers( void );
+
+    //! Return a const reference to the Marker (see Marker.h) container 
+    //! for this AiffFile. 
+    const markers_type & markers( void ) const;
+     
+    //! Return the fractional MIDI note number assigned to this AiffFile. 
+    //! If the sound has no definable pitch, note number 60.0 is used.
+    double midiNoteNumber( void ) const;
+
+    //! Return the number of channels of audio samples represented by
+    //! this AiffFile, 1 for mono, 2 for stereo.
+    unsigned int numChannels( void ) const;
+
+    //! Return the number of sample frames represented in this AiffFile.
+    //! A sample frame contains one sample per channel for a single sample
+    //! interval (e.g. mono and stereo samples files having a sample rate of
+    //! 44100 Hz both have 44100 sample frames per second of audio samples).
+    size_type numFrames( void ) const;
+
+    //! Bad old legacy name for numFrames.
+    //! \deprecated Use numFrames instead.
+    size_type sampleFrames( void ) const { return numFrames(); }
+
+    //! Return the sampling freqency in Hz for the sample data in this
+    //! AiffFile.
+    double sampleRate( void ) const;
+    
+    //! Return a reference (or const reference) to the vector containing
+    //! the floating-point sample data for this AiffFile.
+    samples_type & samples( void );
+
+    //! Return a const reference (or const reference) to the vector containing
+    //! the floating-point sample data for this AiffFile.
+    const samples_type & samples( void ) const;
+
+//  -- mutation --
+
+    //! Render the specified Partial using the (optionally) specified
+    //! Partial fade time (see Synthesizer.h for an examplanation 
+	//!	of fade time), and accumulate the resulting samples into
+    //! the sample vector for this AiffFile. Other synthesis parameters 
+	//!	are taken from the Synthesizer DefaultParameters.
+	//!
+	//!	\sa Synthesizer::DefaultParameters
+    //!
+    //! \param p is the partial to render into this AiffFile
+    //! \param fadeTime is the Partial fade time for rendering
+    //! the Partials on the specified range. If unspecified, the
+	//! fade time is taken from the Synthesizer DefaultParameters.
+    void addPartial( const Loris::Partial & p, double fadeTime = FadeTimeUnspecified );
+     
+	//! Accumulate samples rendered from a sequence of Partials.
+	//! The Partials in the specified half-open (STL-style) range are
+	//! rendered at this AiffFile's sample rate, using the (optionally) 
+	//! specified Partial fade time (see Synthesizer.h for an examplanation 
+	//!	of fade time). Other synthesis parameters are taken from the 
+	//!	Synthesizer DefaultParameters.
+	//!	
+	//!	\sa Synthesizer::DefaultParameters
+	//!
+	//! \param begin_partials is the beginning of a sequence of Partials
+	//! \param end_partials is (one-past) the end of a sequence of
+	//! Partials
+	//! \param fadeTime is the Partial fade time for rendering
+	//! the Partials on the specified range. If unspecified, the
+	//! fade time is taken from the Synthesizer DefaultParameters.
+	//! 
+	//! If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+	//! only PartialList::const_iterator arguments.
+#if !defined(NO_TEMPLATE_MEMBERS)
+    template<typename Iter>
+    void addPartials( Iter begin_partials, Iter end_partials, 
+    				  double fadeTime = FadeTimeUnspecified  );
+#else
+    void addPartials( PartialList::const_iterator begin_partials, 
+                      PartialList::const_iterator end_partials,
+                      double fadeTime = FadeTimeUnspecified  );
+#endif
+
+    //! Set the fractional MIDI note number assigned to this AiffFile. 
+    //! If the sound has no definable pitch, use note number 60.0 (the default).
+    //!
+    //! \param nn is a fractional MIDI note number, 60 is middle C.
+    void setMidiNoteNumber( double nn );
+     
+//  -- export --
+
+    //! Export the sample data represented by this AiffFile to
+    //! the file having the specified filename or path. Export
+    //! signed integer samples of the specified size, in bits
+    //! (8, 16, 24, or 32).
+    //!
+    //! \param filename is the name or path of the AIFF samples file
+    //! to be created or overwritten.
+    //! \param bps is the number of bits per sample to store in the
+    //! samples file (8, 16, 24, or 32).If unspeicified, 16 bits
+    void write( const std::string & filename, unsigned int bps = 16 );
+
+private:
+//  -- implementation --
+    double notenum_, rate_;     // MIDI note number and sample rate
+    unsigned int numchans_;
+    markers_type markers_;      // AIFF Markers
+    samples_type samples_;      // floating point samples [-1.0, 1.0]
+
+
+//  -- helpers --
+
+	//	Construct a Synthesizer for rendering Partials and set its fadeTime.
+	//	Modify the default synthesizer parameters with this file's sample rate
+	//	and, if specified (not equal to FadeTimeUnspecified), the fade time.
+	Synthesizer configureSynthesizer( double fadeTime );
+
+	//	Import data from an AIFF file on disk.
+    void readAiffData( const std::string & filename );
+    
+    enum { FadeTimeUnspecified = -9999999 };
+    //	This is not pretty, but it is better (perhaps) than defining two 
+    //	of every member having an optional fade time parameter.
+
+};  //  end of class AiffFile
+
+// -- template members --
+
+// ---------------------------------------------------------------------------
+//  constructor from Partial range
+// ---------------------------------------------------------------------------
+//! Initialize an instance of AiffFile with samples rendered
+//! from a sequnence of Partials. The Partials in the
+//! specified half-open (STL-style) range are rendered at 
+//! the specified sample rate, using the (optionally) 
+//! specified Partial fade time (see Synthesizer.h
+//! for an examplanation of fade time). Other synthesis 
+//!	parameters are taken from the Synthesizer DefaultParameters.
+//!	
+//!	\sa Synthesizer::DefaultParameters
+//!
+//! \param begin_partials is the beginning of a sequence of Partials
+//! \param end_partials is (one-past) the end of a sequence of
+//! Partials
+//! \param samplerate is the rate (Hz) at which Partials are rendered
+//! \param fadeTime is the Partial fade time (seconds) for rendering
+//! the Partials on the specified range. If unspecified, the
+//! fade time is taken from the Synthesizer DefaultParameters.
+//!
+//! If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+//! only PartialList::const_iterator arguments.
+//
+#if !defined(NO_TEMPLATE_MEMBERS)
+template< typename Iter >
+ AiffFile::AiffFile( Iter begin_partials, Iter end_partials, 
+                     double samplerate, double fadeTime ) :
+#else
+ AiffFile::AiffFile( PartialList::const_iterator begin_partials, 
+                     PartialList::const_iterator end_partials,
+                     double samplerate, double fadeTime ) :
+#endif
+//  initializers:
+    notenum_( 60 ),
+    rate_( samplerate ),
+    numchans_( 1 )
+{
+    addPartials( begin_partials, end_partials, fadeTime );
+}
+
+// ---------------------------------------------------------------------------
+//  addPartials 
+// ---------------------------------------------------------------------------
+//! Accumulate samples rendered from a sequence of Partials.
+//! The Partials in the specified half-open (STL-style) range are
+//! rendered at this AiffFile's sample rate, using the (optionally) 
+//! specified Partial fade time (see Synthesizer.h for an examplanation 
+//!	of fade time). Other synthesis parameters are taken from the 
+//!	Synthesizer DefaultParameters.
+//!	
+//!	\sa Synthesizer::DefaultParameters
+//!
+//! \param begin_partials is the beginning of a sequence of Partials
+//! \param end_partials is (one-past) the end of a sequence of
+//! Partials
+//! \param fadeTime is the Partial fade time for rendering
+//! the Partials on the specified range. If unspecified, the
+//! fade time is taken from the Synthesizer DefaultParameters.
+//! 
+//! If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+//! only PartialList::const_iterator arguments.
+//
+#if !defined(NO_TEMPLATE_MEMBERS)
+template< typename Iter >
+void 
+ AiffFile::addPartials( Iter begin_partials, Iter end_partials, double fadeTime )
+#else
+void 
+ AiffFile::addPartials( PartialList::const_iterator begin_partials, 
+                        PartialList::const_iterator end_partials,
+                        double fadeTime )
+#endif
+{ 
+    Synthesizer synth = configureSynthesizer( fadeTime );    
+    synth.synthesize( begin_partials, end_partials );
+} 
+
+}   //  end of namespace Loris
diff --git a/src/loris/Analyzer.C b/src/loris/Analyzer.C
new file mode 100644
index 0000000..7ed7469
--- /dev/null
+++ b/src/loris/Analyzer.C
@@ -0,0 +1,1420 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Analyzer.C
+ *
+ * Implementation of class Loris::Analyzer.
+ *
+ * Kelly Fitz, 5 Dec 99
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+    #include "config.h"
+#endif
+
+#include "Analyzer.h"
+
+#include "AssociateBandwidth.h"
+#include "Breakpoint.h"
+#include "BreakpointEnvelope.h"
+#include "Envelope.h"
+#include "F0Estimate.h"
+#include "LorisExceptions.h"
+#include "KaiserWindow.h"
+#include "Notifier.h"
+#include "Partial.h"
+#include "PartialPtrs.h"
+#include "ReassignedSpectrum.h"
+#include "SpectralPeakSelector.h"
+#include "PartialBuilder.h"
+
+#include "phasefix.h"   //  for frequency/phase fixing at end of analysis
+
+
+
+#include <algorithm>
+#include <cmath>
+#include <functional>   //  for std::plus
+#include <memory>
+#include <numeric>      //  for std::inner_product
+#include <utility>
+#include <vector>
+
+using namespace std;
+
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+    const double Pi = M_PI;
+#else
+    const double Pi = 3.14159265358979324;
+#endif
+
+//  begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//  helpers, used below
+// ---------------------------------------------------------------------------
+static double accumPeakSquaredAmps( double init, 
+                                    const SpectralPeak & pk )
+{
+    return init + (pk.amplitude() * pk.amplitude());
+}
+
+template < class Pair >
+static double compare2nd( const Pair & p1, const Pair & p2 )
+{
+    return p1.second < p2.second;
+}
+
+// ---------------------------------------------------------------------------
+//  LinearEnvelopeBuilder
+// ---------------------------------------------------------------------------
+//  Base class for envelope builders that add a point (possibly) at each
+//  analysis frame. 
+//
+//  TODO: make a dictionary of these things and allow clients to add their
+//  own envelope builders and builder functions, and retrieve them after
+//  analysis.
+class LinearEnvelopeBuilder
+{
+public:
+    virtual ~LinearEnvelopeBuilder( void ) {}
+    virtual LinearEnvelopeBuilder * clone( void ) const = 0;
+    virtual void build( const Peaks & peaks, double frameTime ) = 0;
+    
+    const LinearEnvelope & envelope( void ) const { return mEnvelope; }
+    
+    //  reset (clear) envelope, override if necesssary:
+    virtual void reset( void ) { mEnvelope.clear(); }
+    
+protected:
+
+    LinearEnvelope mEnvelope;   //  build this
+};
+
+// ---------------------------------------------------------------------------
+//  FundamentalBuilder - for constructing an F0 envelope during analysis
+// ---------------------------------------------------------------------------
+class FundamentalBuilder : public LinearEnvelopeBuilder
+{
+    std::auto_ptr< Envelope > mFminEnv;
+    std::auto_ptr< Envelope > mFmaxEnv; 
+    
+    double mAmpThresh, mFreqThresh;
+    
+    std::vector< double > amplitudes, frequencies;
+    
+    const double mMinConfidence;    // 0.9, this could be made a parameter, 
+                                    // or raised to make estimates smoother
+    
+public:
+    FundamentalBuilder( double fmin, double fmax, double threshDb = -60, double threshHz = 8000 ) :
+        mFminEnv( new LinearEnvelope( fmin ) ), 
+        mFmaxEnv( new LinearEnvelope( fmax ) ), 
+        mAmpThresh( std::pow( 10., 0.05*(threshDb) ) ),
+        mFreqThresh( threshHz ),
+        mMinConfidence( 0.9 )
+        {}
+
+    FundamentalBuilder( const Envelope & fmin, const Envelope & fmax, 
+    					double threshDb = -60, double threshHz = 8000 ) :
+        mFminEnv( fmin.clone() ), 
+        mFmaxEnv( fmax.clone() ), 
+        mAmpThresh( std::pow( 10., 0.05*(threshDb) ) ),
+        mFreqThresh( threshHz ),
+        mMinConfidence( 0.9 )
+        {}
+        	
+    FundamentalBuilder( const FundamentalBuilder & rhs ) :
+        mFminEnv( rhs.mFminEnv->clone() ), 
+        mFmaxEnv( rhs.mFmaxEnv->clone() ), 
+        mAmpThresh( rhs.mAmpThresh ),
+        mFreqThresh( rhs.mFreqThresh ),
+        mMinConfidence( rhs.mMinConfidence )
+        {}
+    
+        
+	FundamentalBuilder * clone( void ) const { return new FundamentalBuilder(*this); }
+	
+    void build( const Peaks & peaks, double frameTime );
+};
+
+// ---------------------------------------------------------------------------
+//  FundamentalBuilder::build
+// ---------------------------------------------------------------------------
+//
+void FundamentalBuilder::build( const Peaks & peaks, double frameTime )
+{
+    amplitudes.clear();
+    frequencies.clear();
+    for ( Peaks::const_iterator spkpos = peaks.begin(); spkpos != peaks.end(); ++spkpos )
+    {
+        if ( spkpos->amplitude() > mAmpThresh &&
+             spkpos->frequency() < mFreqThresh )
+        {
+            amplitudes.push_back( spkpos->amplitude() );
+            frequencies.push_back( spkpos->frequency() );
+        }
+    }
+    if ( ! amplitudes.empty() )
+    {
+        const double fmin = mFminEnv->valueAt( frameTime );
+        const double fmax = mFmaxEnv->valueAt( frameTime );
+        
+        //  estimate f0
+        F0Estimate est( amplitudes, frequencies, fmin, fmax, 0.1 );
+        
+        if ( est.confidence() >= mMinConfidence &&
+             est.frequency() > fmin && est.frequency() < fmax  )
+        {
+            // notifier << "f0 is " << est.frequency << endl;
+            //  add breakpoint to fundamental envelope
+            mEnvelope.insert( frameTime, est.frequency() );
+        }
+    }
+    
+}
+
+// ---------------------------------------------------------------------------
+//  AmpEnvBuilder - for constructing an amplitude envelope during analysis
+// ---------------------------------------------------------------------------
+class AmpEnvBuilder : public LinearEnvelopeBuilder
+{
+public:
+    AmpEnvBuilder( void ) {}
+		
+	AmpEnvBuilder * clone( void ) const { return new AmpEnvBuilder(*this); }
+	
+    void build( const Peaks & peaks, double frameTime );
+
+};
+
+// ---------------------------------------------------------------------------
+//  AmpEnvBuilder::build
+// ---------------------------------------------------------------------------
+//
+void AmpEnvBuilder::build( const Peaks & peaks, double frameTime )
+{
+    double x = std::accumulate( peaks.begin(), peaks.end(), 0.0, accumPeakSquaredAmps );
+    mEnvelope.insert( frameTime, std::sqrt( x ) );
+}
+
+
+// ---------------------------------------------------------------------------
+//  Analyzer constructor - frequency resolution only
+// ---------------------------------------------------------------------------
+//! Construct a new Analyzer configured with the given  
+//! frequency resolution (minimum instantaneous frequency   
+//! difference between Partials). All other Analyzer parameters     
+//! are computed from the specified frequency resolution.   
+//! 
+//! \param resolutionHz is the frequency resolution in Hz.
+//
+Analyzer::Analyzer( double resolutionHz )
+{
+    configure( resolutionHz, 2.0 * resolutionHz );
+}
+
+// ---------------------------------------------------------------------------
+//  Analyzer constructor
+// ---------------------------------------------------------------------------
+//! Construct a new Analyzer configured with the given  
+//! frequency resolution (minimum instantaneous frequency   
+//! difference between Partials) and analysis window width
+//! (main lobe, zero-to-zero). All other Analyzer parameters    
+//! are computed from the specified resolution and window width.    
+//! 
+//! \param resolutionHz is the frequency resolution in Hz.
+//! \param windowWidthHz is the main lobe width of the Kaiser
+//! analysis window in Hz.
+//
+Analyzer::Analyzer( double resolutionHz, double windowWidthHz )
+{
+    configure( resolutionHz, windowWidthHz );
+}
+
+// ---------------------------------------------------------------------------
+//  Analyzer constructor
+// ---------------------------------------------------------------------------
+//! Construct a new Analyzer configured with the given time-varying
+//! frequency resolution (minimum instantaneous frequency   
+//! difference between Partials) and analysis window width
+//! (main lobe, zero-to-zero). All other Analyzer parameters    
+//! are computed from the specified resolution and window width.    
+//! 
+//! \param resolutionHz is the frequency resolution in Hz.
+//! \param windowWidthHz is the main lobe width of the Kaiser
+//! analysis window in Hz.
+//
+Analyzer::Analyzer( const Envelope & resolutionEnv, double windowWidthHz )
+{
+    configure( resolutionEnv, windowWidthHz );
+}
+
+// ---------------------------------------------------------------------------
+//  Analyzer copy constructor
+// ---------------------------------------------------------------------------
+//! Construct  a new Analyzer having identical
+//! parameter configuration to another Analyzer. 
+//! The list of collected Partials is not copied.       
+//! 
+//! \param other is the Analyzer to copy.   
+//
+Analyzer::Analyzer( const Analyzer & other ) :
+    m_freqResolutionEnv( other.m_freqResolutionEnv->clone() ),
+    m_ampFloor( other.m_ampFloor ),
+    m_windowWidth( other.m_windowWidth ),
+    m_freqFloor( other.m_freqFloor ),
+    m_freqDrift( other.m_freqDrift ),
+    m_hopTime( other.m_hopTime ),
+    m_cropTime( other.m_cropTime ),
+    m_bwAssocParam( other.m_bwAssocParam ),
+    m_sidelobeLevel( other.m_sidelobeLevel ),
+    m_phaseCorrect( other.m_phaseCorrect ),
+    m_partials( other.m_partials )
+{
+    m_f0Builder.reset( other.m_f0Builder->clone() );
+    m_ampEnvBuilder.reset( other.m_ampEnvBuilder->clone() );
+}
+
+// ---------------------------------------------------------------------------
+//  Analyzer assignment
+// ---------------------------------------------------------------------------
+//! Construct  a new Analyzer having identical
+//! parameter configuration to another Analyzer. 
+//! The list of collected Partials is not copied.       
+//! 
+//! \param rhs is the Analyzer to copy. 
+//
+Analyzer & 
+Analyzer::operator=( const Analyzer & rhs )
+{
+    if ( this != & rhs ) 
+    {
+        m_freqResolutionEnv.reset( rhs.m_freqResolutionEnv->clone() );
+        m_ampFloor = rhs.m_ampFloor;
+        m_windowWidth = rhs.m_windowWidth;
+        m_freqFloor = rhs.m_freqFloor;  
+        m_freqDrift = rhs.m_freqDrift;
+        m_hopTime = rhs.m_hopTime;
+        m_cropTime = rhs.m_cropTime;
+        m_bwAssocParam = rhs.m_bwAssocParam;
+        m_sidelobeLevel = rhs.m_sidelobeLevel;
+        m_phaseCorrect = rhs.m_phaseCorrect;
+        m_partials = rhs.m_partials;
+
+        m_f0Builder.reset( rhs.m_f0Builder->clone() );
+        m_ampEnvBuilder.reset( rhs.m_ampEnvBuilder->clone() );
+                
+    }
+    return *this;
+}
+
+// ---------------------------------------------------------------------------
+//  Analyzer destructor
+// ---------------------------------------------------------------------------
+//! Destroy this Analyzer.
+//
+Analyzer::~Analyzer( void )
+{
+}
+
+// -- configuration --
+
+// ---------------------------------------------------------------------------
+//  configure
+// ---------------------------------------------------------------------------
+//! Configure this Analyzer with the given frequency resolution 
+//! (minimum instantaneous frequency difference between Partials, 
+//! in Hz). All other Analyzer parameters are (re-)computed from the 
+//! frequency resolution, including the window width, which is
+//!	twice the resolution.      
+//! 
+//! \param resolutionHz is the frequency resolution in Hz.
+//
+void
+Analyzer::configure( double resolutionHz )
+{
+	configure( resolutionHz, 2.0 * resolutionHz );
+}
+
+// ---------------------------------------------------------------------------
+//  configure
+// ---------------------------------------------------------------------------
+//! Configure this Analyzer with the given frequency resolution 
+//! (minimum instantaneous frequency difference between Partials)
+//! and analysis window width (main lobe, zero-to-zero, in Hz). 
+//! All other Analyzer parameters are (re-)computed from the 
+//! frequency resolution and window width.      
+//! 
+//! \param resolutionHz is the frequency resolution in Hz.
+//! \param windowWidthHz is the main lobe width of the Kaiser
+//! analysis window in Hz.
+//!     
+//! There are three categories of analysis parameters:
+//! - the resolution, and params that are usually related to (or
+//! identical to) the resolution (frequency floor and drift)
+//! - the window width and params that are usually related to (or
+//! identical to) the window width (hop and crop times)
+//! - independent parameters (bw region width and amp floor)
+//
+void
+Analyzer::configure( double resolutionHz, double windowWidthHz )
+{
+    //  use specified resolution:
+    setFreqResolution( resolutionHz );
+    
+    //  floor defaults to -90 dB:
+    setAmpFloor( -90. );
+    
+    //  window width should generally be approximately 
+    //  equal to, and never more than twice the 
+    //  frequency resolution:
+    setWindowWidth( windowWidthHz );
+    
+    //  the Kaiser window sidelobe level can be the same
+    //  as the amplitude floor (except in positive dB):
+    setSidelobeLevel( - m_ampFloor );
+    
+    //  for the minimum frequency, below which no data is kept,
+    //  use the frequency resolution by default (this makes 
+    //  Lip happy, and is always safe?) and allow the client 
+    //  to change it to anything at all.
+    setFreqFloor( resolutionHz );
+    
+    //  frequency drift in Hz is the maximum difference
+    //  in frequency between consecutive Breakpoints in
+    //  a Partial, by default, make it equal to one half
+    //  the frequency resolution:
+    setFreqDrift( .5 * resolutionHz );
+    
+    //  hop time (in seconds) is the inverse of the
+    //  window width....really. Smith and Serra (1990) cite 
+    //  Allen (1977) saying: a good choice of hop is the window 
+    //  length divided by the main lobe width in frequency samples,
+    //  which turns out to be just the inverse of the width.
+    setHopTime( 1. / m_windowWidth );
+    
+    //  crop time (in seconds) is the maximum allowable time
+    //  correction, beyond which a reassigned spectral component
+    //  is considered unreliable, and not considered eligible for
+    //  Breakpoint formation in extractPeaks(). By default, use
+    //  the hop time (should it be half that?):
+    setCropTime( m_hopTime );
+    
+    //  bandwidth association region width 
+    //  defaults to 2 kHz, corresponding to 
+    //  1 kHz region center spacing:
+    storeResidueBandwidth();
+
+	//  configure the envelope builders using default 
+	//  parameters:
+	buildFundamentalEnv( 0.99 * resolutionHz,
+                         1.5 * resolutionHz );
+    m_ampEnvBuilder.reset( new AmpEnvBuilder );
+    
+    //  enable phase-correct Partial construction:
+    m_phaseCorrect = true;
+}
+
+// ---------------------------------------------------------------------------
+//  configure
+// ---------------------------------------------------------------------------
+//! Configure this Analyzer with the given time-varying frequency resolution 
+//! (minimum instantaneous frequency difference between Partials)
+//! and analysis window width (main lobe, zero-to-zero, in Hz). 
+//! All other Analyzer parameters are (re-)computed from the 
+//! frequency resolution and window width.      
+//! 
+//! \param resolutionEnv is the time-varying frequency resolution 
+//!	in Hz.
+//! \param windowWidthHz is the main lobe width of the Kaiser
+//! analysis window in Hz.
+//!     
+//! There are three categories of analysis parameters:
+//! - the resolution, and params that are usually related to (or
+//! identical to) the resolution (frequency floor and drift)
+//! - the window width and params that are usually related to (or
+//! identical to) the window width (hop and crop times)
+//! - independent parameters (bw region width and amp floor)
+//
+void
+Analyzer::configure( const Envelope & resolutionEnv, double windowWidthHz )
+{
+    //  use specified resolution:
+    setFreqResolution( resolutionEnv );
+    
+    //  floor defaults to -90 dB:
+    setAmpFloor( -90. );
+    
+    //  window width should generally be approximately 
+    //  equal to, and never more than twice the 
+    //  frequency resolution:
+    setWindowWidth( windowWidthHz );
+    
+    //  the Kaiser window sidelobe level can be the same
+    //  as the amplitude floor (except in positive dB):
+    setSidelobeLevel( - m_ampFloor );
+    
+    //  for the minimum frequency, below which no data is kept,
+    //  use the frequency resolution by default (this makes 
+    //  Lip happy, and is always safe?) and allow the client 
+    //  to change it to anything at all.
+    setFreqFloor( windowWidthHz * 0.5 );		//	!!!!!
+    
+    //  frequency drift in Hz is the maximum difference
+    //  in frequency between consecutive Breakpoints in
+    //  a Partial, by default, make it equal to one half
+    //  the frequency resolution:
+    setFreqDrift( windowWidthHz * 0.25 );		//	!!!!!
+    
+    //  hop time (in seconds) is the inverse of the
+    //  window width....really. Smith and Serra (1990) cite 
+    //  Allen (1977) saying: a good choice of hop is the window 
+    //  length divided by the main lobe width in frequency samples,
+    //  which turns out to be just the inverse of the width.
+    setHopTime( 1. / m_windowWidth );
+    
+    //  crop time (in seconds) is the maximum allowable time
+    //  correction, beyond which a reassigned spectral component
+    //  is considered unreliable, and not considered eligible for
+    //  Breakpoint formation in extractPeaks(). By default, use
+    //  the hop time (should it be half that?):
+    setCropTime( m_hopTime );
+    
+    //  bandwidth association region width 
+    //  defaults to 2 kHz, corresponding to 
+    //  1 kHz region center spacing:
+    storeResidueBandwidth();
+
+	//  configure the envelope builders using default 
+	//  parameters:
+	/*
+	buildFundamentalEnv( *m_freqResolutionEnv * 0.99,
+                         *m_freqResolutionEnv * 1.5 );
+      
+     */	//	!!!!!!!
+	m_f0Builder.reset( 
+        new FundamentalBuilder( *m_freqResolutionEnv * 0.99,
+        						*m_freqResolutionEnv * 1.5,
+        						-60., 8000. ) );
+        
+    m_ampEnvBuilder.reset( new AmpEnvBuilder );
+    
+    //  enable phase-correct Partial construction:
+    m_phaseCorrect = true;
+}
+
+// -- analysis --
+// ---------------------------------------------------------------------------
+//  analyze
+// ---------------------------------------------------------------------------
+//! Analyze a vector of (mono) samples at the given sample rate         
+//! (in Hz) and store the extracted Partials in the Analyzer's
+//! PartialList (std::list of Partials). 
+//! 
+//! \param vec is a vector of floating point samples
+//! \param srate is the sample rate of the samples in the vector 
+//
+void 
+Analyzer::analyze( const std::vector<double> & vec, double srate )      
+{ 
+    BreakpointEnvelope reference( 1.0 );
+    analyze( &(vec[0]),  &(vec[0]) + vec.size(), srate, reference ); 
+}
+
+// ---------------------------------------------------------------------------
+//  analyze
+// ---------------------------------------------------------------------------
+//! Analyze a range of (mono) samples at the given sample rate      
+//! (in Hz) and store the extracted Partials in the Analyzer's
+//! PartialList (std::list of Partials). 
+//! 
+//! \param bufBegin is a pointer to a buffer of floating point samples
+//! \param bufEnd is (one-past) the end of a buffer of floating point 
+//! samples
+//! \param srate is the sample rate of the samples in the buffer
+//
+void 
+Analyzer::analyze( const double * bufBegin, const double * bufEnd, double srate )
+{ 
+    BreakpointEnvelope reference( 1.0 );
+    analyze( bufBegin,  bufEnd, srate, reference ); 
+}
+
+// ---------------------------------------------------------------------------
+//  analyze
+// ---------------------------------------------------------------------------
+//! Analyze a vector of (mono) samples at the given sample rate         
+//! (in Hz) and store the extracted Partials in the Analyzer's
+//! PartialList (std::list of Partials). Use the specified envelope
+//! as a frequency reference for Partial tracking.
+//!
+//! \param vec is a vector of floating point samples
+//! \param srate is the sample rate of the samples in the vector
+//! \param reference is an Envelope having the approximate
+//! frequency contour expected of the resulting Partials.
+//
+void 
+Analyzer::analyze( const std::vector<double> & vec, double srate, 
+                   const Envelope & reference )     
+{ 
+    analyze( &(vec[0]),  &(vec[0]) + vec.size(), srate, reference ); 
+}
+
+
+// ---------------------------------------------------------------------------
+//  analyze
+// ---------------------------------------------------------------------------
+//! Analyze a range of (mono) samples at the given sample rate      
+//! (in Hz) and store the extracted Partials in the Analyzer's
+//! PartialList (std::list of Partials). Use the specified envelope
+//! as a frequency reference for Partial tracking.
+//! 
+//! \param bufBegin is a pointer to a buffer of floating point samples
+//! \param bufEnd is (one-past) the end of a buffer of floating point 
+//! samples
+//! \param srate is the sample rate of the samples in the buffer
+//! \param reference is an Envelope having the approximate
+//! frequency contour expected of the resulting Partials.
+//
+void 
+Analyzer::analyze( const double * bufBegin, const double * bufEnd, double srate,
+                   const Envelope & reference )
+{ 
+    //  configure the reassigned spectral analyzer, 
+    //  always use odd-length windows:
+
+    //  Kaiser window
+    double winshape = KaiserWindow::computeShape( sidelobeLevel() );
+    long winlen = KaiserWindow::computeLength( windowWidth() / srate, winshape );    
+    if (! (winlen % 2)) 
+    {
+        ++winlen;
+    }
+    debugger << "Using Kaiser window of length " << winlen << endl;
+    
+    std::vector< double > window( winlen );
+    KaiserWindow::buildWindow( window, winshape );
+    
+    std::vector< double > windowDeriv( winlen );
+    KaiserWindow::buildTimeDerivativeWindow( windowDeriv, winshape );
+       
+    ReassignedSpectrum spectrum( window, windowDeriv );   
+    
+    //  configure the peak selection and partial formation policies:
+    SpectralPeakSelector selector( srate, m_cropTime );
+    PartialBuilder builder( m_freqDrift, reference );
+    
+    //  configure bw association policy, unless
+    //  bandwidth association is disabled:
+    std::auto_ptr< AssociateBandwidth > bwAssociator;
+    if( m_bwAssocParam > 0 )
+    {
+        debugger << "Using bandwidth association regions of width " 
+                 << bwRegionWidth() << " Hz" << endl;
+        bwAssociator.reset( new AssociateBandwidth( bwRegionWidth(), srate ) );
+    }
+    else
+    {
+        debugger << "Bandwidth association disabled" << endl;
+    }
+
+    //  reset envelope builders:
+    m_ampEnvBuilder->reset();
+    m_f0Builder->reset();
+    
+    m_partials.clear();
+        
+    try 
+    { 
+        const double * winMiddle = bufBegin; 
+
+        //  loop over short-time analysis frames:
+        while ( winMiddle < bufEnd )
+        {
+            //  compute the time of this analysis frame:
+            const double currentFrameTime = long(winMiddle - bufBegin) / srate;
+            
+            //  compute reassigned spectrum:
+            //  sampsBegin is the position of the first sample to be transformed,
+            //  sampsEnd is the position after the last sample to be transformed.
+            //  (these computations work for odd length windows only)
+            const double * sampsBegin = std::max( winMiddle - (winlen / 2), bufBegin );
+            const double * sampsEnd = std::min( winMiddle + (winlen / 2) + 1, bufEnd );
+            spectrum.transform( sampsBegin, winMiddle, sampsEnd );
+            
+             
+            //  extract peaks from the spectrum, and thin
+            Peaks peaks = selector.selectPeaks( spectrum, m_freqFloor ); 
+			Peaks::iterator rejected = thinPeaks( peaks, currentFrameTime );
+
+            //	fix the stored bandwidth values
+            //	KLUDGE: need to do this before the bandwidth
+            //	associator tries to do its job, because the mixed
+            //	derivative is temporarily stored in the Breakpoint 
+            //	bandwidth!!! FIX!!!!
+            fixBandwidth( peaks );
+            
+            if ( m_bwAssocParam > 0 )
+            {
+                bwAssociator->associateBandwidth( peaks.begin(), rejected, peaks.end() );
+            }
+            
+            //  remove rejected Breakpoints (needed above to 
+            //  compute bandwidth envelopes):
+            peaks.erase( rejected, peaks.end() );
+            
+            //  estimate the amplitude in this frame:
+            m_ampEnvBuilder->build( peaks, currentFrameTime );
+                        
+            //  collect amplitudes and frequencies and try to 
+            //  estimate the fundamental
+            m_f0Builder->build( peaks, currentFrameTime );          
+
+            //  form Partials from the extracted Breakpoints:
+            builder.buildPartials( peaks, currentFrameTime );
+            
+            //  slide the analysis window:
+            winMiddle += long( m_hopTime * srate ); //  hop in samples, truncated
+
+        }   //  end of loop over short-time frames
+        
+        //  unwarp the Partial frequency envelopes:
+        builder.finishBuilding( m_partials );
+        
+        //  fix the frequencies and phases to be consistent.
+        if ( m_phaseCorrect )
+        {
+            fixFrequency( m_partials.begin(), m_partials.end() );
+        }
+        
+        
+        //  for debugging:
+        /*
+        if ( ! m_ampEnv.empty() )
+        {
+            LinearEnvelope::iterator peakpos = 
+                std::max_element( m_ampEnv.begin(), m_ampEnv.end(), 
+                                  compare2nd<LinearEnvelope::iterator::value_type> );
+            notifier << "Analyzer found amp peak at time : " << peakpos->first
+                     << " value: " << peakpos->second << endl;
+        }
+        */
+    }
+    catch ( Exception & ex ) 
+    {
+        ex.append( "analysis failed." );
+        throw;
+    }
+}
+
+// -- parameter access --
+
+// ---------------------------------------------------------------------------
+//  ampFloor
+// ---------------------------------------------------------------------------
+//! Return the amplitude floor (lowest detected spectral amplitude),            
+//! in (negative) dB, for this Analyzer.                
+//
+double 
+Analyzer::ampFloor( void ) const 
+{ 
+    return m_ampFloor; 
+}
+
+// ---------------------------------------------------------------------------
+//  cropTime
+// ---------------------------------------------------------------------------
+//! Return the crop time (maximum temporal displacement of a time-
+//! frequency data point from the time-domain center of the analysis
+//! window, beyond which data points are considered "unreliable")
+//! for this Analyzer.
+//
+double 
+Analyzer::cropTime( void ) const 
+{ 
+    // debugger << "Analyzer::cropTime() is a deprecated member, and will be removed in a future Loris release." << endl;
+    return m_cropTime; 
+}
+
+// ---------------------------------------------------------------------------
+//  freqDrift
+// ---------------------------------------------------------------------------
+//! Return the maximum allowable frequency difference 
+//! consecutive Breakpoints in a Partial envelope for this Analyzer.                
+//
+double 
+Analyzer::freqDrift( void ) const 
+{ 
+    return m_freqDrift;
+}
+
+// ---------------------------------------------------------------------------
+//  freqFloor
+// ---------------------------------------------------------------------------
+//! Return the frequency floor (minimum instantaneous Partial               
+//! frequency), in Hz, for this Analyzer.               
+//
+double 
+Analyzer::freqFloor( void ) const 
+{ 
+    return m_freqFloor; 
+}
+
+// ---------------------------------------------------------------------------
+//  freqResolution
+// ---------------------------------------------------------------------------
+//! Return the frequency resolution (minimum instantaneous frequency        
+//! difference between Partials) for this Analyzer at the specified
+//! time in seconds. If no time is specified, then the initial resolution
+//!	(at 0 seconds) is returned.
+//! 
+//! \param time is the time in seconds at which to evaluate the 
+//!		   frequency resolution
+//
+double 
+Analyzer::freqResolution( double time /* = 0.0 */ ) const 
+{ 
+    return m_freqResolutionEnv->valueAt( time ); 
+}
+
+// ---------------------------------------------------------------------------
+//  hopTime
+// ---------------------------------------------------------------------------
+//! Return the hop time (which corresponds approximately to the 
+//! average density of Partial envelope Breakpoint data) for this 
+//! Analyzer.
+//
+double 
+Analyzer::hopTime( void ) const 
+{ 
+    return m_hopTime; 
+}
+
+// ---------------------------------------------------------------------------
+//  sidelobeLevel
+// ---------------------------------------------------------------------------
+//! Return the sidelobe attenutation level for the Kaiser analysis window in
+//! positive dB. Larger numbers (e.g. 90) give very good sidelobe 
+//! rejection but cause the window to be longer in time. Smaller numbers 
+//! (like 60) raise the level of the sidelobes, increasing the likelihood
+//! of frequency-domain interference, but allow the window to be shorter
+//! in time.
+//
+double 
+Analyzer::sidelobeLevel( void ) const 
+{ 
+    return m_sidelobeLevel; 
+}
+
+// ---------------------------------------------------------------------------
+//  windowWidth
+// ---------------------------------------------------------------------------
+//! Return the frequency-domain main lobe width (measured between 
+//! zero-crossings) of the analysis window used by this Analyzer.               
+//
+double 
+Analyzer::windowWidth( void ) const 
+{ 
+    return m_windowWidth; 
+}
+
+// ---------------------------------------------------------------------------
+//  phaseCorrect
+// ---------------------------------------------------------------------------
+//! Return true if the phases and frequencies of the constructed
+//! partials should be modified to be consistent at the end of the
+//! analysis, and false otherwise. (Default is true.)
+//!
+//! \param  TF is a flag indicating whether or not to construct
+//!         phase-corrected Partials
+bool 
+Analyzer::phaseCorrect( void ) const
+{
+    return m_phaseCorrect;
+}
+
+// -- parameter mutation --
+
+#define VERIFY_ARG(func, test)                                          \
+    do {                                                                \
+        if (!(test))                                                    \
+            Throw( Loris::InvalidArgument, #func ": " #test  );         \
+    } while (false)
+
+
+// ---------------------------------------------------------------------------
+//  setAmpFloor
+// ---------------------------------------------------------------------------
+//! Set the amplitude floor (lowest detected spectral amplitude), in            
+//! (negative) dB, for this Analyzer. 
+//! 
+//! \param x is the new value of this parameter.                
+//
+void 
+Analyzer::setAmpFloor( double x ) 
+{ 
+    VERIFY_ARG( setAmpFloor, x < 0 );
+    m_ampFloor = x; 
+}
+
+
+// ---------------------------------------------------------------------------
+//  setCropTime
+// ---------------------------------------------------------------------------
+//! Set the crop time (maximum temporal displacement of a time-
+//! frequency data point from the time-domain center of the analysis
+//! window, beyond which data points are considered "unreliable")
+//! for this Analyzer.
+//! 
+//! \param x is the new value of this parameter.
+//
+void 
+Analyzer::setCropTime( double x ) 
+{ 
+    VERIFY_ARG( setCropTime, x > 0 );
+   // debugger << "Analyzer::setCropTime() is a deprecated member, and will be removed in a future Loris release." << endl;
+    m_cropTime = x; 
+}
+
+// ---------------------------------------------------------------------------
+//  setFreqDrift
+// ---------------------------------------------------------------------------
+//! Set the maximum allowable frequency difference between                  
+//! consecutive Breakpoints in a Partial envelope for this Analyzer.                
+//! 
+//! \param x is the new value of this parameter.            
+//
+void 
+Analyzer::setFreqDrift( double x ) 
+{ 
+    VERIFY_ARG( setFreqDrift, x > 0 );
+    m_freqDrift = x; 
+}
+
+// ---------------------------------------------------------------------------
+//  setFreqFloor
+// ---------------------------------------------------------------------------
+//! Set the frequency floor (minimum instantaneous Partial                  
+//! frequency), in Hz, for this Analyzer.
+//! 
+//! \param x is the new value of this parameter.                    
+//
+void 
+Analyzer::setFreqFloor( double x ) 
+{ 
+    VERIFY_ARG( setFreqFloor, x >= 0 );
+    m_freqFloor = x; 
+}
+
+// ---------------------------------------------------------------------------
+//  setFreqResolution (constant)
+// ---------------------------------------------------------------------------
+//! Set the frequency resolution (minimum instantaneous frequency       
+//! difference between Partials) for this Analyzer. (Does not cause     
+//! other parameters to be recomputed.)                                     
+//! 
+//! \param x is the new value of this parameter.                                        
+//
+void 
+Analyzer::setFreqResolution( double x ) 
+{ 
+    VERIFY_ARG( setFreqResolution, x > 0 );
+    m_freqResolutionEnv.reset( new LinearEnvelope( x ) ); 
+}
+
+// ---------------------------------------------------------------------------
+//  setFreqResolution (envelope)
+// ---------------------------------------------------------------------------
+//! Set the time-varying frequency resolution (minimum instantaneous frequency       
+//! difference between Partials) for this Analyzer. (Does not cause     
+//! other parameters to be recomputed.)                                     
+//! 
+//! \param e is the envelope to copy for this parameter.                                        
+//
+void 
+Analyzer::setFreqResolution( const Envelope & e ) 
+{ 
+	//	No mechanism exists to verify that the envelope never
+	//	drops below zero, this can only be checked at analysis-time.
+    // VERIFY_ARG( setFreqResolution, x > 0 );
+    m_freqResolutionEnv.reset( e.clone() ); 
+}
+
+// ---------------------------------------------------------------------------
+//  setSidelobeLevel
+// ---------------------------------------------------------------------------
+//! Set the sidelobe attenutation level for the Kaiser analysis window in
+//! positive dB. Higher numbers (e.g. 90) give very good sidelobe 
+//! rejection but cause the window to be longer in time. Lower 
+//! numbers raise the level of the sidelobes, increasing the likelihood
+//! of frequency-domain interference, but allow the window to be shorter
+//! in time.
+//! 
+//! \param x is the new value of this parameter.    
+//
+void 
+Analyzer::setSidelobeLevel( double x ) 
+{ 
+    VERIFY_ARG( setSidelobeLevel, x > 0 );
+    m_sidelobeLevel = x; 
+}
+
+// ---------------------------------------------------------------------------
+//  setHopTime
+// ---------------------------------------------------------------------------
+//! Set the hop time (which corresponds approximately to the average
+//! density of Partial envelope Breakpoint data) for this Analyzer.
+//! 
+//! \param x is the new value of this parameter.
+//
+void 
+Analyzer::setHopTime( double x ) 
+{ 
+    VERIFY_ARG( setHopTime, x > 0 );
+    m_hopTime = x; 
+}
+
+// ---------------------------------------------------------------------------
+//  setWindowWidth
+// ---------------------------------------------------------------------------
+//! Set the frequency-domain main lobe width (measured between 
+//! zero-crossings) of the analysis window used by this Analyzer.   
+//! 
+//! \param x is the new value of this parameter.            
+//
+void 
+Analyzer::setWindowWidth( double x ) 
+{ 
+    VERIFY_ARG( setWindowWidth, x > 0 );
+    m_windowWidth = x; 
+}
+
+// ---------------------------------------------------------------------------
+//  setPhaseCorrect
+// ---------------------------------------------------------------------------
+//! Indicate whether the phases and frequencies of the constructed
+//! partials should be modified to be consistent at the end of the
+//! analysis. (Default is true.)
+//!
+//! \param  TF is a flag indicating whether or not to construct
+//!         phase-corrected Partials
+void 
+Analyzer::setPhaseCorrect( bool TF )
+{
+    m_phaseCorrect = TF;
+}
+
+//  -- bandwidth envelope specification --
+
+
+// ---------------------------------------------------------------------------
+//  storeResidueBandwidth
+// ---------------------------------------------------------------------------
+//!	Construct Partial bandwidth envelopes during analysis
+//!	by associating residual energy in the spectrum (after
+//! peak extraction) with the selected spectral peaks that
+//!	are used to construct Partials. 
+//!	
+//!	\param regionWidth is the width (in Hz) of the bandwidth 
+//!	association regions used by this process, must be positive.
+//!	If unspecified, a default value is used.
+//
+void 
+Analyzer::storeResidueBandwidth( double regionWidth ) 
+{ 
+    VERIFY_ARG( storeResidueBandwidth, regionWidth > 0 );
+    m_bwAssocParam = regionWidth; 
+}   
+
+// ---------------------------------------------------------------------------
+//  storeConvergenceBandwidth
+// ---------------------------------------------------------------------------
+//!	Construct Partial bandwidth envelopes during analysis
+//!	by storing the mixed derivative of short-time phase, 
+//!	scaled and shifted so that a value of 0 corresponds
+//!	to a pure sinusoid, and a value of 1 corresponds to a
+//! bandwidth-enhanced sinusoid with maximal energy spread
+//! (minimum sinusoidal convergence).
+//!
+//!	\param tolerance is the amount of range over which the 
+//!	mixed derivative indicator should be allowed to drift away 
+//!	from a pure sinusoid before saturating. This range is mapped
+//!	to bandwidth values on the range [0,1]. Must be positive and 
+//!	not greater than 1. If unspecified, a default value is used.
+//
+void 
+Analyzer::storeConvergenceBandwidth( double tolerance ) 
+{ 
+	if ( 1.0 < tolerance )
+	{
+		//	notify and scale, in Loris 1.5, tolerance was
+		//	specified as a percent
+		notifier << "Analyzer::storeConvergenceBandwidth, conergence tolerance "
+					"should be positive and less than 1.0, scaling by 1/100" << endl;
+		tolerance *= 0.01;
+	}
+	
+    VERIFY_ARG( storeConvergenceBandwidth, 
+    			(tolerance > 0) && (tolerance <= 1) );
+    			
+	//	store a negative value so that it can be 
+	//	identified when used:
+    m_bwAssocParam = -tolerance; 
+}   
+
+// ---------------------------------------------------------------------------
+//  storeNoBandwidth
+// ---------------------------------------------------------------------------
+//!	Disable bandwidth envelope construction. Bandwidth 
+//!	will be zero for all Breakpoints in all Partials.
+//
+void 
+Analyzer::storeNoBandwidth( void ) 
+{ 
+    m_bwAssocParam = 0; 
+}   
+
+// ---------------------------------------------------------------------------
+//!	Return true if this Analyzer is configured to compute
+//! bandwidth envelopes using the spectral residue after
+//! peaks have been identified, and false otherwise.
+// ---------------------------------------------------------------------------
+bool 
+Analyzer::bandwidthIsResidue( void ) const
+{ 
+    return m_bwAssocParam > 0.; 
+}
+
+// ---------------------------------------------------------------------------
+//!	Return true if this Analyzer is configured to compute
+//!	bandwidth envelopes using the mixed derivative convergence
+//!	indicator, and false otherwise.
+// ---------------------------------------------------------------------------
+bool 
+Analyzer::bandwidthIsConvergence( void ) const
+{ 
+    return m_bwAssocParam < 0.; 
+}
+
+
+// ---------------------------------------------------------------------------
+//! Return the width (in Hz) of the Bandwidth Association regions
+//! used by this Analyzer, only if the spectral residue method is
+//!	used to compute bandwidth envelopes. Return zero if the mixed
+//! derivative method is used, or if no bandwidth is computed.
+// ---------------------------------------------------------------------------
+double 
+Analyzer::bwRegionWidth( void ) const
+{
+	if ( m_bwAssocParam > 0 )
+	{
+		return m_bwAssocParam;
+	}
+	return 0;
+}
+
+// ---------------------------------------------------------------------------
+//!	Return the mixed derivative convergence tolerance (percent)
+//!	only if the convergence indicator is used to compute
+//!	bandwidth envelopes. Return zero if the spectral residue
+//!	method is used or if no bandwidth is computed.
+// ---------------------------------------------------------------------------
+double 
+Analyzer::bwConvergenceTolerance( void ) const
+{
+	if ( m_bwAssocParam < 0 )
+	{
+		return - m_bwAssocParam;
+	}
+	return 0;
+}
+
+
+// -- PartialList access --
+
+// ---------------------------------------------------------------------------
+//  partials
+// ---------------------------------------------------------------------------
+//! Return a mutable reference to this Analyzer's list of 
+//! analyzed Partials. 
+//
+PartialList & 
+Analyzer::partials( void ) 
+{ 
+    return m_partials; 
+}
+
+// ---------------------------------------------------------------------------
+//  partials
+// ---------------------------------------------------------------------------
+//! Return an immutable (const) reference to this Analyzer's 
+//! list of analyzed Partials. 
+//
+const PartialList & 
+Analyzer::partials( void ) const
+{ 
+    return m_partials; 
+}
+
+// ---------------------------------------------------------------------------
+//  buildFundamentalEnv
+// ---------------------------------------------------------------------------
+//! Specify parameters for constructing a fundamental frequency 
+//! envelope for the analyzed sound during analysis. The fundamental 
+//! frequency estimate can be accessed by fundamentalEnv() after the 
+//! analysis is complete. 
+//!
+//! \param  fmin is the lower bound on the fundamental frequency estimate
+//! \param  fmax is the upper bound on the fundamental frequency estimate
+//! \param  threshDb is the lower bound on the amplitude of a spectral peak
+//!         that will constribute to the fundamental frequency estimate (very
+//!         low amplitude peaks tend to have less reliable frequency estimates).
+//!         Default is -60 dB.
+//! \param  threshHz is the upper bound on the frequency of a spectral
+//!         peak that will constribute to the fundamental frequency estimate.
+//!         Default is 8 kHz.
+//
+void Analyzer::buildFundamentalEnv( double fmin, double fmax, 
+                                    double threshDb, double threshHz )
+{
+    m_f0Builder.reset( 
+        new FundamentalBuilder( fmin, fmax, threshDb, threshHz ) );
+}
+
+// ---------------------------------------------------------------------------
+//  fundamentalEnv
+// ---------------------------------------------------------------------------
+//! Return the fundamental frequency estimate envelope constructed
+//! during the most recent analysis performed by this Analyzer.
+//! Will be empty unless buildFundamentalEnv was invoked to enable the
+//! construction of this envelope during analysis.
+//
+const LinearEnvelope &
+Analyzer::fundamentalEnv( void ) const
+{   
+    return m_f0Builder->envelope(); 
+}
+
+
+// ---------------------------------------------------------------------------
+//  ampEnv
+// ---------------------------------------------------------------------------
+//! Return the overall amplitude estimate envelope constructed
+//! during the most recent analysis performed by this Analyzer.
+//! Will be empty unless buildAmpEnv was invoked to enable the
+//! construction of this envelope during analysis.
+//
+const LinearEnvelope & 
+Analyzer::ampEnv( void ) const
+{ 
+    return m_ampEnvBuilder->envelope(); 
+}
+
+// -- private helpers --
+
+// ---------------------------------------------------------------------------
+//	can_mask
+// ---------------------------------------------------------------------------
+//	functor used for identying peaks that are too close
+//	in frequency to another louder peak:
+struct can_mask
+{
+	//	masking occurs if any (louder) peak falls
+	//	in the frequency range delimited by fmin and fmax:
+	bool operator()( const SpectralPeak & v )  const
+	{ 
+		return	( v.frequency() > _fmin ) && 
+				( v.frequency() < _fmax ); 
+	}
+		
+	//	constructor:
+	can_mask( double x, double y ) : 
+		_fmin( x ), _fmax( y ) 
+		{ if (x>y) std::swap(x,y); }
+		
+	//	bounds:
+private:
+	double _fmin, _fmax;
+};
+
+// ---------------------------------------------------------------------------
+//	negative_time
+// ---------------------------------------------------------------------------
+//	functor used to identify peaks that have reassigned times 
+//	before 0:
+struct negative_time
+{
+	//	negative times occur when the reassigned time
+	// 	plus the current frame time is less than 0:
+	bool operator()( const Peaks::value_type & v )  const
+	{ 
+		return 0 > ( v.time() + _frameTime );
+	}
+		
+	//	constructor:
+	negative_time( double t ) : 
+		_frameTime( t ) {}
+		
+	//	bounds:
+private:
+	double _frameTime;
+	
+};
+
+
+// ---------------------------------------------------------------------------
+//	thinPeaks (HELPER)
+// ---------------------------------------------------------------------------
+//	Reject peaks that are too quiet (low amplitude). Peaks that are retained,
+//	but are quiet enough to be in the specified fadeRange should be faded.
+//	Peaks having negative times are also rejected.
+//
+//	This is exactly the same as the basic peak selection strategy, there
+//	is no tracking here.
+//	
+//	Rejected peaks are placed at the end of the peak collection.
+//	Return the first position in the collection containing a rejected peak,
+//	or the end of the collection if no peaks are rejected.
+//
+//	This used to be part of SpectralPeakSelector, but it really had no place
+//	there. It _should_ remove the rejected peaks, but for now, those are needed
+//	by the bandwidth association strategy.
+//
+Peaks::iterator 
+Analyzer::thinPeaks( Peaks & peaks, double frameTime  )
+{
+	const double ampFloordB = m_ampFloor;
+
+	//  fade quiet peaks out over 10 dB:
+	const double fadeRangedB = 10.0;
+
+	//	compute absolute magnitude thresholds:
+	const double threshold = std::pow( 10., 0.05 * ampFloordB );
+	const double beginFade = std::pow( 10., 0.05 * (ampFloordB+fadeRangedB) );
+
+	//	louder peaks are preferred, so consider them 
+	//	in order of louder magnitude:
+	std::sort( peaks.begin(), peaks.end(), SpectralPeak::sort_greater_amplitude );
+	
+    //  negative times are not real, but still might represent
+    //  a noisy part of the spectrum...
+	Peaks::iterator bogusTimes = 
+		std::remove_if( peaks.begin(), peaks.end(), negative_time( frameTime ) );
+		
+	//	...get rid of them anyway
+    peaks.erase( bogusTimes, peaks.end() );
+    bogusTimes = peaks.end();
+        
+    
+	Peaks::iterator it = peaks.begin();
+	Peaks::iterator beginRejected = it;
+
+    const double freqResolution = 
+    	std::max( m_freqResolutionEnv->valueAt( frameTime ), 0.0 ); 
+    
+    
+	while ( it != peaks.end() ) 
+	{
+		SpectralPeak & pk = *it;
+		
+		//	keep this peak if it is loud enough and not
+		//	 too near in frequency to a louder one:
+		double lower = pk.frequency() - freqResolution;
+		double upper = pk.frequency() + freqResolution;
+		if ( pk.amplitude() > threshold &&
+			 beginRejected == std::find_if( peaks.begin(), beginRejected, can_mask(lower, upper) ) )
+		{
+			//	this peak is a keeper, fade its
+			//	amplitude if it is too quiet:
+			if ( pk.amplitude() < beginFade )
+			{
+				double alpha = (beginFade - pk.amplitude())/(beginFade - threshold);
+				pk.setAmplitude( pk.amplitude() * (1. - alpha) );
+			}
+			
+			//	keep retained peaks at the front of the collection:
+			if ( it != beginRejected )
+			{
+				std::swap( *it, *beginRejected );
+			}
+			++beginRejected;
+		}
+		++it;
+	}
+	
+	// debugger << "thinPeaks retained " << std::distance( peaks.begin(), beginRejected ) << endl;
+
+	//  remove rejected Breakpoints:
+	//peaks.erase( beginRejected, peaks.end() );
+	
+	return beginRejected;
+}
+
+// ---------------------------------------------------------------------------
+//	fixBandwidth (HELPER)
+// ---------------------------------------------------------------------------
+//	Fix the bandwidth value stored in the specified Peaks. 
+//	This function is invoked if the spectral residue method is
+//	not used to compute bandwidth (that method overwrites the
+//	bandwidth already). If the convergence method is used to 
+//	compute bandwidth, the appropriate scaling is applied
+//	to the stored mixed phase derivative. Otherwise, the
+//	Peak bandwidth is set to zero.
+//
+//  The convergence value is on the range [0,1], 0 for a sinusoid, 
+//  and 1 for an impulse. If convergence tolerance is specified (as
+//  a negative value in m_bwAssocParam), it should be positive and 
+//  less than 1, and specifies the convergence value that is to 
+//  correspond to bandwidth equal to 1.0. This is achieved by scaling
+//  the convergence by the inverse of the tolerance, and saturating
+//  at 1.0.
+void Analyzer::fixBandwidth( Peaks & peaks )
+{
+	
+	if ( m_bwAssocParam < 0 )
+	{
+		double scale = 1.0 / (- m_bwAssocParam);	
+			// m_bwAssocParam stores negative tolerance
+	
+		for ( Peaks::iterator it = peaks.begin(); it != peaks.end(); ++it )
+		{
+            SpectralPeak & pk = *it;
+			pk.setBandwidth( std::min( 1.0, scale * pk.bandwidth() ) );
+		}
+	}
+	else if ( m_bwAssocParam == 0 )
+	{
+		for ( Peaks::iterator it = peaks.begin(); it != peaks.end(); ++it )
+		{
+            SpectralPeak & pk = *it;
+			pk.setBandwidth( 0 );
+		}
+	}
+}
+
+}   //  end of namespace Loris
diff --git a/src/loris/Analyzer.h b/src/loris/Analyzer.h
new file mode 100644
index 0000000..6bdfe52
--- /dev/null
+++ b/src/loris/Analyzer.h
@@ -0,0 +1,620 @@
+#ifndef INCLUDE_ANALYZER_H
+#define INCLUDE_ANALYZER_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Analyzer.h
+ *
+ * Definition of class Loris::Analyzer.
+ *
+ * Kelly Fitz, 5 Dec 99
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#include <memory>
+#include <vector>
+#include "LinearEnvelope.h"
+#include "Partial.h"
+#include "PartialList.h"
+// #include "SpectralPeaks.h"
+
+//  begin namespace
+namespace Loris {
+
+class Envelope;
+class LinearEnvelopeBuilder;
+// class Peaks;
+// class Peaks::iterator;
+//  oooo, this is nasty, need to fix it!
+class SpectralPeak;
+typedef std::vector< SpectralPeak > Peaks;
+
+// ---------------------------------------------------------------------------
+//  class Analyzer
+//
+//! Class Analyzer represents a configuration of parameters for
+//! performing Reassigned Bandwidth-Enhanced Additive Analysis
+//! of sampled sounds. The analysis process yields a collection 
+//! of Partials, each having a trio of synchronous, non-uniformly-
+//! sampled breakpoint envelopes representing the time-varying 
+//! frequency, amplitude, and noisiness of a single bandwidth-
+//! enhanced sinusoid. These Partials are accumulated in the
+//! Analyzer.
+//!
+//! The core analysis parameter is the frequency resolution, the 
+//! minimum instantaneous frequency spacing between partials. Most 
+//! other parameters are initially configured according to this 
+//! parameter (and the analysis window width, if specified).
+//! Subsequent parameter mutations are independent.
+//! 
+//! Bandwidth enhancement:
+//! Two different strategies are available for computing bandwidth
+//! (or noisiness) envelope: 
+//! 
+//! One strategy is to construct bandwidth envelopes during analysis
+//! by associating residual energy in the spectrum (after peak 
+//! extraction) with the selected spectral peaks that are used 
+//! to construct Partials. This is the original bandwidth enhancement
+//! algorithm, and bandwidth envelopes constructed in this way may
+//! be suitable for use in bandwidth-enhanced synthesis. 
+//! 
+//! Another stategy is to construct bandwidth envelopes during 
+//! analysis by storing the mixed derivative of short-time phase, 
+//! scaled and shifted so that a value of 0 corresponds
+//! to a pure sinusoid, and a value of 1 corresponds to a
+//! bandwidth-enhanced sinusoid with maximal energy spread
+//! (minimum convergence in frequency). These bandwidth envelopes
+//! are not suitable for bandwidth-enhanced synthesis, be sure
+//! to set the bandwidth to 0, or to disable bandwidth enhancement
+//! before rendering.
+//! 
+//! The Analyzer may be configured to use either of these two
+//! strategies for bandwidth-enhanced analysis, or to construct
+//! no bandwidth envelopes at all. If unspecified, the default
+//! Analyzer configuration uses spectral residue to construct
+//! bandwidth envelopes.
+//! 
+//! \sa storeResidueBandwidth, storeConvergenceBandwidth, storeNoBandwidth
+//! 
+//! For more information about Reassigned Bandwidth-Enhanced 
+//! Analysis and the Reassigned Bandwidth-Enhanced Additive Sound 
+//! Model, refer to the Loris website: www.cerlsoundgroup.org/Loris/.
+//
+class Analyzer
+{
+//  -- public interface --
+public:
+
+//  -- construction --
+
+    //! Construct a new Analyzer configured with the given  
+    //! frequency resolution (minimum instantaneous frequency   
+    //! difference between Partials). All other Analyzer parameters     
+    //! are computed from the specified frequency resolution.   
+    //! 
+    //! \param resolutionHz is the frequency resolution in Hz.
+    explicit Analyzer( double resolutionHz );
+    
+    //! Construct a new Analyzer configured with the given  
+    //! frequency resolution (minimum instantaneous frequency   
+    //! difference between Partials) and analysis window width
+    //! (main lobe, zero-to-zero). All other Analyzer parameters    
+    //! are computed from the specified resolution and window width.    
+    //! 
+    //! \param resolutionHz is the frequency resolution in Hz.
+    //! \param windowWidthHz is the main lobe width of the Kaiser
+    //! analysis window in Hz.
+    Analyzer( double resolutionHz, double windowWidthHz );
+
+    //! Construct a new Analyzer configured with the given time-varying
+    //! frequency resolution (minimum instantaneous frequency   
+    //! difference between Partials) and analysis window width
+    //! (main lobe, zero-to-zero). All other Analyzer parameters    
+    //! are computed from the specified resolution and window width.    
+    //! 
+    //! \param resolutionHz is the frequency resolution in Hz.
+    //! \param windowWidthHz is the main lobe width of the Kaiser
+    //! analysis window in Hz.
+    Analyzer( const Envelope & resolutionEnv, double windowWidthHz );
+
+    //! Construct  a new Analyzer having identical
+    //! parameter configuration to another Analyzer. 
+    //! The list of collected Partials is not copied.       
+    //! 
+    //! \param other is the Analyzer to copy.   
+    Analyzer( const Analyzer & other );
+
+    //! Destroy this Analyzer.
+    ~Analyzer( void );
+
+    //! Construct  a new Analyzer having identical
+    //! parameter configuration to another Analyzer. 
+    //! The list of collected Partials is not copied.       
+    //! 
+    //! \param rhs is the Analyzer to copy. 
+    Analyzer & operator=( const Analyzer & rhs );
+
+//  -- configuration --
+
+    //! Configure this Analyzer with the given frequency resolution 
+    //! (minimum instantaneous frequency difference between Partials, 
+    //! in Hz). All other Analyzer parameters are (re-)computed from the 
+    //! frequency resolution, including the window width, which is
+    //! twice the resolution.      
+    //! 
+    //! \param resolutionHz is the frequency resolution in Hz.
+    void configure( double resolutionHz );
+
+    //! Configure this Analyzer with the given frequency resolution 
+    //! (minimum instantaneous frequency difference between Partials)
+    //! and analysis window width (main lobe, zero-to-zero, in Hz). 
+    //! All other Analyzer parameters are (re-)computed from the 
+    //! frequency resolution and window width.      
+    //! 
+    //! \param resolutionHz is the frequency resolution in Hz.
+    //! \param windowWidthHz is the main lobe width of the Kaiser
+    //! analysis window in Hz.
+    //!     
+    //! There are three categories of analysis parameters:
+    //! - the resolution, and params that are usually related to (or
+    //! identical to) the resolution (frequency floor and drift)
+    //! - the window width and params that are usually related to (or
+    //! identical to) the window width (hop and crop times)
+    //! - independent parameters (bw region width and amp floor)
+    void configure( double resolutionHz, double windowWidthHz );
+
+	//! Configure this Analyzer with the given time-varying frequency resolution 
+	//! (minimum instantaneous frequency difference between Partials)
+	//! and analysis window width (main lobe, zero-to-zero, in Hz). 
+	//! All other Analyzer parameters are (re-)computed from the 
+	//! frequency resolution and window width.      
+	//! 
+	//! \param resolutionEnv is the time-varying frequency resolution 
+	//!	in Hz.
+	//! \param windowWidthHz is the main lobe width of the Kaiser
+	//! analysis window in Hz.
+	//!     
+	//! There are three categories of analysis parameters:
+	//! - the resolution, and params that are usually related to (or
+	//! identical to) the resolution (frequency floor and drift)
+	//! - the window width and params that are usually related to (or
+	//! identical to) the window width (hop and crop times)
+	//! - independent parameters (bw region width and amp floor)
+	//
+	void configure( const Envelope & resolutionEnv, double windowWidthHz );    
+    
+//  -- analysis --
+
+    //! Analyze a vector of (mono) samples at the given sample rate         
+    //! (in Hz) and store the extracted Partials in the Analyzer's 
+    //! PartialList (std::list of Partials).    
+    //! 
+    //! \param  vec is a vector of floating point samples
+    //! \param  srate is the sample rate of the samples in the vector 
+    void analyze( const std::vector<double> & vec, double srate );
+    
+    //! Analyze a range of (mono) samples at the given sample rate      
+    //! (in Hz) and store the extracted Partials in the Analyzer's
+    //! PartialList (std::list of Partials).    
+    //! 
+    //! \param  bufBegin is a pointer to a buffer of floating point samples
+    //! \param  bufEnd is (one-past) the end of a buffer of floating point 
+    //!         samples
+    //! \param  srate is the sample rate of the samples in the buffer
+    void analyze( const double * bufBegin, const double * bufEnd, double srate );
+    
+//  -- tracking analysis --
+
+    //! Analyze a vector of (mono) samples at the given sample rate         
+    //! (in Hz) and store the extracted Partials in the Analyzer's
+    //! PartialList (std::list of Partials). Use the specified envelope
+    //! as a frequency reference for Partial tracking.
+    //!
+    //! \param  vec is a vector of floating point samples
+    //! \param  srate is the sample rate of the samples in the vector
+    //! \param  reference is an Envelope having the approximate
+    //!         frequency contour expected of the resulting Partials.
+    void analyze( const std::vector<double> & vec, double srate, 
+                  const Envelope & reference );
+    
+    //! Analyze a range of (mono) samples at the given sample rate      
+    //! (in Hz) and store the extracted Partials in the Analyzer's
+    //! PartialList (std::list of Partials). Use the specified envelope
+    //! as a frequency reference for Partial tracking.
+    //! 
+    //! \param  bufBegin is a pointer to a buffer of floating point samples
+    //! \param  bufEnd is (one-past) the end of a buffer of floating point 
+    //!         samples
+    //! \param  srate is the sample rate of the samples in the buffer
+    //! \param  reference is an Envelope having the approximate
+    //!         frequency contour expected of the resulting Partials.
+    void analyze( const double * bufBegin, const double * bufEnd, double srate,
+                  const Envelope & reference );
+    
+//  -- parameter access --
+
+    //! Return the amplitude floor (lowest detected spectral amplitude),            
+    //! in (negative) dB, for this Analyzer.                
+    double ampFloor( void ) const;
+
+    //! Return the crop time (maximum temporal displacement of a time-
+    //! frequency data point from the time-domain center of the analysis
+    //! window, beyond which data points are considered "unreliable")
+    //! for this Analyzer.
+    double cropTime( void ) const;
+
+    //! Return the maximum allowable frequency difference between                   
+    //! consecutive Breakpoints in a Partial envelope for this Analyzer.                
+    double freqDrift( void ) const;
+
+    //! Return the frequency floor (minimum instantaneous Partial               
+    //! frequency), in Hz, for this Analyzer.               
+    double freqFloor( void ) const;
+	
+	//! Return the frequency resolution (minimum instantaneous frequency        
+	//! difference between Partials) for this Analyzer at the specified
+	//! time in seconds. If no time is specified, then the initial resolution
+	//!	(at 0 seconds) is returned.
+	//! 
+	//! \param time is the time in seconds at which to evaluate the 
+	//!		   frequency resolution
+	double freqResolution( double time = 0.0 ) const; 
+
+    //! Return the hop time (which corresponds approximately to the 
+    //! average density of Partial envelope Breakpoint data) for this 
+    //! Analyzer.
+    double hopTime( void ) const;
+
+    //! Return the sidelobe attenutation level for the Kaiser analysis window in
+    //! positive dB. Larger numbers (e.g. 90) give very good sidelobe 
+    //! rejection but cause the window to be longer in time. Smaller numbers 
+    //! (like 60) raise the level of the sidelobes, increasing the likelihood
+    //! of frequency-domain interference, but allow the window to be shorter
+    //! in time.
+    double sidelobeLevel( void ) const;
+
+    //! Return the frequency-domain main lobe width (measured between 
+    //! zero-crossings) of the analysis window used by this Analyzer.               
+    double windowWidth( void ) const;
+     
+    //! Return true if the phases and frequencies of the constructed
+    //! partials should be modified to be consistent at the end of the
+    //! analysis, and false otherwise. (Default is true.)
+    bool phaseCorrect( void ) const;
+
+
+//  -- parameter mutation --
+
+    //! Set the amplitude floor (lowest detected spectral amplitude), in            
+    //! (negative) dB, for this Analyzer. 
+    //! 
+    //! \param x is the new value of this parameter.            
+    void setAmpFloor( double x );
+
+    //! Set the crop time (maximum temporal displacement of a time-
+    //! frequency data point from the time-domain center of the analysis
+    //! window, beyond which data points are considered "unreliable")
+    //! for this Analyzer.
+    //! 
+    //! \param x is the new value of this parameter.            
+    void setCropTime( double x );
+
+    //! Set the maximum allowable frequency difference between                  
+    //! consecutive Breakpoints in a Partial envelope for this Analyzer.                
+    //! 
+    //! \param x is the new value of this parameter.            
+    void setFreqDrift( double x );
+
+    //! Set the frequency floor (minimum instantaneous Partial                  
+    //! frequency), in Hz, for this Analyzer.
+    //! 
+    //! \param x is the new value of this parameter.            
+    void setFreqFloor( double x );
+
+    //! Set the frequency resolution (minimum instantaneous frequency       
+    //! difference between Partials) for this Analyzer. (Does not cause     
+    //! other parameters to be recomputed.)                                     
+    //! 
+    //! \param x is the new value of this parameter.            
+    void setFreqResolution( double x );
+    
+	//! Set the time-varying frequency resolution (minimum instantaneous frequency       
+	//! difference between Partials) for this Analyzer. (Does not cause     
+	//! other parameters to be recomputed.)                                     
+	//! 
+	//! \param e is the envelope to copy for this parameter.                                        
+	void setFreqResolution( const Envelope & e );    
+
+    //! Set the hop time (which corresponds approximately to the average
+    //! density of Partial envelope Breakpoint data) for this Analyzer.
+    //! 
+    //! \param x is the new value of this parameter.            
+    void setHopTime( double x );
+
+    //! Set the sidelobe attenutation level for the Kaiser analysis window in
+    //! positive dB. More negative numbers (e.g. -90) give very good sidelobe 
+    //! rejection but cause the window to be longer in time. Less negative 
+    //! numbers raise the level of the sidelobes, increasing the likelihood
+    //! of frequency-domain interference, but allow the window to be shorter
+    //! in time.
+    //! 
+    //! \param x is the new value of this parameter.            
+    void setSidelobeLevel( double x );
+
+    //! Set the frequency-domain main lobe width (measured between 
+    //! zero-crossings) of the analysis window used by this Analyzer.   
+    //! 
+    //! \param x is the new value of this parameter.            
+    void setWindowWidth( double x );
+
+    //! Indicate whether the phases and frequencies of the constructed
+    //! partials should be modified to be consistent at the end of the
+    //! analysis. (Default is true.)
+    //!
+    //! \param  TF is a flag indicating whether or not to construct
+    //!         phase-corrected Partials
+    void setPhaseCorrect( bool TF = true );
+    
+    
+//  -- bandwidth envelope specification --
+
+    enum { Default_ResidueBandwidth_RegionWidth = 2000,
+           Default_ConvergenceBandwidth_TolerancePct = 10 };
+           
+    //! Construct Partial bandwidth envelopes during analysis
+    //! by associating residual energy in the spectrum (after
+    //! peak extraction) with the selected spectral peaks that
+    //! are used to construct Partials. 
+    //!
+    //!	This is the default bandwidth-enhancement strategy.
+    //! 
+    //! \param regionWidth is the width (in Hz) of the bandwidth 
+    //! association regions used by this process, must be positive.
+    //! If unspecified, a default value is used.
+    void storeResidueBandwidth( double regionWidth = Default_ResidueBandwidth_RegionWidth );
+    
+	//!	Construct Partial bandwidth envelopes during analysis
+	//!	by storing the mixed derivative of short-time phase, 
+	//!	scaled and shifted so that a value of 0 corresponds
+	//!	to a pure sinusoid, and a value of 1 corresponds to a
+	//! bandwidth-enhanced sinusoid with maximal energy spread
+	//! (minimum sinusoidal convergence).
+	//!
+	//!	\param tolerance is the amount of range over which the 
+	//!	mixed derivative indicator should be allowed to drift away 
+	//!	from a pure sinusoid before saturating. This range is mapped
+	//!	to bandwidth values on the range [0,1]. Must be positive and 
+	//!	not greater than 1. If unspecified, a default value is used.
+    void storeConvergenceBandwidth( double tolerancePct = 
+    		0.01 * (double)Default_ConvergenceBandwidth_TolerancePct );
+    
+    //! Disable bandwidth envelope construction. Bandwidth 
+    //! will be zero for all Breakpoints in all Partials.
+    void storeNoBandwidth( void );
+    
+    //! Return true if this Analyzer is configured to compute
+    //! bandwidth envelopes using the spectral residue after
+    //! peaks have been identified, and false otherwise.
+    bool bandwidthIsResidue( void ) const;
+    
+    //! Return true if this Analyzer is configured to compute
+    //! bandwidth envelopes using the mixed derivative convergence
+    //! indicator, and false otherwise.
+    bool bandwidthIsConvergence( void ) const;
+    
+    //! Return the width (in Hz) of the Bandwidth Association regions
+    //! used by this Analyzer, only if the spectral residue method is
+    //! used to compute bandwidth envelopes. Return zero if the mixed
+    //! derivative method is used, or if no bandwidth is computed.
+    double bwRegionWidth( void ) const;
+
+    //! Return the mixed derivative convergence tolerance (percent)
+    //! only if the convergence indicator is used to compute
+    //! bandwidth envelopes. Return zero if the spectral residue
+    //! method is used or if no bandwidth is computed.
+    double bwConvergenceTolerance( void ) const;
+
+    //! Return true if bandwidth envelopes are to be constructed
+    //!	by any means, that is, if either bandwidthIsResidue() or 
+    //!	bandwidthIsConvergence() are true. Otherwise, return
+    //! false.
+    bool associateBandwidth( void ) const
+        { return bandwidthIsResidue() || bandwidthIsConvergence(); }
+
+    //! Deprecated, use storeResidueBandwidth or storeNoBandwidth instead.            
+    void setBwRegionWidth( double x ) 
+        { 
+            if ( x != 0 )
+            {
+                storeResidueBandwidth( x ); 
+            }
+            else
+            {
+                storeNoBandwidth();
+            }
+        }
+           
+
+//  -- PartialList access --
+
+    //! Return a mutable reference to this Analyzer's list of 
+    //! analyzed Partials. 
+    PartialList & partials( void );
+
+    //! Return an immutable (const) reference to this Analyzer's 
+    //! list of analyzed Partials. 
+    const PartialList & partials( void ) const;
+
+//  -- envelope access --
+
+    enum { Default_FundamentalEnv_ThreshDb = -60, 
+           Default_FundamentalEnv_ThreshHz = 8000 };
+
+    //! Specify parameters for constructing a fundamental frequency 
+    //! envelope for the analyzed sound during analysis. The fundamental 
+    //! frequency estimate can be accessed by fundamentalEnv() after the 
+    //! analysis is complete. 
+    //!
+    //! By default, a fundamental envelope is estimated during analysis
+    //! between the frequency resolution and 1.5 times the resolution.
+    //!
+    //! \param  fmin is the lower bound on the fundamental frequency estimate
+    //! \param  fmax is the upper bound on the fundamental frequency estimate
+    //! \param  threshDb is the lower bound on the amplitude of a spectral peak
+    //!         that will constribute to the fundamental frequency estimate (very
+    //!         low amplitude peaks tend to have less reliable frequency estimates).
+    //!         Default is -60 dB.
+    //! \param  threshHz is the upper bound on the frequency of a spectral
+    //!         peak that will constribute to the fundamental frequency estimate.
+    //!         Default is 8 kHz.
+    void buildFundamentalEnv( double fmin, double fmax, 
+                              double threshDb = Default_FundamentalEnv_ThreshDb, 
+                              double threshHz = Default_FundamentalEnv_ThreshHz );                                     
+
+
+    //! Return the fundamental frequency estimate envelope constructed
+    //! during the most recent analysis performed by this Analyzer.
+    //!
+    //! By default, a fundamental envelope is estimated during analysis
+    //! between the frequency resolution and 1.5 times the resolution.
+    const LinearEnvelope & fundamentalEnv( void ) const;
+
+    //! Return the overall amplitude estimate envelope constructed
+    //! during the most recent analysis performed by this Analyzer.
+    const LinearEnvelope & ampEnv( void ) const;
+    
+    
+//  -- legacy support --
+    
+    //  Fundamental and amplitude envelopes are always constructed during
+    //  analysis, these members do nothing, and are retained for backwards
+    //  compatibility.
+    void buildAmpEnv( bool TF = true ) { TF = TF; }
+    void buildFundamentalEnv( bool TF = true ) { TF = TF; }
+
+//  -- private member variables --
+
+private:
+
+    std::auto_ptr< Envelope > m_freqResolutionEnv;    
+    							//!  in Hz, minimum instantaneous frequency distance;
+                                //!  this is the core parameter, others are, by default,
+                                //!  computed from this one
+    
+    double m_ampFloor;          //!  dB, relative to full amplitude sine wave, absolute
+                                //!  amplitude threshold (negative)
+    
+    double m_windowWidth;       //!  in Hz, width of main lobe; this might be more
+                                //!  conveniently presented as window length, but
+                                //!  the main lobe width more explicitly highlights
+                                //!  the critical interaction with resolution
+    
+    // std::auto_ptr< Envelope > m_freqFloorEnv; 
+    double m_freqFloor;         //!  lowest frequency (Hz) component extracted
+                                //!  in spectral analysis
+    
+    double m_freqDrift;         //!  the maximum frequency (Hz) difference between two 
+                                //!  consecutive Breakpoints that will be linked to
+                                //!  form a Partial
+    
+    double m_hopTime;           //!  in seconds, time between analysis windows in
+                                //!  successive spectral analyses
+    
+    double m_cropTime;          //!  in seconds, maximum time correction for a spectral
+                                //!  component to be considered reliable, and to be eligible
+                                //!  for extraction and for Breakpoint formation
+    
+    double m_bwAssocParam;      //!  formerly, width in Hz of overlapping bandwidth 
+                                //!  association regions, or zero if bandwidth association
+                                //!  is disabled, now a catch-all bandwidth association
+                                //!  parameter that, if negative, indicates the tolerance (%)
+                                //!  level used to construct bandwidth envelopes from the
+                                //!  mixed phase derivative indicator
+                                                        
+    double m_sidelobeLevel;     //!  sidelobe attenutation level for the Kaiser analysis 
+                                //!  window, in positive dB
+                                
+    bool m_phaseCorrect;        //!  flag indicating that phases/frequencies should be
+                                //!  made consistent at the end of the analysis
+                            
+    PartialList m_partials;     //!  collect Partials here
+        
+    //! builder object for constructing a fundamental frequency
+    //! estimate during analysis
+    std::auto_ptr< LinearEnvelopeBuilder > m_f0Builder;
+
+    //! builder object for constructing an amplitude
+    //! estimate during analysis
+    std::auto_ptr< LinearEnvelopeBuilder > m_ampEnvBuilder;
+
+//  -- private auxiliary functions --
+//	future development
+/*
+
+	//	These members make up the sequence of operations in an
+	//	analysis. If analysis were ever to be made into a 
+	//	template method, these would be the operations that
+	//	derived classes could override. Or each of these could
+	//	be represented by a strategy class.
+
+	//!	Compute the spectrum of the next sequence of samples.
+	void computeSpectrum( void );
+	
+	//!	Identify and select the spectral components that will be
+	//!	used to form Partials. 
+	void selectPeaks( void );
+	
+	//!	Compute the bandwidth coefficients for the Breakpoints
+	//!	that are going to be used to form Partials. 
+	void associateBandwidth( void );
+	
+	//!	Construct Partials from extracted spectral components.
+	//!	Partials are built up frame by frame by appending
+	//!	Breakpoints to Partials under construction, and giving
+	//!	birth to new Partials using unmatched Peaks.
+	void formPartials( Peaks & peaks );
+*/
+    //  Reject peaks that are too close in frequency to a louder peak that is
+    //  being retained, and peaks that are too quiet. Peaks that are retained,
+    //  but are quiet enough to be in the specified fadeRange should be faded.
+    //  
+    //  Rejected peaks are placed at the end of the peak collection.
+    //  Return the first position in the collection containing a rejected peak,
+    //  or the end of the collection if no peaks are rejected.
+    Peaks::iterator thinPeaks( Peaks & peaks, double frameTime  );
+                
+    //  Fix the bandwidth value stored in the specified Peaks. 
+    //  This function is invoked if the spectral residue method is
+    //  not used to compute bandwidth (that method overwrites the
+    //  bandwidth already). If the convergence method is used to 
+    //  compute bandwidth, the appropriate scaling is applied
+    //  to the stored mixed phase derivative. Otherwise, the
+    //  Peak bandwidth is set to zero.
+    void fixBandwidth( Peaks & peaks );
+                    
+};  //  end of class Analyzer
+
+}   //  end of namespace Loris
+
+#endif /* ndef INCLUDE_ANALYZER_H */
diff --git a/src/loris/AssociateBandwidth.C b/src/loris/AssociateBandwidth.C
new file mode 100644
index 0000000..e72c52f
--- /dev/null
+++ b/src/loris/AssociateBandwidth.C
@@ -0,0 +1,317 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * AssociateBandwidth.C
+ *
+ * Implementation of a class representing a policy for associating noise
+ * (bandwidth) energy with reassigned spectral peaks to be used in
+ * Partial formation.
+ *
+ * Kelly Fitz, 20 Jan 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "AssociateBandwidth.h"
+#include "Breakpoint.h"
+#include "BreakpointUtils.h"
+#include "LorisExceptions.h"
+#include "Notifier.h"
+#include "SpectralPeaks.h"
+
+#include <algorithm>
+#include <cmath>
+
+using namespace Loris;
+
+// ---------------------------------------------------------------------------
+//	AssociateBandwidth constructor
+// ---------------------------------------------------------------------------
+//	Association regions are centered on all integer bin frequencies, regionWidth
+//	is the total width (in Hz) of the overlapping bandwidth association regions, 
+//	the region centers are spaced at half this width.
+//
+AssociateBandwidth::AssociateBandwidth( double regionWidth, double srate ) :
+	_regionRate( 0 )
+{
+	if ( ! (regionWidth>0) )
+		Throw( InvalidArgument, "The regionWidth must be greater than 0 Hz." );
+	if ( ! (srate>0) )
+		Throw( InvalidArgument, "The sample rate must be greater than 0 Hz." );
+		
+		
+	_weights.resize( int(srate/regionWidth) );
+	_surplus.resize( int(srate/regionWidth) );
+	_regionRate = 2./regionWidth;
+}	
+
+// ---------------------------------------------------------------------------
+//	AssociateBandwidth destructor
+// ---------------------------------------------------------------------------
+//
+AssociateBandwidth::~AssociateBandwidth( void )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	binFrequency
+// ---------------------------------------------------------------------------
+//	Compute the warped fractional bin/region frequency corresponding to 
+//	freqHz. (_regionRate is the number of regions per hertz.)
+//
+//	Once, we used bark frequency scale warping here, but there seems to be
+//	no reason to do so. The best results seem to be indistinguishable from
+// 	plain 'ol 1k bins, and some results are much worse.
+//	
+static double binFrequency( double freqHz, double regionRate )
+{
+//#define Use_Barks
+#ifndef Use_Barks
+	return freqHz * regionRate;
+#else
+	//	Compute Bark frequency from Hertz.
+	//	Got this formula for Bark frequency from Sciarraba's thesis.
+	//	Ignore region rate when using barks
+	double tmp = std::atan( ( 0.001 / 7.5 ) * freqHz );
+	return  13. * std::atan( 0.76 * 0.001 * freqHz ) + 3.5 * ( tmp * tmp );
+#endif
+	
+}
+
+// ---------------------------------------------------------------------------
+//	findRegionBelow
+// ---------------------------------------------------------------------------
+//	Return the index of the last region having center frequency less than
+//	or equal to freq, or -1 if no region is low enough. 
+//
+//	Note: the zeroeth region is centered at bin frequency 1 and tapers
+//	to zero at bin frequency 0! (when booger is 1.)
+//
+static int findRegionBelow( double binfreq, unsigned int howManyBins )
+{
+	const double booger = 0.;
+	if ( binfreq < booger ) 
+	{
+		return -1;
+	}
+	else 
+	{
+		return int( std::min( std::floor(binfreq - booger), howManyBins - 1. ) );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	computeAlpha
+// ---------------------------------------------------------------------------
+//	binfreq is a warped, fractional bin frequency, and bin frequencies 
+//	are integers. Return the relative contribution of a component at
+//	binfreq to the bins (bw association regions) below and above
+//	binfreq. 
+//
+static double computeAlpha( double binfreq, unsigned int howManyBins )
+{
+	//	everything above the center of the highest
+	//	bin is lumped into that bin; i.e it does
+	//	not taper off at higher frequencies:	
+	if ( binfreq > howManyBins ) 
+	{
+		return 0.;
+	}
+	else 
+	{
+		return binfreq - std::floor( binfreq );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	distribute
+// ---------------------------------------------------------------------------
+//
+static void distribute( double fractionalBin, double x, std::vector<double> & regions )
+{
+	//	contribute x to two regions having center
+	//	frequencies less and greater than freqHz:
+	int posBelow = findRegionBelow( fractionalBin, regions.size() );
+	int posAbove = posBelow + 1;
+	
+	double alpha = computeAlpha( fractionalBin, regions.size() );
+	
+	if ( posAbove < regions.size() )
+		regions[posAbove] += alpha * x;
+	
+	if ( posBelow >= 0 )
+		regions[posBelow] += (1. - alpha) * x;
+}
+
+// ---------------------------------------------------------------------------
+//	computeNoiseEnergy
+// ---------------------------------------------------------------------------
+//	Return the noise energy to be associated with a component at freqHz.
+//	_surplus contains the surplus spectral energy in each region, which is,
+//	by defintion, non-negative.
+//
+double 
+AssociateBandwidth::computeNoiseEnergy( double freq, double amp )
+{
+	//	don't mess with negative frequencies:
+	if ( freq < 0. )
+		return 0.;
+	
+	//	compute the fractional bin frequency 
+	//	corresponding to freqHz:
+	double bin = binFrequency( freq, _regionRate );
+	
+	//	contribute x to two regions having center
+	//	frequencies less and greater than freqHz:
+	int posBelow = findRegionBelow( bin, _surplus.size() );
+	int posAbove = posBelow + 1;
+
+	double alpha = computeAlpha( bin, _surplus.size() );
+
+	double noise = 0.;
+	//	Have to check for alpha == 0, because 
+	//	the weights will be zero (see computeAlpha()):
+	//	(ignore lowest regions)
+	const int LowestRegion = 2;
+	/*
+	if ( posAbove < _surplus.size() && alpha != 0. && posAbove >= LowestRegion )
+		noise += _surplus[posAbove] * alpha / _weights[posAbove];
+	
+	if ( posBelow >= LowestRegion )
+		noise += _surplus[posBelow] * (1. - alpha) / _weights[posBelow];
+	*/
+	//	new idea, weight Partials by amplitude:	
+	if ( posAbove < _surplus.size() && alpha != 0. && posAbove >= LowestRegion )
+		noise += _surplus[posAbove] * alpha * amp / _weights[posAbove];
+	
+	if ( posBelow >= LowestRegion )
+		noise += _surplus[posBelow] * (1. - alpha) * amp / _weights[posBelow];
+		
+	return noise;
+}
+
+// ---------------------------------------------------------------------------
+//	accumulateSinusoid
+// ---------------------------------------------------------------------------
+//	Accumulate sinusoidal energy at frequency f and amplitude a.
+//	The amplitude isn't used for anything.
+//	
+void
+AssociateBandwidth::accumulateSinusoid( double freq, double amp )
+{
+	//	distribute weight at the peak frequency,
+	//	don't mess with negative frequencies:
+	if ( freq > 0. )
+	{
+		//distribute( binFrequency( freq, _regionRate ), 1., _weights );
+		//	new idea: weight Partials by amplitude:
+		distribute( binFrequency( freq, _regionRate ), amp, _weights );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	accumulateNoise
+// ---------------------------------------------------------------------------
+//	Accumulate a rejected spectral peak as surplus (noise) energy.
+//
+void
+AssociateBandwidth::accumulateNoise( double freq, double amp )
+{
+	//	compute energy contribution and distribute 
+	//	at frequency f, don't mess with negative 
+	//	frequencies:
+	if ( freq > 0. )
+    {
+		distribute( binFrequency( freq, _regionRate ), amp * amp, _surplus  );
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	associate
+// ---------------------------------------------------------------------------
+//	Associate bandwidth with a single SpectralPeak.
+//
+void 
+AssociateBandwidth::associate( SpectralPeak & pk )
+{		
+    pk.setBandwidth(0);
+    pk.addNoiseEnergy( computeNoiseEnergy( pk.frequency(), pk.amplitude() ) );
+}
+
+// ---------------------------------------------------------------------------
+//	reset
+// ---------------------------------------------------------------------------
+//	This is called after each distribution of bandwidth energy.
+//
+void
+AssociateBandwidth::reset( void )
+{
+	std::fill( _weights.begin(), _weights.end(), 0. );
+	std::fill( _surplus.begin(), _surplus.end(), 0. );
+}
+
+// ---------------------------------------------------------------------------
+//	associate
+// ---------------------------------------------------------------------------
+//	Perform bandwidth association on a collection of reassigned spectral peaks
+//	or ridges. The range [begin, rejected) spans the Peaks selected to form
+//	Partials. The range [rejected, end) spans the Peaks that were found in
+//	the reassigned spectrum, but rejected as too weak or too close (in 
+//	frequency) to another stronger Peak. 
+//
+void 
+AssociateBandwidth::associateBandwidth( Peaks::iterator begin, 		//	beginning of Peaks
+										Peaks::iterator rejected, 	//	first rejected Peak
+										Peaks::iterator end )		//	end of Peaks
+{		
+	if ( begin == rejected )
+		return;
+		
+	//	accumulate retained Breakpoints as sinusoids, 
+	for ( Peaks::iterator it = begin; it != rejected; ++it )
+	{
+		accumulateSinusoid( it->frequency(), it->amplitude() );
+	}
+	
+	//	accumulate rejected breakpoints as noise:
+	for ( Peaks::iterator it = rejected; it != end; ++it )
+	{
+		accumulateNoise( it->frequency(), it->amplitude() );
+	}
+
+	//	associate bandwidth with each retained Breakpoint:
+	for ( Peaks::iterator it = begin; it != rejected; ++it )
+	{
+        //  sets bandwidth to zero, then calls addNoiseEnergy()
+		associate( *it );
+	}
+	
+	//	reset after association, yuk:
+	reset();
+
+}
diff --git a/src/loris/AssociateBandwidth.h b/src/loris/AssociateBandwidth.h
new file mode 100644
index 0000000..475aeb0
--- /dev/null
+++ b/src/loris/AssociateBandwidth.h
@@ -0,0 +1,109 @@
+#ifndef INCLUDE_ASSOCIATEBANDWIDTH_H
+#define INCLUDE_ASSOCIATEBANDWIDTH_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * AssociateBandwidth.h
+ *
+ * Definition of a class representing a policy for associating noise
+ * (bandwidth) energy with reassigned spectral peaks to be used in
+ * Partial formation.
+ *
+ * Kelly Fitz, 20 Jan 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "SpectralPeaks.h"
+
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+class Breakpoint;
+
+// ---------------------------------------------------------------------------
+//	class AssociateBandwidth
+//
+//	In the new strategy, Breakpoints are extracted and accumulated
+//	as sinusoids. Spectral peaks that are not extracted (don't exceed
+//	the amplitude floor) or are rejected for certain reasons, are 
+//	accumulated diectly as noise (surplus). After all spectral peaks 
+//	have been accumulated as noise or sinusoids, the noise is distributed 
+//	as bandwidth.
+//
+class AssociateBandwidth
+{
+//	-- instance variables --
+	std::vector< double > _weights;	//	weights vector for recording 
+									//	frequency distribution of retained
+									//	sinusoids
+	std::vector< double > _surplus; //	surplus (noise) energy vector for
+	 								//	accumulating the distribution of
+	 								//	spectral energy to be distributed 
+	 								//	as noise
+	
+	double _regionRate;				//	inverse of region center spacing
+	
+//	-- public interface --
+public:
+	//	construction:
+	AssociateBandwidth( double regionWidth, double srate );
+	~AssociateBandwidth( void );
+	
+	//	Perform bandwidth association on a collection of reassigned spectral peaks
+	//	or ridges. The range [begin, rejected) spans the Peaks selected to form
+	//	Partials. The range [rejected, end) spans the Peaks that were found in
+	//	the reassigned spectrum, but rejected as too weak or too close (in 
+	//	frequency) to another stronger Peak. 
+	void associateBandwidth( Peaks::iterator begin, 	//	beginning of Peaks
+							 Peaks::iterator rejected, 	//	first rejected Peak
+							 Peaks::iterator end );		//	end of Peaks
+	
+		
+//	-- private helpers --	
+private:	
+	double computeNoiseEnergy( double freq, double amp );
+	
+	//	These four formerly comprised the public interface
+	//	to this policy, now they are all hidden behind a 
+	//	single call to associateBandwidth.
+	
+	//	energy accumulation:
+	void accumulateNoise( double freq, double amp );	
+	void accumulateSinusoid( double freq, double amp  );	
+	
+	//	bandwidth assocation:
+	void associate( SpectralPeak & pk );
+	
+	//	call this to wipe out the accumulated energy to 
+	//	prepare for the next frame (yuk):
+	void reset( void );
+	
+};	// end of class AssociateBandwidth
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_ASSOCIATEBANDWIDTH_H */
diff --git a/src/loris/BigEndian.C b/src/loris/BigEndian.C
new file mode 100644
index 0000000..515b010
--- /dev/null
+++ b/src/loris/BigEndian.C
@@ -0,0 +1,148 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * BigEndian.C
+ *
+ * Implementation of wrappers for stream-based binary file i/o.
+ *
+ * Kelly Fitz, 23 May 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "BigEndian.h"
+#include "LorisExceptions.h"
+#include <vector>
+#include <iostream>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	bigEndianSystem
+// ---------------------------------------------------------------------------
+//	Return true is this is a big-endian system, false otherwise.
+//
+static bool bigEndianSystem( void )
+{
+#if defined(WORDS_BIGENDIAN)
+	return true;
+#elif HAVE_CONFIG_H && !defined(WORDS_BIGENDIAN)
+	return false;
+#else	
+	static union {
+		int s ;
+		char c[sizeof(int)] ;
+	} x ;
+	bool ret = (x.s = 1, x.c[0] != 1) ? true : false;
+	
+	return ret; // x.c[0] != 1;
+#endif
+}
+
+// ---------------------------------------------------------------------------
+//	swapByteOrder
+// ---------------------------------------------------------------------------
+//	
+static void swapByteOrder( char * bytes, int n )
+{
+	char * beg = bytes, * end = bytes + n - 1;
+	while ( beg < end ) {
+		char tmp = *end;
+		*end = *beg;
+		*beg = tmp;
+		
+		++beg;
+		--end;
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	BigEndian read
+// ---------------------------------------------------------------------------
+//
+std::istream &
+BigEndian::read( std::istream & s, long howmany, int size, char * putemHere )
+{
+	//	read the bytes into data:
+	s.read( putemHere, howmany*size );
+	
+	//	check stream state:	
+    if ( s )
+    {
+        //  if the stream is still in a good state, then
+        //  the correct number of bytes must have been read:
+        Assert( s.gcount() == howmany*size );
+
+        //	swap byte order if nec.
+        if ( ! bigEndianSystem() && size > 1 ) 
+        {
+            for ( long i = 0; i < howmany; ++i )
+            {
+                swapByteOrder( putemHere + (i*size), size );
+            }
+        }
+    }
+    
+    return s;
+}
+
+// ---------------------------------------------------------------------------
+//	BigEndian write
+// ---------------------------------------------------------------------------
+//
+std::ostream &
+BigEndian::write( std::ostream & s, long howmany, int size, const char * stuff )
+{
+	//	swap byte order if nec.
+	if ( ! bigEndianSystem() && size > 1 ) 
+	{
+		//	use a temporary vector to automate storage:
+		std::vector<char> v( stuff, stuff + (howmany*size) );
+		for ( long i = 0; i < howmany; ++i )
+		{
+			swapByteOrder( & v[i*size], size );
+		}
+		s.write( &v[0], howmany*size );
+	}
+	else
+	{
+		//	read the bytes into data:
+		s.write( stuff, howmany*size );
+	}
+	
+	//	check stream state:
+	if ( ! s.good() )
+		Throw( FileIOException, "File write failed. " );
+        
+    return s;
+}
+
+}	//	end of namespace Loris
+
+
diff --git a/src/loris/BigEndian.h b/src/loris/BigEndian.h
new file mode 100644
index 0000000..d4d70e8
--- /dev/null
+++ b/src/loris/BigEndian.h
@@ -0,0 +1,54 @@
+#ifndef INCLUDE_BIGENDIAN_H
+#define INCLUDE_BIGENDIAN_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * BigEndian.h
+ *
+ * Definition of wrappers for stream-based binary file i/o.
+ *
+ * Kelly Fitz, 23 May 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include <iosfwd>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	class BigEndian
+//
+class BigEndian
+{
+public:
+	static std::istream & read( std::istream & s, long howmany, int size, char * putemHere );
+	static std::ostream & write( std::ostream & s, long howmany, int size, const char * stuff );	
+};	//	end of class BigEndian
+
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_BIGENDIAN_H */
diff --git a/src/loris/Breakpoint.C b/src/loris/Breakpoint.C
new file mode 100644
index 0000000..4e5659f
--- /dev/null
+++ b/src/loris/Breakpoint.C
@@ -0,0 +1,129 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Breakpoint.C
+ *
+ * Implementation of class Loris::Breakpoint.
+ *
+ * Kelly Fitz, 16 Aug 99
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "Breakpoint.h"
+#include "LorisExceptions.h"
+#include <cmath>
+
+//	begin namespace
+namespace Loris {
+
+
+// -
+// construction
+
+// ---------------------------------------------------------------------------
+//	Breakpoint default constructor
+// ---------------------------------------------------------------------------
+//!	Construct a new Breakpoint with all parameters initialized to 0
+//!	(needed for STL containability).
+Breakpoint::Breakpoint( void ) :
+	_frequency( 0. ),
+	_amplitude( 0. ),
+	_bandwidth( 0. ),
+	_phase( 0. )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	Breakpoint constructor
+// ---------------------------------------------------------------------------
+//!	Construct a new Breakpoint with the specified parameters.
+//!	
+//!	\param f is the intial frequency.
+//!	\param a is the initial amplitude.
+//!	\param b is the initial bandwidth.
+//!	\param p is the initial phase, if specified (if unspecified, 0 
+//!	is assumed).
+//
+Breakpoint::Breakpoint( double f, double a, double b, double p ) :
+	_frequency( f ),
+	_amplitude( a ),
+	_bandwidth( b ),
+	_phase( p )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	addNoiseEnergy
+// ---------------------------------------------------------------------------
+//!	Add noise (bandwidth) energy to this Breakpoint by computing new 
+//!	amplitude and bandwidth values. enoise may be negative, but 
+//!	noise energy cannot be removed (negative energy added) in excess 
+//!	of the current noise energy.
+//!	
+//!	\param enoise is the amount of noise energy to add to
+//!	this Breakpoint.
+//
+void 
+Breakpoint::addNoiseEnergy( double enoise )
+{
+	//	compute current energies:
+	double e = amplitude() * amplitude();	//	current total energy
+	double n = e * bandwidth();				//	current noise energy
+	
+	//	Assert( e >= n );
+	//	could complain, but its recoverable, just fix it:
+	if ( e < n )
+    {
+		e = n;
+	}
+    
+	//	guard against divide-by-zero, and don't allow
+	//	the sinusoidal energy to decrease:
+	if ( n + enoise > 0. ) 
+	{
+		//	if new noise energy is positive, total
+		//	energy must also be positive:
+		//	Assert( e + enoise > 0 );
+		setBandwidth( (n + enoise) / (e + enoise) );
+		setAmplitude( std::sqrt(e + enoise) );
+	}
+	else 
+	{
+		//	if new noise energy is negative, leave 
+		//	all sinusoidal energy:
+		setBandwidth( 0. );
+		setAmplitude( std::sqrt( e - n ) );
+	}
+}
+
+}	//	end of namespace Loris
+
+
+
+
diff --git a/src/loris/Breakpoint.h b/src/loris/Breakpoint.h
new file mode 100644
index 0000000..31123dd
--- /dev/null
+++ b/src/loris/Breakpoint.h
@@ -0,0 +1,133 @@
+#ifndef INCLUDE_BREAKPOINT_H
+#define INCLUDE_BREAKPOINT_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Breakpoint.h
+ *
+ * Definition of class Loris::Breakpoint.
+ *
+ * Kelly Fitz, 16 Aug 99
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+//	begin namespace
+namespace Loris {
+
+
+// ---------------------------------------------------------------------------
+//	class Breakpoint
+//	
+//!	Class Breakpoint represents a single breakpoint in the
+//!	Partial parameter (frequency, amplitude, bandwidth) envelope.
+//!	Instantaneous phase is also stored, but is only used at the onset of 
+//!	a partial, or when it makes a transition from zero to nonzero amplitude.
+//!	
+//!	Loris Partials represent reassigned bandwidth-enhanced model components.
+//!	A Partial consists of a chain of Breakpoints describing the time-varying
+//!	frequency, amplitude, and bandwidth (noisiness) of the component.
+//!	For more information about Reassigned Bandwidth-Enhanced 
+//!	Analysis and the Reassigned Bandwidth-Enhanced Additive Sound 
+//!	Model, refer to the Loris website: 
+//!	www.cerlsoundgroup.org/Loris/.
+//!	
+//!	Breakpoint is a leaf class, do not subclass.
+//
+class Breakpoint
+{
+//	-- instance variables --
+	double _frequency;	//!	in Hertz
+	double _amplitude;	//!	absolute
+	double _bandwidth;	//!	fraction of total energy that is noise energy
+	double _phase;		//!	radians
+	
+//	-- public Breakpoint interface --
+
+public:
+//	-- construction --
+
+	//!	Construct a new Breakpoint with all parameters initialized to 0
+	//!	(needed for STL containability).
+ 	Breakpoint( void );	
+
+	//!	Construct a new Breakpoint with the specified parameters.
+	//!	
+	//!	\param 	f is the intial frequency.
+	//!	\param 	a is the initial amplitude.
+	//!	\param 	b is the initial bandwidth.
+	//!	\param 	p is the initial phase, if specified (if unspecified, 0 
+	//!			is assumed).
+ 	Breakpoint( double f, double a, double b, double p = 0. );
+
+	//	(use compiler-generated destructor, copy, and assign)
+	
+//	-- access --
+	//!	Return the amplitude of this Breakpoint.
+ 	double amplitude( void ) const { return _amplitude; }
+
+	//!	Return the bandwidth (noisiness) coefficient of this Breakpoint.
+ 	double bandwidth( void ) const { return _bandwidth; }
+
+	//!	Return the frequency of this Breakpoint.
+  	double frequency( void ) const { return _frequency; }
+
+	//!	Return the phase of this Breakpoint.
+	double phase( void ) const { return _phase; }
+	
+//	-- mutation --
+	//!	Set the amplitude of this Breakpoint.
+	//!
+	//!	\param x is the new amplitude
+ 	void setAmplitude( double x ) { _amplitude = x; }
+
+	//!	Set the bandwidth (noisiness) coefficient of this Breakpoint.
+	//!
+	//!	\param x is the new bandwidth
+ 	void setBandwidth( double x ) { _bandwidth = x; }
+
+	//!	Set the frequency of this Breakpoint.
+	//!
+	//!	\param x is the new frequency.
+ 	void setFrequency( double x ) { _frequency = x; }
+
+	//!	Set the phase of this Breakpoint.
+	//!
+	//!	\param x is the new phase.
+ 	void setPhase( double x ) { _phase = x; }
+	 
+	//!	Add noise (bandwidth) energy to this Breakpoint by computing new 
+	//!	amplitude and bandwidth values. enoise may be negative, but 
+	//!	noise energy cannot be removed (negative energy added) in excess 
+	//!	of the current noise energy.
+	//!	
+	//!	\param 	enoise is the amount of noise energy to add to
+	//!			this Breakpoint.
+	void addNoiseEnergy( double enoise );
+	
+};	//	end of class Breakpoint
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_BREAKPOINT_H */
diff --git a/src/loris/BreakpointEnvelope.h b/src/loris/BreakpointEnvelope.h
new file mode 100644
index 0000000..383626a
--- /dev/null
+++ b/src/loris/BreakpointEnvelope.h
@@ -0,0 +1,47 @@
+#ifndef INCLUDE_BREAKPOINTENVELOPE_H
+#define INCLUDE_BREAKPOINTENVELOPE_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * BreakpointEnvelope.h
+ *
+ * Definition of class BreakpointEnvelope.
+ * This class has been renamed LinearEnvelope. The old
+ * name and header are preserved for compatibility.
+ *
+ * Kelly Fitz, 21 July 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "LinearEnvelope.h"
+
+//	begin namespace
+namespace Loris {
+
+   typedef LinearEnvelope BreakpointEnvelope;
+
+}
+
+#endif /* ndef INCLUDE_BREAKPOINTENVELOPE_H */
diff --git a/src/loris/BreakpointUtils.C b/src/loris/BreakpointUtils.C
new file mode 100644
index 0000000..ea1ab68
--- /dev/null
+++ b/src/loris/BreakpointUtils.C
@@ -0,0 +1,89 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * BreakpointUtils.C
+ *
+ * Out-of-line Breakpoint utility functions collected in namespace BreakpointUtils.
+ *
+ * Kelly Fitz, 19 June 2003
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "BreakpointUtils.h"
+#include "Breakpoint.h"
+
+#include <cmath>
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+	const double Pi = M_PI;
+#else
+	const double Pi = 3.14159265358979324;
+#endif
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	makeNullBefore
+// ---------------------------------------------------------------------------
+// 	Return a null (zero-amplitude) Breakpoint to preceed the specified 
+//	Breakpoint, useful for fading in a Partial.
+//
+Breakpoint 
+BreakpointUtils::makeNullBefore( const Breakpoint & bp, double fadeTime )
+{
+	Breakpoint ret( bp );
+	// adjust phase
+	double dp = 2. * Pi * fadeTime * bp.frequency();
+	ret.setPhase( std::fmod( bp.phase() - dp, 2. * Pi ) );
+	ret.setAmplitude(0.);
+	ret.setBandwidth(0.);
+	
+	return ret;
+}
+
+// ---------------------------------------------------------------------------
+//	makeNullAfter
+// ---------------------------------------------------------------------------
+// 	Return a null (zero-amplitude) Breakpoint to succeed the specified 
+//	Breakpoint, useful for fading out a Partial.
+//
+Breakpoint 
+BreakpointUtils::makeNullAfter( const Breakpoint & bp, double fadeTime )
+{
+	Breakpoint ret( bp );
+	// adjust phase
+	double dp = 2. * Pi * fadeTime * bp.frequency();
+	ret.setPhase( std::fmod( bp.phase() + dp, 2. * Pi ) );
+	ret.setAmplitude(0.);
+	ret.setBandwidth(0.);
+
+	return ret;
+}
+
+}	//	end of namespace Loris
diff --git a/src/loris/BreakpointUtils.h b/src/loris/BreakpointUtils.h
new file mode 100644
index 0000000..41fd106
--- /dev/null
+++ b/src/loris/BreakpointUtils.h
@@ -0,0 +1,217 @@
+#ifndef INCLUDE_BREAKPOINTUTILS_H
+#define INCLUDE_BREAKPOINTUTILS_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * BreakpointUtils.h
+ *
+ * Breakpoint utility functions collected in namespace BreakpointUtils.
+ *
+ * Kelly Fitz, 6 July 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "Breakpoint.h"
+#include <algorithm>
+#include <functional>
+
+//	begin namespace
+namespace Loris {
+
+namespace BreakpointUtils {
+
+//	-- free functions --
+
+// ---------------------------------------------------------------------------
+//	addNoiseEnergy
+// ---------------------------------------------------------------------------
+//!	Add noise (bandwidth) energy to a Breakpoint by computing new 
+//!	amplitude and bandwidth values. enoise may be negative, but 
+//!	noise energy cannot be removed (negative energy added) in excess 
+//!	of the current noise energy.
+//!	
+//!	\deprecated This operation is now part of the Breakpoint interface.
+//!				Use Breakpoint::addNoiseEnergy instead.
+//
+inline void addNoiseEnergy( Breakpoint & bp, double enoise ) 
+{ 
+	bp.addNoiseEnergy(enoise); 
+}
+ 
+// ---------------------------------------------------------------------------
+//	makeNullBefore
+// ---------------------------------------------------------------------------
+//!	Return a null (zero-amplitude) Breakpoint to preceed the specified 
+//!	Breakpoint, useful for fading in a Partial.
+//!
+//! \param	bp make a null Breakpoint to preceed this one
+//! \param	fadeTime the time (in seconds) by which the new null Breakpoint
+//!			should preceed bp
+//! \return	a new null Breakpoint, having zero amplitude, frequency equal
+//!			to that of bp, and phase computed back from that of bp
+//
+Breakpoint makeNullBefore( const Breakpoint & bp, double fadeTime ); // see BreakpointUtils.C
+
+
+// ---------------------------------------------------------------------------
+//	addNoiseEnergy
+// ---------------------------------------------------------------------------
+//!	Return a null (zero-amplitude) Breakpoint to succeed the specified 
+//!	Breakpoint, useful for fading out a Partial.
+//!
+//! \param	bp make a null Breakpoint to succeed this one
+//! \param	fadeTime the time (in seconds) by which the new null Breakpoint
+//!			should succeed bp
+//! \return	a new null Breakpoint, having zero amplitude, frequency equal
+//!			to that of bp, and phase computed forward from that of bp
+//
+Breakpoint makeNullAfter( const Breakpoint & bp, double fadeTime ); // see BreakpointUtils.C
+
+//	-- predicates --
+
+// ---------------------------------------------------------------------------
+//	isFrequencyBetween
+//	
+//!	Predicate functor returning true if its Breakpoint argument 
+//!	has frequency between specified bounds, and false otherwise.
+//
+class isFrequencyBetween : 
+	public std::unary_function< const Breakpoint, bool >
+{
+public:
+	//! Return true if its Breakpoint argument has frequency 
+	//! between specified bounds, and false otherwise.
+	bool operator()( const Breakpoint & b )  const
+	{ 
+		return (b.frequency() > _fmin) && 
+			   (b.frequency() < _fmax); 
+	}
+	
+//	constructor:
+
+	//! Construct a predicate functor, specifying two frequency bounds.
+	isFrequencyBetween( double x, double y ) : 
+		_fmin( x ), _fmax( y ) 
+	{ 
+		if (x>y) std::swap(x,y); 
+	}
+		
+//	bounds:
+private:
+	double _fmin, _fmax;
+};
+
+//! Old name for isFrequencyBetween.
+//! \deprecated use isFrequencyBetween instead.
+typedef isFrequencyBetween frequency_between;
+
+// ---------------------------------------------------------------------------
+//	isNonNull
+//
+//!	Predicate functor returning true if a Breakpoint has non-zero 
+//! amplitude, false otherwise.
+//
+static bool isNonNull( const Breakpoint & bp )
+{
+	return bp.amplitude() != 0.;
+}
+
+// ---------------------------------------------------------------------------
+//	isNull
+//
+//!	Predicate functor returning true if a Breakpoint has zero 
+//! amplitude, false otherwise.
+//
+static bool isNull( const Breakpoint & bp )
+{
+	return ! isNonNull( bp );
+}
+
+//	-- comparitors --
+
+// ---------------------------------------------------------------------------
+//	compareFrequencyLess
+//	
+//!	Comparitor (binary) functor returning true if its first Breakpoint
+//!	argument has frequency less than that of its second Breakpoint argument,
+//!	and false otherwise.
+//
+class compareFrequencyLess : 
+	public std::binary_function< const Breakpoint, const Breakpoint, bool >
+{
+public:
+	//! Return true if its first Breakpoint argument has frequency less 
+	//! than that of its second Breakpoint argument, and false otherwise.
+	bool operator()( const Breakpoint & lhs, const Breakpoint & rhs ) const
+		{ return lhs.frequency() < rhs.frequency(); }
+};
+
+//! Old name for compareFrequencyLess.
+//! \deprecated use compareFrequencyLess instead.
+typedef compareFrequencyLess less_frequency;
+
+// ---------------------------------------------------------------------------
+//	compareAmplitudeGreater
+//	
+//!	Comparitor (binary) functor returning true if its first Breakpoint
+//!	argument has amplitude greater than that of its second Breakpoint argument,
+//!	and false otherwise.
+//
+class compareAmplitudeGreater : 
+	public std::binary_function< const Breakpoint, const Breakpoint, bool >
+{
+public:
+	//!	Return true if its first Breakpoint argument has amplitude greater 
+	//!	than that of its second Breakpoint argument, and false otherwise.
+	bool operator()( const Breakpoint & lhs, const Breakpoint & rhs ) const
+		{ return lhs.amplitude() > rhs.amplitude(); }
+};	
+
+//! Old name for compareAmplitudeGreater.
+//! \deprecated use compareAmplitudeGreater instead.
+typedef compareAmplitudeGreater greater_amplitude;
+
+// ---------------------------------------------------------------------------
+//	compareAmplitudeLess
+//	
+//!	Comparitor (binary) functor returning true if its first Breakpoint
+//!	argument has amplitude less than that of its second Breakpoint argument,
+//!	and false otherwise.
+//
+class compareAmplitudeLess : 
+	public std::binary_function< const Breakpoint, const Breakpoint, bool >
+{
+public:
+	//!	Return true if its first Breakpoint argument has amplitude greater 
+	//!	than that of its second Breakpoint argument, and false otherwise.
+	bool operator()( const Breakpoint & lhs, const Breakpoint & rhs ) const
+		{ return lhs.amplitude() < rhs.amplitude(); }
+};	
+
+}	//	end of namespace BreakpointUtils
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_BREAKPOINTUTILS_H */
diff --git a/src/loris/Channelizer.C b/src/loris/Channelizer.C
new file mode 100644
index 0000000..5ab6484
--- /dev/null
+++ b/src/loris/Channelizer.C
@@ -0,0 +1,590 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Channelizer.C
+ *
+ * Implementation of class Channelizer.
+ *
+ * Kelly Fitz, 21 July 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "Channelizer.h"
+#include "Envelope.h"
+#include "LinearEnvelope.h"
+#include "Partial.h"
+#include "PartialList.h"
+#include "Notifier.h"
+
+#include <cmath>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	Channelizer constructor from reference envelope
+// ---------------------------------------------------------------------------
+//!	Construct a new Channelizer using the specified reference
+//!	Envelope to represent the a numbered channel. If the sound
+//! being channelized is known to have detuned harmonics, a 
+//! stretching factor can be specified (defaults to 0 for no 
+//! stretching). The stretching factor can be computed using
+//! the static member computeStretchFactor.
+//!	
+//!	\param 	refChanFreq is an Envelope representing the center frequency
+//!		    of a channel.
+//!	\param  refChanLabel is the corresponding channel number (i.e. 1
+//!		    if refChanFreq is the lowest-frequency channel, and all 
+//!		    other channels are harmonics of refChanFreq, or 2 if  
+//!		    refChanFreq tracks the second harmonic, etc.).
+//! \param  stretchFactor is a stretching factor to account for detuned 
+//!         harmonics, default is 0. 
+//!
+//! \throw  InvalidArgument if refChanLabel is not positive.
+//! \throw  InvalidArgument if stretchFactor is negative.
+//
+Channelizer::Channelizer( const Envelope & refChanFreq, int refChanLabel, double stretchFactor ) :
+	_refChannelFreq( refChanFreq.clone() ),
+	_refChannelLabel( refChanLabel ),
+	_stretchFactor( stretchFactor ),
+    _ampWeighting( 0 )
+{
+	if ( refChanLabel <= 0 )
+	{
+		Throw( InvalidArgument, "Channelizer reference label must be positive." );
+	}
+ 	if ( stretchFactor < 0. )
+	{
+		Throw( InvalidArgument, "Channelizer stretch factor must be non-negative." );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	Channelizer constructor from constant reference frequency
+// ---------------------------------------------------------------------------
+//!	Construct a new Channelizer having a constant reference frequency.
+//!	The specified frequency is the center frequency of the lowest-frequency
+//!	channel (for a harmonic sound, the channel containing the fundamental 
+//!	Partial.
+//!
+//!	\param	refFreq is the reference frequency (in Hz) corresponding
+//!			to the first frequency channel.
+//! \param  stretchFactor is a stretching factor to account for detuned 
+//!         harmonics, default is 0. 
+//!
+//!	\throw	InvalidArgument is the reference frequency is not positive
+Channelizer::Channelizer( double refFreq, double stretchFactor ) :
+	_refChannelFreq( new LinearEnvelope( refFreq ) ),
+	_refChannelLabel( 1 ),
+	_stretchFactor( stretchFactor ),
+    _ampWeighting( 0 )
+{
+	if ( refFreq <= 0 )
+	{
+		Throw( InvalidArgument, "Channelizer reference frequency must be positive." );
+	}
+ 	if ( stretchFactor < 0. )
+	{
+		Throw( InvalidArgument, "Channelizer stretch factor must be non-negative." );
+	}
+}
+
+
+// ---------------------------------------------------------------------------
+//	Channelizer copy constructor 
+// ---------------------------------------------------------------------------
+//!	Construct a new Channelizer that is an exact copy of another.
+//!	The copy represents the same set of frequency channels, constructed
+//!	from the same reference Envelope and channel number.
+//!	
+//!	\param other is the Channelizer to copy
+//
+Channelizer::Channelizer( const Channelizer & other ) :
+	_refChannelFreq( other._refChannelFreq->clone() ),
+	_refChannelLabel( other._refChannelLabel ),
+	_stretchFactor( other._stretchFactor ),
+    _ampWeighting( other._ampWeighting )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	Channelizer assignment 
+// ---------------------------------------------------------------------------
+//!	Assignment operator: make this Channelizer an exact copy of another. 
+//!	This Channelizer is made to represent the same set of frequency channels, 
+//!	constructed from the same reference Envelope and channel number as @a rhs.
+//!
+//!	\param rhs is the Channelizer to copy
+//
+Channelizer & 
+Channelizer::operator=( const Channelizer & rhs )
+{
+	if ( &rhs != this )
+	{
+		_refChannelFreq.reset( rhs._refChannelFreq->clone() );
+		_refChannelLabel = rhs._refChannelLabel;
+		_stretchFactor = rhs._stretchFactor;
+        _ampWeighting = rhs._ampWeighting;
+	}
+	return *this;
+}
+
+
+// ---------------------------------------------------------------------------
+//	Channelizer destructor
+// ---------------------------------------------------------------------------
+//!	Destroy this Channelizer.
+//
+Channelizer::~Channelizer( void )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	amplitudeWeighting
+// ---------------------------------------------------------------------------
+//! Return the exponent applied to amplitude before weighting
+//! the instantaneous estimate of the frequency channel number
+//! for a Partial. zero (default) for no weighting, 1 for linear
+//! amplitude weighting, 2 for power weighting, etc.
+//! Amplitude weighting is a bad idea for many sounds, particularly
+//! those with transients, for which it may emphasize the part of
+//! the Partial having the least reliable frequency estimate.
+//
+double Channelizer::amplitudeWeighting( void ) const
+{
+    return _ampWeighting;
+}
+    
+// ---------------------------------------------------------------------------
+//	setAmplitudeWeighting
+// ---------------------------------------------------------------------------
+//! Set the exponent applied to amplitude before weighting
+//! the instantaneous estimate of the frequency channel number
+//! for a Partial. zero (default) for no weighting, 1 for linear
+//! amplitude weighting, 2 for power weighting, etc.
+//! Amplitude weighting is a bad idea for many sounds, particularly
+//! those with transients, for which it may emphasize the part of
+//! the Partial having the least reliable frequency estimate.
+//
+void Channelizer::setAmplitudeWeighting( double x )
+{
+    _ampWeighting = x;
+}
+
+// ---------------------------------------------------------------------------
+//	stretchFactor
+// ---------------------------------------------------------------------------
+//! Return the stretching factor used to account for detuned
+//! harmonics, as in a piano tone. Normally set to 0 for 
+//! in-tune harmonics. 
+//!
+//! The stretching factor is a small positive number for 
+//! heavy vibrating strings (as in pianos) for which the
+//! mass of the string significantly affects the frequency
+//! of the vibrating modes. See Martin Keane, "Understanding
+//! the complex nature of the piano tone", 2004, for a discussion
+//! and the source of the mode frequency stretching algorithms 
+//! implemented here.
+//
+double Channelizer::stretchFactor( void ) const
+{
+    return _stretchFactor;
+}
+
+// ---------------------------------------------------------------------------
+//	setStretchFactor
+// ---------------------------------------------------------------------------
+//! Set the stretching factor used to account for detuned
+//! harmonics, as in a piano tone. Normally set to 0 for 
+//! in-tune harmonics. The stretching factor for massy 
+//! vibrating strings (like pianos) can be computed from 
+//! the physical characteristics of the string, or using 
+//! computeStretchFactor().
+//!
+//! The stretching factor is a small positive number for 
+//! heavy vibrating strings (as in pianos) for which the
+//! mass of the string significantly affects the frequency
+//! of the vibrating modes. See Martin Keane, "Understanding
+//! the complex nature of the piano tone", 2004, for a discussion
+//! and the source of the mode frequency stretching algorithms 
+//! implemented here.
+//!
+//! \throw  InvalidArgument if stretch is negative.
+//
+void Channelizer::setStretchFactor( double stretch )
+{
+ 	if ( stretch < 0. )
+	{
+		Throw( InvalidArgument, "Channelizer stretch factor must be non-negative." );
+	}
+    _stretchFactor = stretch;
+}
+
+// ---------------------------------------------------------------------------
+//	setStretchFactor
+// ---------------------------------------------------------------------------
+//! Set the stretching factor used to account for (consistently) 
+//! detuned harmonics, as in a piano tone, from a pair of 
+//! mode (harmonic) frequencies and numbers.
+//!
+//! The stretching factor is a small positive number for 
+//! heavy vibrating strings (as in pianos) for which the
+//! mass of the string significantly affects the frequency
+//! of the vibrating modes. See Martin Keane, "Understanding
+//! the complex nature of the piano tone", 2004, for a discussion
+//! and the source of the mode frequency stretching algorithms 
+//! implemented here.
+//!
+//! The stretching factor is computed using computeStretchFactor,
+//! but only a valid stretch factor will ever be assigned. If an
+//! invalid (negative) stretching factor is computed for the
+//! specified frequencies and mode numbers, the stretch factor
+//! will be set to zero.
+//!
+//! \param      fm is the frequency of the Mth stretched harmonic
+//! \param      m is the harmonic number of the harmonic whose frequnecy is fm
+//! \param      fn is the frequency of the Nth stretched harmonic
+//! \param      n is the harmonic number of the harmonic whose frequnecy is fn
+void Channelizer::setStretchFactor( double fm, int m, double fn, int n )
+{
+    const double B = computeStretchFactor( fm, m, fn, n );
+    if ( 0 < B )
+    {
+        _stretchFactor = B;
+    }
+    else
+    {
+        _stretchFactor = 0;
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	computeStretchFactor (STATIC class member)
+// ---------------------------------------------------------------------------
+//! Static member to compute the stretch factor for a sound having
+//! (consistently) detuned harmonics, like piano tones.
+//!
+//! The stretching factor is a small positive number for 
+//! heavy vibrating strings (as in pianos) for which the
+//! mass of the string significantly affects the frequency
+//! of the vibrating modes. See Martin Keane, "Understanding
+//! the complex nature of the piano tone", 2004, for a discussion
+//! and the source of the mode frequency stretching algorithms 
+//! implemented here.
+//!
+//! The value returned by this function MAY NOT be a valid stretch
+//! factor. If this function returns a negative stretch factor,
+//! then the specified pair of frequencies and mode numbers cannot
+//! be used to estimate the effects of string mass on mode frequency
+//! (because the negative stretch factor implies a physical 
+//! impossibility, like negative mass or negative length). 
+//!
+//! \param      fm is the frequency of the Mth stretched harmonic
+//! \param      m is the harmonic number of the harmonic whose frequnecy is fm
+//! \param      fn is the frequency of the Nth stretched harmonic
+//! \param      n is the harmonic number of the harmonic whose frequnecy is fn
+//! \returns    the stretching factor, usually a very small positive
+//!             floating point number, or 0 for pefectly tuned harmonics
+//!             (that is, if fn = n*f1).
+//
+double 
+Channelizer::computeStretchFactor( double fm, int m, double fn, int n )
+{
+ 	if ( fm <= 0. || fn <= 0. )
+	{
+		Throw( InvalidArgument, "Channelizer stretched harmonic frequencies must be positive." );
+	}
+ 	if ( m <= 0 || n <= 0 )
+	{
+		Throw( InvalidArgument, "Channelizer stretched harmonic numbers must be positive." );
+	}
+   
+    //  K is a factor that depends on the frequencies 
+    //  of the two stretched harmonics, equal to 1.0 for
+    //  perfectly tuned (not stretched) harmonics
+    const double K = (m*fn) / (n*fm);
+
+    const double num = 1. - (K*K);
+    const double denom = (K*K*m*m) - (n*n);
+/*
+    OLD and wrong I think
+    double num = (fn*fn) - (n*n*fref*fref);
+    double denom = (n*n*n*n)*(fref*fref);
+*/
+    
+    return num / denom;
+}
+
+// ---------------------------------------------------------------------------
+//	computeStretchFactor (STATIC class member)
+// ---------------------------------------------------------------------------
+//! Static member to compute the stretch factor for a sound having
+//! (consistently) detuned harmonics, like piano tones. Legacy version
+//! that assumes the first argument corresponds to the first partial.
+//!
+//! \param      f1 is the frequency of the lowest numbered (1) partial.
+//! \param      fn is the frequency of the Nth stretched harmonic
+//! \param      n is the harmonic number of the harmonic whose frequnecy is fn
+//! \returns    the stretching factor, usually a very small positive
+//!             floating point number, or 0 for pefectly tuned harmonics
+//!             (that is, for harmonic frequencies fn = n*f1).
+//
+double 
+Channelizer::computeStretchFactor( double f1, double fn, double n )
+{
+    return computeStretchFactor( f1, 1, fn, int(n + 0.5) );
+}
+
+// ---------------------------------------------------------------------------
+//	referenceFrequencyAt
+// ---------------------------------------------------------------------------
+//! Compute the reference frequency at the specified time. For non-stretched 
+//! harmonics, this is simply the ratio of the reference envelope evaluated 
+//! at that time to the reference channel number, and is the center frequecy
+//! for the lowest channel. For stretched harmonics, the reference frequency 
+//! is NOT equal to the center frequency of any of the channels, and is also
+//! a function of the stretch factor. 
+//
+double Channelizer::referenceFrequencyAt( double time ) const
+{
+    const double N = _refChannelLabel;
+    double fref = _refChannelFreq->valueAt( time ) / N;
+    
+    if ( 0 != _stretchFactor )
+    {
+        double divisor = std::sqrt( 1.0 + ( _stretchFactor*N*N) );
+        fref = fref / divisor;
+    }
+    
+    return fref;
+}
+
+// ---------------------------------------------------------------------------
+//	computeFractionalChannelNumber
+// ---------------------------------------------------------------------------
+//! Compute the (fractional) channel number estimate for a Partial having a
+//! given frequency at a specified time. For ordinary harmonics, this
+//! is simply the ratio of the specified frequency to the reference
+//! frequency at the specified time. For stretched harmonics (as in 
+//! a piano), the stretching factor is used to compute the frequency
+//! of the corresponding modes of a massy string. See Martin Keane, 
+//! "Understanding the complex nature of the piano tone", 2004, for 
+//! the source of the mode frequency stretching algorithms 
+//! implemented here.
+//!
+//! The fractional channel number is used internally to determine
+//! a best estimate for the channel number (label) for a Partial
+//! having time-varying frequency. 
+//!
+//! \param  time is the time (in seconds) at which to evalute 
+//!         the reference envelope
+//! \param  frequency is the frequency (in Hz) for wihch the channel
+//!         number is to be determined
+//! \return the fractional channel number corresponding to the specified
+//!         frequency and time
+//
+double 
+Channelizer::computeFractionalChannelNumber( double time, double frequency ) const
+{
+    double refFreq = referenceFrequencyAt( time );
+    
+    if ( 0 == _stretchFactor )
+    {
+        return frequency / refFreq;
+    }
+    
+    /*
+    const double frefsqrd = fref*fref;
+    double num = sqrt( (frefsqrd*frefsqrd) + (4*stretch*frefsqrd*fn*fn) ) - (frefsqrd);
+    double denom = 2*stretch*frefsqrd;
+    return sqrt( num / denom );
+    */
+    
+    //  else:
+    //  avoid squaring big numbers... two sqrts kind of sucks too.
+    const double rB = 1. / _stretchFactor;     // reciprocal of B, the stretch factor
+    const double fratio = frequency / refFreq;
+    return std::sqrt( std::sqrt( (.25 * rB * rB) + (fratio * fratio * rB) ) - (.5 * rB) );
+}
+
+// ---------------------------------------------------------------------------
+//	computeChannelNumber
+// ---------------------------------------------------------------------------
+//! Compute the (fractional) channel number estimate for a Partial having a
+//! given frequency at a specified time. For ordinary harmonics, this
+//! is simply the ratio of the specified frequency to the reference
+//! frequency at the specified time. For stretched harmonics (as in 
+//! a piano), the stretching factor is used to compute the frequency
+//! of the corresponding modes of a massy string. See Martin Keane, 
+//! "Understanding the complex nature of the piano tone", 2004, for 
+//! the source of the mode frequency stretching algorithms 
+//! implemented here.
+//! 
+//! \param  time is the time (in seconds) at which to evalute 
+//!         the reference envelope
+//! \param  frequency is the frequency (in Hz) for wihch the channel
+//!         number is to be determined
+//! \return the channel number corresponding to the specified
+//!         frequency and time
+//
+int 
+Channelizer::computeChannelNumber( double time, double frequency ) const
+{    
+    return int( computeFractionalChannelNumber( time, frequency ) + 0.5 );
+}
+
+// ---------------------------------------------------------------------------
+//	channelFrequencyAt
+// ---------------------------------------------------------------------------
+//! Compute the center frequency of one a channel at the specified
+//! time. For non-stretched harmonics, this is simply the value
+//! of the reference envelope scaled by the ratio of the specified
+//! channel number to the reference channel number. For stretched
+//! harmonics, the channel center frequency is computed using the
+//! stretch factor. See Martin Keane, "Understanding
+//! the complex nature of the piano tone", 2004, for a discussion
+//! and the source of the mode frequency stretching algorithms 
+//! implemented here.
+//!
+//! \param  time is the time (in seconds) at which to evalute 
+//!         the reference envelope
+//! \param  channel is the frequency channel (or harmonic, or vibrational     
+//!         mode) number whose frequency is to be determined
+//! \return the center frequency in Hz of the specified frequency channel
+//!         at the specified time
+//
+double 
+Channelizer::channelFrequencyAt( double time, int channel ) const
+{
+    const double fref = referenceFrequencyAt( time );
+    double fn = channel * fref;
+    
+    if ( 0 != _stretchFactor )
+    {
+        const double scale = std::sqrt( 1.0 + (_stretchFactor*channel*channel) );
+        fn = fn * scale;
+    }
+    return fn;
+}
+
+// ---------------------------------------------------------------------------
+//	channelize (one Partial)
+// ---------------------------------------------------------------------------
+//!	Label a Partial with the number of the frequency channel corresponding to
+//!	the average frequency over all the Partial's Breakpoints.
+//!	
+//!	\param partial is the Partial to label.
+//
+void
+Channelizer::channelize( Partial & partial ) const
+{
+    using std::pow;
+
+	debugger << "channelizing Partial with " << partial.numBreakpoints() << " Breakpoints" << endl;
+			
+	//	compute an amplitude-weighted average channel
+	//	label for each Partial:
+	//double ampsum = 0.;
+	double weightedlabel = 0.;
+	Partial::const_iterator bp;
+	for ( bp = partial.begin(); bp != partial.end(); ++bp )
+	{
+				
+		double f = bp.breakpoint().frequency();
+		double t = bp.time();
+		
+        double weight = 1;
+        if ( 0 != _ampWeighting )
+        {
+            //  This used to be an amplitude-weighted avg, but for many sounds, 
+            //  particularly those for which the weighted avg would be very
+            //  different from the simple avg, the amplitude-weighted avg
+            //  emphasized the part of the sound in which the frequency estimates
+            //  are least reliable (e.g. a piano tone). The unweighted 
+            //  average should give more intuitive results in most cases.
+
+            //	use sinusoidal amplitude:
+            double a = bp.breakpoint().amplitude() * std::sqrt( 1. - bp.breakpoint().bandwidth() );                
+            weight = pow( a, _ampWeighting );
+        }
+        
+        weightedlabel += weight * computeFractionalChannelNumber( t, f );
+	}
+	
+	int label = 0;
+	if ( 0 < partial.numBreakpoints() ) //  should always be the case
+	{        
+		label = (int)((weightedlabel / partial.numBreakpoints()) + 0.5);
+	}
+	Assert( label >= 0 );
+			
+	//	assign label, and remember it, but
+	//	only if it is a valid (positive) 
+	//	distillation label:
+	partial.setLabel( label );
+
+}
+
+// -- simplified interface --
+
+
+// ---------------------------------------------------------------------------
+//	channelize (static simplified interface)
+// ---------------------------------------------------------------------------
+//! Static member that constructs an instance and applies
+//! it to a PartialList (simplified interface). 
+//!
+//! Construct a Channelizer using the specified Envelope
+//! and reference label, and use it to channelize a
+//! sequence of Partials. 
+//!
+//! \param  partials is the sequence of Partials to 
+//!         channelize.
+//! \param  refChanFreq is an Envelope representing the center frequency
+//!         of a channel.
+//! \param  refChanLabel is the corresponding channel number (i.e. 1
+//!         if refChanFreq is the lowest-frequency channel, and all 
+//!         other channels are harmonics of refChanFreq, or 2 if  
+//!         refChanFreq tracks the second harmonic, etc.).
+//! \throw  InvalidArgument if refChanLabel is not positive.
+//
+void 
+Channelizer::channelize( PartialList & partials,
+                         const Envelope & refChanFreq, int refChanLabel )
+{
+    Channelizer instance( refChanFreq, refChanLabel );
+
+    for ( PartialList::iterator it = partials.begin(); it != partials.end(); ++it )
+    {
+        instance.channelize( *it );
+    }
+}
+
+
+}	//	end of namespace Loris
diff --git a/src/loris/Channelizer.h b/src/loris/Channelizer.h
new file mode 100644
index 0000000..d57932b
--- /dev/null
+++ b/src/loris/Channelizer.h
@@ -0,0 +1,526 @@
+#ifndef INCLUDE_CHANNELIZER_H
+#define INCLUDE_CHANNELIZER_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Channelizer.h
+ *
+ * Definition of class Loris::Channelizer.
+ *
+ * Kelly Fitz, 21 July 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "PartialList.h"
+
+#include <memory>
+
+//  begin namespace
+namespace Loris {
+
+class Envelope;
+class Partial;
+
+// ---------------------------------------------------------------------------
+//  Channelizer
+//  
+//! Class Channelizer represents an algorithm for automatic labeling of
+//! a sequence of Partials. Partials must be labeled in
+//! preparation for morphing (see Morpher) to establish correspondences
+//! between Partials in the morph source and target sounds. 
+//! 
+//! Channelized partials are labeled according to their adherence to a
+//! harmonic frequency structure with a time-varying fundamental
+//! frequency. The frequency spectrum is partitioned into
+//! non-overlapping channels having time-varying center frequencies that
+//! are harmonic (integer) multiples of a specified reference frequency
+//! envelope, and each channel is identified by a unique label equal to
+//! its harmonic number. Each Partial is assigned the label
+//! corresponding to the channel containing the greatest portion of its
+//! (the Partial's) energy. 
+//! 
+//! A reference frequency Envelope for channelization and the channel
+//! number to which it corresponds (1 for an Envelope that tracks the
+//! Partial at the fundamental frequency) must be specified. The
+//! reference Envelope can be constructed explcitly, point by point
+//! (using, for example, the BreakpointEnvelope class), or constructed
+//! automatically using the FrequencyReference class. 
+//!
+//! The Channelizer can be configured with a stretch factor, to accomodate
+//! detuned harmonics, as in the case of piano tones. The static member
+//! computeStretchFactor can compute the apppropriate stretch factor, given
+//! a pair of partials. This computation is based on formulae given in 
+//! "Understanding the complex nature of the piano tone" by Martin Keane
+//! at the Acoustics Research Centre at the University of Aukland (Feb 2004).
+//! The stretching factor must be non-negative (and is zero for perfectly
+//! tunes harmonics). Even in the case of stretched harmonics, the
+//! reference frequency envelope is assumed to track the frequency of
+//! one of the partials, and the center frequency of the corresponding
+//! channel, even though it may represent a stretched harmonic.
+//! 
+//! Channelizer is a leaf class, do not subclass.
+//
+class Channelizer
+{
+//  -- implementaion --
+    std::auto_ptr< Envelope > _refChannelFreq;  //! the reference frequency envelope
+    
+    int _refChannelLabel;                       //! the channel number corresponding to the
+                                                //! reference frequency (1 for the fundamental)
+                                                
+    double _stretchFactor;                      //! stretching factor to account for 
+                                                //! detuned harmonics, as in the case of the piano; 
+                                                //! can be computed using the static member
+                                                //! computeStretchFactor. Should be 0 for most
+                                                //! (strongly harmonic) sounds.
+
+    double _ampWeighting;                       //! exponent for amplitude weighting in channel
+                                                //! computation, 0 for no weighting, 1 for linear
+                                                //! amplitude weighting, 2 for power weighting, etc.
+                                                //! default is 0, amplitude weighting is a bad idea
+                                                //! for many sounds
+    
+//  -- public interface --
+public:
+//  -- construction --
+
+    //! Construct a new Channelizer using the specified reference
+    //! Envelope to represent the a numbered channel. If the sound
+    //! being channelized is known to have detuned harmonics, a 
+    //! stretching factor can be specified (defaults to 0 for no 
+    //! stretching). The stretching factor can be computed using
+    //! the static member computeStretchFactor.
+    //! 
+    //! \param  refChanFreq is an Envelope representing the center frequency
+    //!         of a channel.
+    //! \param  refChanLabel is the corresponding channel number (i.e. 1
+    //!         if refChanFreq is the lowest-frequency channel, and all 
+    //!         other channels are harmonics of refChanFreq, or 2 if  
+    //!         refChanFreq tracks the second harmonic, etc.).
+    //! \param  stretchFactor is a stretching factor to account for detuned 
+    //!         harmonics, default is 0. 
+    //!
+    //! \throw  InvalidArgument if refChanLabel is not positive.
+    //! \throw  InvalidArgument if stretchFactor is negative.
+    Channelizer( const Envelope & refChanFreq, int refChanLabel, double stretchFactor = 0 );
+     
+    //! Construct a new Channelizer having a constant reference frequency.
+    //! The specified frequency is the center frequency of the lowest-frequency
+    //! channel (for a harmonic sound, the channel containing the fundamental 
+    //! Partial.
+    //!
+    //! \param  refFreq is the reference frequency (in Hz) corresponding
+    //!         to the first frequency channel.
+    //! \param  stretchFactor is a stretching factor to account for detuned 
+    //!         harmonics, default is 0. 
+    //!
+    //! \throw  InvalidArgument if refChanLabel is not positive.
+    //! \throw  InvalidArgument if stretchFactor is negative.
+    Channelizer( double refFreq, double stretchFactor = 0 );
+         
+    //! Construct a new Channelizer that is an exact copy of another.
+    //! The copy represents the same set of frequency channels, constructed
+    //! from the same reference Envelope and channel number.
+    //! 
+    //! \param other is the Channelizer to copy
+    Channelizer( const Channelizer & other );
+     
+    //! Assignment operator: make this Channelizer an exact copy of another. 
+    //! This Channelizer is made to represent the same set of frequency channels, 
+    //! constructed from the same reference Envelope and channel number as rhs.
+    //!
+    //! \param rhs is the Channelizer to copy
+    Channelizer & operator=( const Channelizer & rhs );
+     
+    //! Destroy this Channelizer.
+    ~Channelizer( void );
+     
+//  -- channelizing --
+
+    //! Label a Partial with the number of the frequency channel containing
+    //! the greatest portion of its (the Partial's) energy.
+    //! 
+    //! \param partial is the Partial to label.
+    void channelize( Partial & partial ) const;
+
+    //! Assign each Partial in the specified half-open (STL-style) range
+    //! the label corresponding to the frequency channel containing the
+    //! greatest portion of its (the Partial's) energy.
+    //! 
+    //! \param begin is the beginning of the range of Partials to channelize
+    //! \param end is (one-past) the end of the range of Partials to channelize
+    //! 
+    //! If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+    //! must be PartialList::iterators, otherwise they can be any type
+    //! of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    template<typename Iter>
+    void channelize( Iter begin, Iter end ) const;
+#else
+    void channelize( PartialList::iterator begin, PartialList::iterator end ) const;
+#endif   
+
+    //! Function call operator: same as channelize().
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    template<typename Iter>
+    void operator() ( Iter begin, Iter end ) const
+#else
+    inline
+    void operator() ( PartialList::iterator begin, PartialList::iterator end ) const
+#endif
+         { channelize( begin, end ); }
+         
+    //! Compute the center frequency of one a channel at the specified
+    //! time. For non-stretched harmonics, this is simply the value
+    //! of the reference envelope scaled by the ratio of the specified
+    //! channel number to the reference channel number. For stretched
+    //! harmonics, the channel center frequency is computed using the
+    //! stretch factor. See Martin Keane, "Understanding
+    //! the complex nature of the piano tone", 2004, for a discussion
+    //! and the source of the mode frequency stretching algorithms 
+    //! implemented here.
+    //!
+    //! \param  time is the time (in seconds) at which to evalute 
+    //!         the reference envelope
+    //! \param  channel is the frequency channel (or harmonic, or vibrational     
+    //!         mode) number whose frequency is to be determined
+    //! \return the center frequency in Hz of the specified frequency channel
+    //!         at the specified time
+    double channelFrequencyAt( double time, int channel ) const;
+
+    //! Compute the (fractional) channel number estimate for a Partial having a
+    //! given frequency at a specified time. For ordinary harmonics, this
+    //! is simply the ratio of the specified frequency to the reference
+    //! frequency at the specified time. For stretched harmonics (as in 
+    //! a piano), the stretching factor is used to compute the frequency
+    //! of the corresponding modes of a massy string. See Martin Keane, 
+    //! "Understanding the complex nature of the piano tone", 2004, for 
+    //! the source of the mode frequency stretching algorithms 
+    //! implemented here.
+    //! 
+    //! \param  time is the time (in seconds) at which to evalute 
+    //!         the reference envelope
+    //! \param  frequency is the frequency (in Hz) for wihch the channel
+    //!         number is to be determined
+    //! \return the channel number corresponding to the specified
+    //!         frequency and time
+    int computeChannelNumber( double time, double frequency ) const;
+    
+    //! Compute the (fractional) channel number estimate for a Partial having a
+    //! given frequency at a specified time. For ordinary harmonics, this
+    //! is simply the ratio of the specified frequency to the reference
+    //! frequency at the specified time. For stretched harmonics (as in 
+    //! a piano), the stretching factor is used to compute the frequency
+    //! of the corresponding modes of a massy string. See Martin Keane, 
+    //! "Understanding the complex nature of the piano tone", 2004, for 
+    //! the source of the mode frequency stretching algorithms 
+    //! implemented here.
+    //!
+    //! The fractional channel number is used internally to determine
+    //! a best estimate for the channel number (label) for a Partial
+    //! having time-varying frequency. 
+    //! 
+    //! \param  time is the time (in seconds) at which to evalute 
+    //!         the reference envelope
+    //! \param  frequency is the frequency (in Hz) for wihch the channel
+    //!         number is to be determined
+    //! \return the fractional channel number corresponding to the specified
+    //!         frequency and time
+    double computeFractionalChannelNumber( double time, double frequency ) const;
+    
+    
+    //! Compute the reference frequency at the specified time. For non-stretched 
+    //! harmonics, this is simply the ratio of the reference envelope evaluated 
+    //! at that time to the reference channel number, and is the center frequecy
+    //! for the lowest channel. For stretched harmonics, the reference frequency 
+    //! is NOT equal to the center frequency of any of the channels, and is also
+    //! a function of the stretch factor. 
+    //!
+    //! \param  time is the time (in seconds) at which to evalute 
+    //!         the reference envelope
+    double referenceFrequencyAt( double time ) const;
+
+//  -- access/mutation --
+         
+    //! Return the exponent applied to amplitude before weighting
+    //! the instantaneous estimate of the frequency channel number
+    //! for a Partial. zero (default) for no weighting, 1 for linear
+    //! amplitude weighting, 2 for power weighting, etc.
+    //! Amplitude weighting is a bad idea for many sounds, particularly
+    //! those with transients, for which it may emphasize the part of
+    //! the Partial having the least reliable frequency estimate.
+    double amplitudeWeighting( void ) const;
+
+    //! Set the exponent applied to amplitude before weighting
+    //! the instantaneous estimate of the frequency channel number
+    //! for a Partial. zero (default) for no weighting, 1 for linear
+    //! amplitude weighting, 2 for power weighting, etc.
+    //! Amplitude weighting is a bad idea for many sounds, particularly
+    //! those with transients, for which it may emphasize the part of
+    //! the Partial having the least reliable frequency estimate.
+    void setAmplitudeWeighting( double expon );
+
+    //! Return the stretching factor used to account for detuned
+    //! harmonics, as in a piano tone. Normally set to 0 for 
+    //! in-tune harmonics.
+    //!
+    //! The stretching factor is a small positive number for 
+    //! heavy vibrating strings (as in pianos) for which the
+    //! mass of the string significantly affects the frequency
+    //! of the vibrating modes. See Martin Keane, "Understanding
+    //! the complex nature of the piano tone", 2004, for a discussion
+    //! and the source of the mode frequency stretching algorithms 
+    //! implemented here.
+    double stretchFactor( void ) const;
+        
+    //! Set the stretching factor used to account for detuned
+    //! harmonics, as in a piano tone. Normally set to 0 for 
+    //! in-tune harmonics. The stretching factor for massy 
+    //! vibrating strings (like pianos) can be computed from 
+    //! the physical characteristics of the string, or using 
+    //! computeStretchFactor(). 
+    //!
+    //! The stretching factor is a small positive number for 
+    //! heavy vibrating strings (as in pianos) for which the
+    //! mass of the string significantly affects the frequency
+    //! of the vibrating modes. See Martin Keane, "Understanding
+    //! the complex nature of the piano tone", 2004, for a discussion
+    //! and the source of the mode frequency stretching algorithms 
+    //! implemented here.
+    //!
+    //! \throw  InvalidArgument if stretch is negative.
+    void setStretchFactor( double stretch );    
+    
+         
+// -- static members --
+
+     
+    //! Static member to compute the stretch factor for a sound having
+    //! (consistently) detuned harmonics, like piano tones.
+    //!
+    //! The stretching factor is a small positive number for 
+    //! heavy vibrating strings (as in pianos) for which the
+    //! mass of the string significantly affects the frequency
+    //! of the vibrating modes. See Martin Keane, "Understanding
+    //! the complex nature of the piano tone", 2004, for a discussion
+    //! and the source of the mode frequency stretching algorithms 
+    //! implemented here.
+    //!
+    //! The value returned by this function MAY NOT be a valid stretch
+    //! factor. If this function returns a negative stretch factor,
+    //! then the specified pair of frequencies and mode numbers cannot
+    //! be used to estimate the effects of string mass on mode frequency
+    //! (because the negative stretch factor implies a physical 
+    //! impossibility, like negative mass or negative length). 
+    //!
+    //! \param      fm is the frequency of the Mth stretched harmonic
+    //! \param      m is the harmonic number of the harmonic whose frequnecy is fm
+    //! \param      fn is the frequency of the Nth stretched harmonic
+    //! \param      n is the harmonic number of the harmonic whose frequnecy is fn
+    //! \returns    the stretching factor, usually a very small positive
+    //!             floating point number, or 0 for pefectly tuned harmonics
+    //!             (that is, if fn = n*f1).
+    static double computeStretchFactor( double fm, int m, double fn, int n );
+
+
+// -- simplified interface --
+
+    //! Static member that constructs an instance and applies
+    //! it to a PartialList (simplified interface). 
+    //!
+    //! Construct a Channelizer using the specified Envelope
+    //! and reference label, and use it to channelize a
+    //! sequence of Partials. 
+    //!
+    //! \param  partials is the sequence of Partials to 
+    //!         channelize.
+    //! \param  refChanFreq is an Envelope representing the center frequency
+    //!         of a channel.
+    //! \param  refChanLabel is the corresponding channel number (i.e. 1
+    //!         if refChanFreq is the lowest-frequency channel, and all 
+    //!         other channels are harmonics of refChanFreq, or 2 if  
+    //!         refChanFreq tracks the second harmonic, etc.).
+    //! \throw  InvalidArgument if refChanLabel is not positive.
+    static 
+    void channelize( PartialList & partials,
+                     const Envelope & refChanFreq, int refChanLabel );
+
+     
+
+// -- DEPRECATED members --
+
+    //! DEPRECATED
+    //!
+    //! Set the stretching factor used to account for (consistently) 
+    //! detuned harmonics, as in a piano tone, from a pair of 
+    //! mode (harmonic) frequencies and numbers.
+    //!
+    //! The stretching factor is a small positive number for 
+    //! heavy vibrating strings (as in pianos) for which the
+    //! mass of the string significantly affects the frequency
+    //! of the vibrating modes. See Martin Keane, "Understanding
+    //! the complex nature of the piano tone", 2004, for a discussion
+    //! and the source of the mode frequency stretching algorithms 
+    //! implemented here.
+    //!
+    //! The stretching factor is computed using computeStretchFactor,
+    //! but only a valid stretch factor will ever be assigned. If an
+    //! invalid (negative) stretching factor is computed for the
+    //! specified frequencies and mode numbers, the stretch factor
+    //! will be set to zero.
+    //!
+    //! \param      fm is the frequency of the Mth stretched harmonic
+    //! \param      m is the harmonic number of the harmonic whose frequnecy is fm
+    //! \param      fn is the frequency of the Nth stretched harmonic
+    //! \param      n is the harmonic number of the harmonic whose frequnecy is fn
+    void setStretchFactor( double fm, int m, double fn, int n );
+    
+
+    //! DEPRECATED
+    //!
+    //! Static member that constructs an instance and applies
+    //! it to a sequence of Partials. 
+    //! Construct a Channelizer using the specified Envelope
+    //! and reference label, and use it to channelize a
+    //! sequence of Partials. 
+    //!
+    //! \param  begin is the beginning of a sequence of Partials to 
+    //!         channelize.
+    //! \param  end is the end of a sequence of Partials to 
+    //!         channelize.
+    //! \param  refChanFreq is an Envelope representing the center frequency
+    //!         of a channel.
+    //! \param  refChanLabel is the corresponding channel number (i.e. 1
+    //!         if refChanFreq is the lowest-frequency channel, and all 
+    //!         other channels are harmonics of refChanFreq, or 2 if  
+    //!         refChanFreq tracks the second harmonic, etc.).
+    //! \throw  InvalidArgument if refChanLabel is not positive.
+    //! 
+    //! If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+    //! must be PartialList::iterators, otherwise they can be any type
+    //! of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    template< typename Iter >
+    static 
+    void channelize( Iter begin, Iter end, 
+                     const Envelope & refChanFreq, int refChanLabel );
+#else
+    static inline 
+    void channelize( PartialList::iterator begin, PartialList::iterator end,
+                     const Envelope & refChanFreq, int refChanLabel );
+#endif   
+
+     
+    //! DEPRECATED
+    //!
+    //! Static member to compute the stretch factor for a sound having
+    //! (consistently) detuned harmonics, like piano tones. Legacy version
+    //! that assumes the first argument corresponds to the first partial.
+    //!
+    //! \param      f1 is the frequency of the lowest numbered (1) partial.
+    //! \param      fn is the frequency of the Nth stretched harmonic
+    //! \param      n is the harmonic number of the harmonic whose frequnecy is fn
+    //! \returns    the stretching factor, usually a very small positive
+    //!             floating point number, or 0 for pefectly tuned harmonics
+    //!             (that is, for harmonic frequencies fn = n*f1).
+    static double computeStretchFactor( double f1, double fn, double n );
+    
+};  //  end of class Channelizer
+
+// ---------------------------------------------------------------------------
+//  channelize (sequence of Partials)
+// ---------------------------------------------------------------------------
+//! Assign each Partial in the specified half-open (STL-style) range
+//! the label corresponding to the frequency channel containing the
+//! greatest portion of its (the Partial's) energy.
+//! 
+//! \param begin is the beginning of the range of Partials to channelize
+//! \param end is (one-past) the end of the range of Partials o channelize
+//! 
+//! If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+//! must be PartialList::iterators, otherwise they can be any type
+//! of iterators over a sequence of Partials.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void Channelizer::channelize( Iter begin, Iter end ) const
+#else
+inline
+void Channelizer::channelize( PartialList::iterator begin, PartialList::iterator end ) const
+#endif
+{
+    while ( begin != end )
+    {
+        channelize( *begin++ );
+    }
+}
+
+// ---------------------------------------------------------------------------
+//  channelize (static)
+// ---------------------------------------------------------------------------
+//! DEPRECATED
+//!
+//!   Static member that constructs an instance and applies
+//!   it to a sequence of Partials. 
+//!   Construct a Channelizer using the specified Envelope
+//!   and reference label, and use it to channelize a
+//!   sequence of Partials. 
+//!
+//!   \param   begin is the beginning of a sequence of Partials to 
+//!            channelize.
+//!   \param   end is the end of a sequence of Partials to 
+//!            channelize.
+//!   \param    refChanFreq is an Envelope representing the center frequency
+//!             of a channel.
+//!   \param    refChanLabel is the corresponding channel number (i.e. 1
+//!             if refChanFreq is the lowest-frequency channel, and all 
+//!             other channels are harmonics of refChanFreq, or 2 if  
+//!             refChanFreq tracks the second harmonic, etc.).
+//!   \throw   InvalidArgument if refChanLabel is not positive.
+//! 
+//! If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+//! must be PartialList::iterators, otherwise they can be any type
+//! of iterators over a sequence of Partials.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename Iter >
+void Channelizer::channelize( Iter begin, Iter end, 
+                              const Envelope & refChanFreq, int refChanLabel )
+#else
+inline
+void Channelizer::channelize( PartialList::iterator begin, PartialList::iterator end,
+                              const Envelope & refChanFreq, int refChanLabel )
+#endif   
+{
+   Channelizer instance( refChanFreq, refChanLabel );
+    while ( begin != end )
+    {
+        instance.channelize( *begin++ );
+    }
+}
+
+}   //  end of namespace Loris
+
+#endif /* ndef INCLUDE_CHANNELIZER_H */
diff --git a/src/loris/Collator.C b/src/loris/Collator.C
new file mode 100644
index 0000000..1cbddbf
--- /dev/null
+++ b/src/loris/Collator.C
@@ -0,0 +1,190 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Collator.h
+ *
+ * Definition of class Collator.
+ *
+ * Kelly Fitz, 29 April 2005
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "Collator.h"
+#include "Breakpoint.h"
+#include "BreakpointUtils.h"
+#include "LorisExceptions.h"
+#include "Partial.h"
+#include "PartialList.h"
+#include "PartialUtils.h"
+#include "Notifier.h"
+
+#include <algorithm>
+#include <functional>
+#include <utility>
+
+//	begin namespace
+namespace Loris {
+
+
+// ---------------------------------------------------------------------------
+//	Collator constructor
+// ---------------------------------------------------------------------------
+//! Construct a new Collator using the specified fade and gap times
+//! between Partials. When two Partials are joined, the collated Partial
+//! fades out at the end of the earlier Partial and back in again
+//! at the onset of the later one. The fade time is the time over
+//! which these fades occur. By default, use a 5 ms fade time.
+//!	The gap time is the additional time over which a Partial faded
+//!	out must remain at zero amplitude before it can fade back in.
+//!	By default, use a gap time of one millisecond, to 
+//!	prevent a pair of arbitrarily close null Breakpoints being
+//!	inserted. (Defaults are copied from the Distiller.)
+//!
+//!   \param   partialFadeTime is the time (in seconds) over
+//!            which Partials joined by distillation fade to
+//!            and from zero amplitude. Default is 0.005 (one
+//!            millisecond).
+//!   \param   partialSilentTime is the minimum duration (in seconds) 
+//!            of the silent (zero-amplitude) gap between two 
+//!            Partials joined by distillation. (Default is
+//!            0.001 (one millisecond).
+Collator::Collator( double partialFadeTime, double partialSilentTime ) :
+	_fadeTime( partialFadeTime ),
+	_gapTime( partialSilentTime )
+{
+	if ( _fadeTime <= 0.0 )
+	{
+		Throw( InvalidArgument, "Collator fade time must be positive." );
+	}
+	if ( _gapTime <= 0.0 )
+	{
+		Throw( InvalidArgument, "Collator gap time must be positive." );
+	}
+}
+
+// -- helpers --
+
+// ---------------------------------------------------------------------------
+//	helper predicates
+// ---------------------------------------------------------------------------
+static bool ends_earlier( const Partial & lhs, const Partial & rhs )
+{
+	return lhs.endTime() < rhs.endTime();
+}
+
+struct ends_before : public std::unary_function< const Partial, bool >
+{
+	double t;
+	ends_before( double time ) : t( time ) {}
+	
+	bool operator() ( const Partial & p ) const 
+		{ return p.endTime() < t; }
+};
+
+// ---------------------------------------------------------------------------
+//	collateAux
+// ---------------------------------------------------------------------------
+//! Collate unlabeled (zero labeled) Partials into the smallest
+//! possible number of Partials that does not combine any temporally
+//! overlapping Partials. The unlabeled Partials are
+//! collated in-place.
+//
+void Collator::collateAux( PartialList & unlabeled  )
+{
+	debugger << "Collator found " << unlabeled.size() 
+			 << " unlabeled Partials, collating..." << endl;
+	
+	// 	sort Partials by end time:
+	// 	thanks to Ulrike Axen for this optimal algorithm!
+	unlabeled.sort( ends_earlier );
+	
+	//	invariant:
+	//	Partials in the range [partials.begin(), endcollated)
+	//	are the collated Partials.
+	PartialList::iterator endcollated = unlabeled.begin();
+	while ( endcollated != unlabeled.end() )
+	{
+		//	find a collated Partial that ends
+		//	before this one begins.
+		//	There must be a gap of at least
+		//	twice the _fadeTime, because this algorithm
+		//	does not remove any null Breakpoints, and 
+		//	because Partials joined in this way might
+		//	be far apart in frequency.
+		const double clearance = (2.*_fadeTime) + _gapTime;
+		PartialList::iterator it = 
+			std::find_if( unlabeled.begin(), endcollated, 
+                          ends_before( endcollated->startTime() - clearance) );
+						  
+		// 	if no such Partial exists, then this Partial
+		//	becomes one of the collated ones, otherwise, 
+		//	insert two null Breakpoints, and then all
+		//	the Breakpoints in this Partial:
+		if ( it != endcollated )
+		{
+			Partial & addme = *endcollated;
+			Partial & collated = *it;
+			Assert( &addme != &collated );
+			
+			//	insert a null at the (current) end
+			//	of collated:
+			double nulltime1 = collated.endTime() + _fadeTime;
+			Breakpoint null1( collated.frequencyAt(nulltime1), 0., 
+							  collated.bandwidthAt(nulltime1), collated.phaseAt(nulltime1) );			
+			collated.insert( nulltime1, null1 );
+
+			//	insert a null at the beginning of
+			//	of the current Partial:
+			double nulltime2 = addme.startTime() - _fadeTime;
+			Assert( nulltime2 >= nulltime1 );
+			Breakpoint null2( addme.frequencyAt(nulltime2), 0., 
+							  addme.bandwidthAt(nulltime2), addme.phaseAt(nulltime2) );			
+			collated.insert( nulltime2, null2 );
+	
+			//	insert all the Breakpoints in addme 
+			//	into collated:
+			Partial::iterator addme_it;
+			for ( addme_it = addme.begin(); addme_it != addme.end(); ++addme_it )
+			{
+				collated.insert( addme_it.time(), addme_it.breakpoint() );
+			}
+			
+			//	remove this Partial from the list:
+			endcollated = unlabeled.erase( endcollated );
+		}
+		else
+		{
+		    ++endcollated;
+		}
+	}
+	
+	debugger << "...now have " << unlabeled.size() << endl;
+}
+
+}	//	end of namespace Loris
diff --git a/src/loris/Collator.h b/src/loris/Collator.h
new file mode 100644
index 0000000..e1d441c
--- /dev/null
+++ b/src/loris/Collator.h
@@ -0,0 +1,366 @@
+#ifndef INCLUDE_COLLATOR_H
+#define INCLUDE_COLLATOR_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Collator.h
+ *
+ * Definition of class Collator.
+ *
+ * Kelly Fitz, 29 April 2005
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "Distiller.h"	//	for default fade time and silent time
+#include "Partial.h"
+#include "PartialList.h"
+#include "PartialUtils.h"
+
+#include <algorithm>
+
+//  begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//  class Collator
+//
+//! Class Collator represents an algorithm for reducing a collection
+//! of Partials into the smallest collection of "equivalent" Partials
+//! by joining non-overlapping Partials end to end.
+//! 
+//! Partials that are not labeled, that is, Partials having label 0,
+//! are "collated " into groups of non-overlapping (in time)
+//! Partials, and fused into a single Partial per group. 
+//! "Collating" is a bit like "distilling" but non-overlapping
+//! Partials are grouped without regard to frequency proximity. This
+//! algorithm produces the smallest-possible number of collated Partials.
+//! Thanks to Ulrike Axen for providing this optimal algorithm.
+//! 
+//! Collating modifies the Partial container (a PartialList). Only
+//! unlabeled (labeled 0) Partials are affected by the collating
+//! operation. Collated Partials are moved to the end of the 
+//! collection of Partials.
+//
+class Collator
+{
+//  -- instance variables --
+
+    double _fadeTime, _gapTime;       
+        
+//  -- public interface --
+public:
+
+//  -- global defaults and constants --
+
+	enum 
+	{
+	
+		//! Default time in milliseconds over which Partials joined by
+		//! distillation fade to and from zero amplitude. Divide by 
+		//!	1000 to use as a member function parameter. This parameter
+		//!	should be the same in Distiller, Sieve, and Collator.
+		DefaultFadeTimeMs = Distiller::DefaultFadeTimeMs,
+		
+		//! Default minimum duration in milliseconds of the silent 
+		//! (zero-amplitude) gap between two Partials joined by 
+		//!	distillation. Divide by 1000 to use as a member function 
+		//!	parameter. This parameter should be the same in Distiller, 
+		//!	Sieve, and Collator.
+		DefaultSilentTimeMs = Distiller::DefaultSilentTimeMs
+    };
+    
+//  -- construction --
+
+    //! Construct a new Collator using the specified fade and gap times
+    //! between Partials. When two Partials are joined, the collated Partial
+    //! fades out at the end of the earlier Partial and back in again
+    //! at the onset of the later one. The fade time is the time over
+    //! which these fades occur. By default, use a 5 ms fade time.
+	//!	The gap time is the additional time over which a Partial faded
+	//!	out must remain at zero amplitude before it can fade back in.
+	//!	By default, use a gap time of one millisecond, to 
+	//!	prevent a pair of arbitrarily close null Breakpoints being
+	//!	inserted. (Defaults are copied from the Distiller.)
+	//!
+	//!   \param   partialFadeTime is the time (in seconds) over
+	//!            which Partials joined by distillation fade to
+	//!            and from zero amplitude. Default is 0.005 (one
+	//!            millisecond).
+	//!   \param   partialSilentTime is the minimum duration (in seconds) 
+	//!            of the silent (zero-amplitude) gap between two 
+	//!            Partials joined by distillation. (Default is
+	//!            0.001 (one millisecond).
+    explicit
+    Collator( double partialFadeTime = Collator::DefaultFadeTimeMs/1000.0,
+              double partialSilentTime = Collator::DefaultSilentTimeMs/1000.0 );
+     
+    //  Use compiler-generated copy, assign, and destroy.
+    
+//  -- collating --
+
+    //! Collate unlabeled (zero-labeled) Partials into the smallest-possible 
+    //! number of Partials that does not combine any overlapping Partials.
+    //! Collated Partials assigned labels higher than any label in the original 
+    //! list, and appear at the end of the sequence, after all previously-labeled
+    //! Partials.
+    //!
+    //!
+    //! Return an iterator refering to the position of the first collated Partial,
+    //! or the end of the collated collection if there are no collated Partials.
+    //! Since collating is in-place, the Partials collection may be smaller
+    //! (fewer Partials) after collating, and any iterators on the collection
+    //! may be invalidated.
+    //!
+    //!   \param  partials is the collection of Partials to collate in-place
+    //!   \return the position of the end of the range of labeled Partials,
+    //!           which is either the end of the collection, or the position
+    //!           of the first collated Partial, composed of unlabeled Partials
+    //!           in the original collection.
+    //!
+    //! If compiled with NO_TEMPLATE_MEMBERS defined, then partials
+    //! must be a PartialList, otherwise it can be any container type
+    //! storing Partials that supports at least bidirectional iterators.
+    //!
+    //!  \sa Collator::collate( Container & partials )
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    template< typename Container >
+    typename Container::iterator collate( Container & partials );
+#else
+    inline
+    PartialList::iterator collate( PartialList & partials );
+#endif
+
+    //! Function call operator: same as collate( PartialList & partials ).
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    template< typename Container >
+    typename Container::iterator operator() ( Container & partials );
+#else
+    PartialList::iterator operator() ( PartialList & partials );
+#endif
+    
+    //! Static member that constructs an instance and applies
+    //! it to a sequence of Partials.  Collated Partials are 
+    //! labeled beginning with the label one more than the
+    //! largest label in the orignal Partials.
+    //!
+    //! \param  partials is the collection of Partials to collate in-place
+    //! \param  partialFadeTime is the time (in seconds) over
+    //!         which Partials joined by collating fade to
+    //!         and from zero amplitude.
+    //! \param  partialSilentTime is the minimum duration (in seconds) 
+    //!         of the silent (zero-amplitude) gap between two 
+    //!         Partials joined by collating. 
+    //! \return the position of the first collated Partial
+    //!
+    //! If compiled with NO_TEMPLATE_MEMBERS defined, then partials
+    //! must be a PartialList, otherwise it can be any container type
+    //! storing Partials that supports at least bidirectional iterators.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    template< typename Container >
+    static typename Container::iterator 
+    collate( Container & partials, double partialFadeTime,
+                                   double partialSilentTime );
+#else
+    static inline PartialList::iterator
+    collate( PartialList & partials, double partialFadeTime,
+                                     double partialSilentTime );
+#endif
+
+
+private:
+
+//  -- helpers --
+
+    //! Collate unlabeled (zero labeled) Partials into the smallest
+    //! possible number of Partials that does not combine any temporally
+    //! overlapping Partials. Give each collated Partial a label, starting
+    //! with startlabel, and incrementing. If startLabel is zero, then
+    //! give each collated Partial the label zero. The unlabeled Partials are
+    //! collated in-place.
+    void collateAux( PartialList & unlabled );
+    
+};  //  end of class Collator
+
+// ---------------------------------------------------------------------------
+//  collate
+// ---------------------------------------------------------------------------
+//! Collate unlabeled (zero-labeled) Partials into the smallest-possible 
+//! number of Partials that does not combine any overlapping Partials.
+//! Collated Partials assigned labels higher than any label in the original 
+//! list, and appear at the end of the sequence, after all previously-labeled
+//! Partials.
+//!
+//! Return an iterator refering to the position of the first collated Partial,
+//! or the end of the collated collection if there are no collated Partials.
+//! Since collating is in-place, the Partials collection may be smaller
+//! (fewer Partials) after collating, and any iterators on the collection
+//! may be invalidated.
+//!
+//!   \param  partials is the collection of Partials to collate in-place
+//!   \return the position of the end of the range of labeled Partials,
+//!           which is either the end of the collection, or the position
+//!           of the first collated Partial, composed of unlabeled Partials
+//!           in the original collection.
+//!
+//! If compiled with NO_TEMPLATE_MEMBERS defined, then partials
+//! must be a PartialList, otherwise it can be any container type
+//! storing Partials that supports at least bidirectional iterators.
+//!
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename Container >
+typename Container::iterator 
+Collator::collate( Container & partials )
+#else
+inline
+PartialList::iterator 
+Collator::collate( PartialList & partials )
+#endif
+{
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    typedef typename Container::iterator Iterator;
+#else
+    typedef PartialList::iterator Iterator;
+#endif
+
+    // Partition the Partials into labeled and unlabeled, 
+    // and collate the unlabeled ones and replace the 
+    // unlabeled range.
+    // (This requires bidirectional iterator support.)
+    Iterator beginUnlabeled = 
+       std::partition( partials.begin(), partials.end(), 
+                              std::not1( PartialUtils::isLabelEqual(0) ) );
+        //  this used to be a stable partition, which 
+        //  is very much slower and seems unnecessary
+        
+    // cannot splice if this operation is to be generic
+    // with respect to container, have to copy:
+    PartialList collated( beginUnlabeled, partials.end() );
+    // collated.splice( collated.end(), beginUnlabeled, partials.end() );
+    
+    //  determine the label for the first collated Partial:
+    Partial::label_type labelCollated = 1;
+    if ( partials.begin() != beginUnlabeled )
+    {
+       labelCollated = 
+        1 + std::max_element( partials.begin(), beginUnlabeled, 
+                              PartialUtils::compareLabelLess() )->label();
+    }
+    if ( labelCollated < 1 )
+    {
+        labelCollated = 1;
+    }
+
+    //  collate unlabeled (zero-labeled) Partials:
+    collateAux( collated );
+    
+    //  label the collated Partials:
+    for ( Iterator it = collated.begin(); it != collated.end(); ++it )
+    {
+        it->setLabel( labelCollated++ );
+    }
+    
+    //  copy the collated Partials back into the source container
+    //  after the range of labeled Partials     
+    Iterator endCollated = 
+        std::copy( collated.begin(), collated.end(), beginUnlabeled );
+
+    //  remove extra Partials from the end of the source container
+    if ( endCollated != partials.end() )
+    {
+        typename Iterator::difference_type numLabeled = 
+            std::distance( partials.begin(), beginUnlabeled );
+
+        partials.erase( endCollated, partials.end() );
+
+        // restore beginUnlabeled:    
+        beginUnlabeled = partials.begin();
+        std::advance( beginUnlabeled, numLabeled );
+    }
+    return beginUnlabeled;
+}
+
+// ---------------------------------------------------------------------------
+//  Function call operator 
+// ---------------------------------------------------------------------------
+//! Function call operator: same as collate( PartialList & partials ).
+//! 
+//! \sa Collator::collate( Container & partials )
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename Container >
+typename Container::iterator Collator::operator()( Container & partials )
+#else
+inline
+PartialList::iterator Collator::operator()( PartialList & partials )
+#endif
+{ 
+    return collate( partials );
+}
+
+// ---------------------------------------------------------------------------
+//  collate
+// ---------------------------------------------------------------------------
+//! Static member that constructs an instance and applies
+//! it to a sequence of Partials. Collated Partials are 
+//! labeled beginning with the label one more than the
+//! largest label in the orignal Partials.
+//!
+//! \post   All Partials in the collection are uniquely-labeled,
+//!         collated Partials are all at the end of the collection
+//!         (after all labeled Partials).
+//! \param  partials is the collection of Partials to collate in-place
+//! \param  partialFadeTime is the time (in seconds) over
+//!         which Partials joined by collating fade to
+//!         and from zero amplitude.
+//! \param  partialSilentTime is the minimum duration (in seconds) 
+//!         of the silent (zero-amplitude) gap between two 
+//!         Partials joined by collateation. (Default is
+//!         0.0001 (one tenth of a millisecond).
+//! \return the position of the first collated Partial
+//!
+//! If compiled with NO_TEMPLATE_MEMBERS defined, then partials
+//! must be a PartialList, otherwise it can be any container type
+//! storing Partials that supports at least bidirectional iterators.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename Container >
+typename Container::iterator 
+Collator::collate( Container & partials, double partialFadeTime,
+                                         double partialSilentTime )
+#else
+inline
+PartialList::iterator 
+Collator::collate( PartialList & partials, double partialFadeTime,
+                                           double partialSilentTime )
+#endif
+{
+    Collator instance( partialFadeTime, partialSilentTime );
+    return instance.collate( partials );
+}
+
+}   //  end of namespace Loris
+
+#endif /* ndef INCLUDE_COLLATOR_H */
diff --git a/src/loris/Dilator.C b/src/loris/Dilator.C
new file mode 100644
index 0000000..733915f
--- /dev/null
+++ b/src/loris/Dilator.C
@@ -0,0 +1,282 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Dilator.C
+ *
+ * Implementation of class Dilator.
+ *
+ * Kelly Fitz, 26 Oct 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "Dilator.h"
+#include "Breakpoint.h"
+#include "LorisExceptions.h"
+#include "Marker.h"
+#include "Notifier.h"
+#include "Partial.h"
+#include "PartialList.h"
+
+#include <algorithm>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	constructor
+// ---------------------------------------------------------------------------
+//!	Construct a new Dilator with 
+//!	no time points.
+Dilator::Dilator( void )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	insert
+// ---------------------------------------------------------------------------
+//!	Insert a pair of initial and target time points. 
+//!	
+//!	Specify a pair of initial and target time points to be used
+//!	by this Dilator, corresponding, for example, to the initial
+//!	and desired time of a particular temporal feature in an
+//!	analyzed sound.
+//!	
+//!	\param i is an initial, or source, time point
+//!	\param t is a target time point
+//!	
+//!	The time points will be sorted before they are used.
+//!	If, in the sequences of initial and target time points, there are
+//!	exactly the same number of initial time points preceding i as
+//!	target time points preceding t, then time i will be warped to 
+//!	time t in the dilation process.
+//
+void
+Dilator::insert( double i, double t )
+{
+	_initial.push_back(i);
+	_target.push_back(t);
+
+	//	sort the time points before dilating:
+	std::sort( _initial.begin(), _initial.end() );
+	std::sort( _target.begin(), _target.end() );
+}
+
+// ---------------------------------------------------------------------------
+//	warpTime
+// --------------------------------------------------------------------------
+//! Return the dilated time value corresponding to the specified initial time.
+//! 
+//! \param currentTime is a pre-dilated time.
+//! \return the dilated time corresponding to the initial time currentTime
+//
+double
+Dilator::warpTime( double currentTime ) const
+{
+    int idx = std::distance( _initial.begin(), 
+                             std::lower_bound( _initial.begin(), _initial.end(), currentTime ) );
+    Assert( idx == _initial.size() || currentTime <= _initial[idx] );
+    
+    //	compute a new time for the Breakpoint at pIter:
+    double newtime = 0;
+    if ( idx == 0 ) 
+    {
+        //	all time points in _initial are later than 
+        //	the currentTime; stretch if no zero time 
+        //	point has been specified, otherwise, shift:
+        if ( _initial[idx] != 0. )
+            newtime = currentTime * _target[idx] / _initial[idx];
+        else
+            newtime = _target[idx] + (currentTime - _initial[idx]);
+    }
+    else if ( idx == _initial.size() ) 
+    {
+        //	all time points in _initial are earlier than 
+        //	the currentTime; shift:
+        //
+        //	note: size is already known to be > 0, so
+        //	idx-1 is safe
+        newtime = _target[idx-1] + (currentTime - _initial[idx-1]);
+    }
+    else 
+    {
+        //	currentTime is between the time points at idx and
+        //	idx-1 in _initial; shift and stretch: 
+        //
+        //	note: size is already known to be > 0, so
+        //	idx-1 is safe
+        Assert( _initial[idx-1] < _initial[idx] );	//	currentTime can't wind up 
+                                                    //	between two equal times
+        
+        double stretch = (_target[idx]	- _target[idx-1]) / (_initial[idx] - _initial[idx-1]);			
+        newtime = _target[idx-1] + ((currentTime - _initial[idx-1]) * stretch);
+    }
+	
+	return newtime;
+}
+
+// ---------------------------------------------------------------------------
+//	dilate
+// ---------------------------------------------------------------------------
+//!	Replace the Partial envelope with a new envelope having the
+//!	same Breakpoints at times computed to align temporal features
+//!	in the sorted sequence of initial time points with their 
+//!	counterparts the sorted sequence of target time points.
+//!
+//!	Depending on the specification of initial and target time 
+//!	points, the dilated Partial may have Breakpoints at times
+//!	less than 0, even if the original Partial did not.
+//!
+//!	It is possible to have duplicate time points in either sequence.
+//!	Duplicate initial time points result in very localized stretching.
+//!	Duplicate target time points result in very localized compression.
+//!
+//!	If all initial time points are greater than 0, then an implicit
+//!	time point at 0 is assumed in both initial and target sequences, 
+//!	so the onset of a sound can be stretched without explcitly specifying a 
+//!	zero point in each vector. (This seems most intuitive, and only looks
+//!	like an inconsistency if clients are using negative time points in 
+//!	their Dilator, or Partials having Breakpoints before time 0, both 
+//!	of which are probably unusual circumstances.)
+//!
+//!	\param p is the Partial to dilate.
+//	
+void
+Dilator::dilate( Partial & p ) const
+{
+	debugger << "dilating Partial having " << p.numBreakpoints() 
+			 << " Breakpoints" << endl;
+
+	//	sanity check:
+	Assert( _initial.size() == _target.size() );
+	
+	//	don't dilate if there's no time points, or no Breakpoints:
+	if ( 0 == _initial.size() ||
+	     0 == p.numBreakpoints() )
+	{
+		return;
+    }
+    
+	//	create the new Partial:
+	Partial newp;
+	newp.setLabel( p.label() );
+	
+	//	timepoint index:
+	int idx = 0;
+	for ( Partial::const_iterator iter = p.begin(); iter != p.end(); ++iter )
+	{
+		//	find the first initial time point later 
+		//	than the currentTime:
+		double currentTime = iter.time();
+        idx = std::distance( _initial.begin(), 
+                             std::lower_bound( _initial.begin(), _initial.end(), currentTime ) );
+        Assert( idx == _initial.size() || currentTime <= _initial[idx] );
+        
+		//	compute a new time for the Breakpoint at pIter:
+		double newtime = 0;
+		if ( idx == 0 ) 
+		{
+			//	all time points in _initial are later than 
+			//	the currentTime; stretch if no zero time 
+			//	point has been specified, otherwise, shift:
+			if ( _initial[idx] != 0. )
+				newtime = currentTime * _target[idx] / _initial[idx];
+			else
+				newtime = _target[idx] + (currentTime - _initial[idx]);
+		}
+		else if ( idx == _initial.size() ) 
+		{
+			//	all time points in _initial are earlier than 
+			//	the currentTime; shift:
+			//
+			//	note: size is already known to be > 0, so
+			//	idx-1 is safe
+			newtime = _target[idx-1] + (currentTime - _initial[idx-1]);
+		}
+		else 
+		{
+			//	currentTime is between the time points at idx and
+			//	idx-1 in _initial; shift and stretch: 
+			//
+			//	note: size is already known to be > 0, so
+			//	idx-1 is safe
+			Assert( _initial[idx-1] < _initial[idx] );	//	currentTime can't wind up 
+														//	between two equal times
+			
+			double stretch = (_target[idx]	- _target[idx-1]) / (_initial[idx] - _initial[idx-1]);			
+			newtime = _target[idx-1] + ((currentTime - _initial[idx-1]) * stretch);
+		}
+		
+		//	add a Breakpoint at the computed time:
+		newp.insert( newtime, iter.breakpoint() );
+	}
+	
+	//	new Breakpoints need to be added to the Partial at times corresponding
+	//	to all target time points that are after the first Breakpoint and
+	//	before the last, otherwise, Partials may be briefly out of tune with
+	//	each other, since our Breakpoints are non-uniformly distributed in time:
+	for ( idx = 0; idx < _initial.size(); ++ idx )
+	{
+		if ( _initial[idx] <= p.startTime() )
+        {
+			continue;
+        }
+		else if ( _initial[idx] >= p.endTime() )
+        {
+			break;
+        }
+		else
+		{
+			newp.insert( _target[idx], 
+						 Breakpoint( p.frequencyAt(_initial[idx]), p.amplitudeAt(_initial[idx]),
+									 p.bandwidthAt(_initial[idx]), p.phaseAt(_initial[idx]) ) );
+		}
+	}
+	
+	//	store the new Partial:
+	p = newp;
+}
+
+
+// ---------------------------------------------------------------------------
+//	dilate
+// ---------------------------------------------------------------------------
+//!	Compute a new time for the specified Marker using
+//!	warpTime(), exactly as Partial Breakpoint times are
+//!	recomputed. This can be used to dilate the Markers
+//!	corresponding to a collection of Partials. 
+//!
+//!	\param	m is the Marker whose time should be recomputed.
+//
+void
+Dilator::dilate( Marker & m ) const
+{
+	m.setTime( warpTime( m.time() ) );
+}
+
+}	//	end of namespace Loris
diff --git a/src/loris/Dilator.h b/src/loris/Dilator.h
new file mode 100644
index 0000000..3370788
--- /dev/null
+++ b/src/loris/Dilator.h
@@ -0,0 +1,410 @@
+#ifndef INCLUDE_DILATOR_H
+#define INCLUDE_DILATOR_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Dilator.h
+ *
+ * Definition of class Dilator.
+ *
+ * Kelly Fitz, 26 Oct 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if defined(NO_TEMPLATE_MEMBERS)
+#include "PartialList.h"
+#endif
+
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+class Marker;
+class Partial;
+
+// ---------------------------------------------------------------------------
+//	class Dilator
+//
+//!	Class Dilator represents an algorithm for non-uniformly expanding
+//!	and contracting the Partial parameter envelopes according to the initial
+//!	and target (desired) times of temporal features.
+//!	
+//!	It is frequently necessary to redistribute temporal events in this way
+//!	in preparation for a sound morph. For example, when morphing instrument
+//!	tones, it is common to align the attack, sustain, and release portions
+//!	of the source sounds by dilating or contracting those temporal regions.
+//!
+//!	This same procedure can be applied to the Markers stored in AiffFile,
+//!	SdifFile, and SpcFile (see Marker.h).
+//
+class Dilator
+{
+//	-- instance variables --
+
+	std::vector< double > _initial, _target;	//	time points
+	
+//	-- public interface --
+public:
+//	-- construction --
+
+	//!	Construct a new Dilator with no time points.
+	Dilator( void );
+	 	
+	//!	Construct a new Dilator using a range of initial time points
+	//!	and a range of target (desired) time points. The client must
+	//!	ensure that the target range has at least as many elements as
+	//!	the initial range.
+	//!	
+	//!	\param 	ibegin is the beginning of a sequence of initial, or source,
+	//!	         time points.
+	//!	\param 	iend is (one-past) the end of a sequence of initial, or
+	//!	         source, time points.
+	//!	\param 	tbegin is the beginning of a sequence of target time points; 
+	//!	         this sequence must be as long as the sequence of initial time
+	//!	         point described by ibegin and iend.
+	//!
+	//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+	//!	only const double * arguments.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter1, typename Iter2>
+	Dilator( Iter1 ibegin, Iter1 iend, Iter2 tbegin );
+#else
+    inline
+	Dilator( const double * ibegin, const double * iend, const double * tbegin );
+#endif
+
+	//	Use compiler-generated copy, assign, and destroy.
+	
+//	-- mutation --
+	
+	//!	Insert a pair of initial and target time points. 
+	//!	
+	//!	Specify a pair of initial and target time points to be used
+	//!	by this Dilator, corresponding, for example, to the initial
+	//!	and desired time of a particular temporal feature in an
+	//!	analyzed sound.
+	//!	
+	//!	\param 	i is an initial, or source, time point
+	//!	\param 	t is a target time point
+	//!	
+	//!	The time points will be sorted before they are used.
+	//!	If, in the sequences of initial and target time points, there are
+	//!	exactly the same number of initial time points preceding i as
+	//!	target time points preceding t, then time i will be warped to 
+	//!	time t in the dilation process.	
+	void insert( double i, double t );
+	
+//	-- dilation --
+
+	//!	Replace the Partial envelope with a new envelope having the
+	//!	same Breakpoints at times computed to align temporal features
+	//!	in the sorted sequence of initial time points with their 
+	//!	counterparts the sorted sequence of target time points.
+	//!
+	//!	Depending on the specification of initial and target time 
+	//!	points, the dilated Partial may have Breakpoints at times
+	//!	less than 0, even if the original Partial did not.
+	//!
+	//!	It is possible to have duplicate time points in either sequence.
+	//!	Duplicate initial time points result in very localized stretching.
+	//!	Duplicate target time points result in very localized compression.
+	//!
+	//!	If all initial time points are greater than 0, then an implicit
+	//!	time point at 0 is assumed in both initial and target sequences, 
+	//!	so the onset of a sound can be stretched without explcitly specifying a 
+	//!	zero point in each vector. (This seems most intuitive, and only looks
+	//!	like an inconsistency if clients are using negative time points in 
+	//!	their Dilator, or Partials having Breakpoints before time 0, both 
+	//!	of which are probably unusual circumstances.)
+	//!
+	//!	\param	p is the Partial to dilate.
+	void dilate( Partial & p ) const;
+	 
+	//!	Function call operator: same as dilate( Partial & p ).
+	void operator() ( Partial & p ) const;
+
+	//!	Compute a new time for the specified Marker using
+	//!	warpTime(), exactly as Partial Breakpoint times are
+	//!	recomputed. This can be used to dilate the Markers
+	//!	corresponding to a collection of Partials. 
+	//!
+	//!	\param	m is the Marker whose time should be recomputed.
+	void dilate( Marker & m ) const;
+	 
+	//!	Function call operator: same as dilate( Marker & p ).
+	void operator() ( Marker & m ) const;
+	 
+	//!	Non-uniformly expand and contract the parameter envelopes of the each
+	//!	Partial in the specified half-open range according to this Dilator's
+	//!	stored initial and target (desired) times. 
+	//!
+	//!	\param dilate_begin is the beginning of a sequence of Partials to dilate.
+	//!	\param dilate_end is (one-past) the end of a sequence of Partials to dilate.
+	//!
+	//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+	//!	only PartialList::const_iterator arguments. Otherwise, this member
+	//!   also works for sequences of Markers.
+	//!	
+	//!	\sa Dilator::dilate( Partial & p ) const
+	//!	\sa Dilator::dilate( Marker & m ) const
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+	void dilate( Iter dilate_begin, Iter dilate_end  ) const;
+#else
+    inline
+	void dilate( PartialList::iterator dilate_begin, 
+				    PartialList::iterator dilate_end  ) const;
+#endif
+	 
+	//!	Function call operator: same as 
+	//!	dilate( Iter dilate_begin, Iter dilate_end )
+	//!
+	//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+	//!	only PartialList::const_iterator arguments. Otherwise, this member
+	//!   also works for sequences of Markers.
+	//!	
+	//!	\sa Dilator::dilate( Partial & p ) const
+	//!	\sa Dilator::dilate( Marker & m ) const
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+	void operator() ( Iter dilate_begin, Iter dilate_end  ) const;
+#else
+    inline
+	void operator() ( PartialList::iterator dilate_begin, 
+					      PartialList::iterator dilate_end ) const;
+#endif
+	 
+	//!	Return the dilated time value corresponding to the specified initial time.
+	//! 
+	//!	\param currentTime is a pre-dilated time.
+	//! \return the dilated time corresponding to the initial time currentTime
+    double warpTime( double currentTime ) const;
+
+// -- static members --
+
+   //!   Static member that constructs an instance and applies
+   //!   it to a sequence of Partials. 
+   //!   Construct a Dilator using the specified initial and 
+   //!   target times, and apply it to a sequence of Partials.
+  	//!
+	//!	\param   dilate_begin is the beginning of a sequence of Partials to dilate.
+	//!	\param   dilate_end is (one-past) the end of a sequence of Partials to dilate.
+	//!	\param 	ibegin is the beginning of a sequence of initial, or source,
+	//!	         time points.
+	//!	\param 	iend is (one-past) the end of a sequence of initial, or
+	//!	         source, time points.
+	//!	\param 	tbegin is the beginning of a sequence of target time points; 
+	//!	         this sequence must be as long as the sequence of initial time
+	//!	         point described by ibegin and iend.
+	//!
+	//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+	//!	only PartialList::const_iterator arguments. Otherwise, this member
+	//!   also works for sequences of Markers.
+	//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+	//!	only const double * arguments for the times, otherwise, any iterator
+	//!   will do..
+	//!	
+	//!	\sa Dilator::dilate( Partial & p ) const
+	//!	\sa Dilator::dilate( Marker & m ) const
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template< typename PartialsIter, typename TimeIter1, typename TimeIter2 >
+	static 
+	void dilate( PartialsIter dilate_begin, PartialsIter dilate_end,
+	             TimeIter1 ibegin, TimeIter1 iend, TimeIter2 tbegin  );
+#else
+    static inline
+ 	void dilate( PartialList::iterator dilate_begin, 
+				 PartialList::iterator dilate_end,
+		   		 const double * ibegin, const double * iend, 
+				 const double * tbegin  );
+#endif
+
+};	//	end of class Dilator
+
+
+// ---------------------------------------------------------------------------
+//	constructor (sequences of time points)
+// ---------------------------------------------------------------------------
+//!	Construct a new Dilator using a range of initial time points
+//!	and a range of target (desired) time points. The client must
+//!	ensure that the target range has at least as many elements as
+//!	the initial range.
+//!	
+//!	\param 	ibegin is the beginning of a sequence of initial, or source,
+//!	        time points.
+//!	\param 	iend is (one-past) the end of a sequence of initial, or
+//!	        source, time points.
+//!	\param 	tbegin is the beginning of a sequence of target time points; 
+//!	        this sequence must be as long as the sequence of initial time
+//!	        point described by ibegin and iend.
+//!
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+//!	only const double * arguments.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter1, typename Iter2>
+Dilator::Dilator( Iter1 ibegin, Iter1 iend, Iter2 tbegin )
+#else
+inline
+Dilator::Dilator( const double * ibegin, const double * iend, const double * tbegin )
+#endif
+{
+	while ( ibegin != iend )
+	{
+		insert( *ibegin++, *tbegin++ );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	dilate (sequence of Partials or Markers)
+// ---------------------------------------------------------------------------
+//!	Non-uniformly expand and contract the parameter envelopes of the each
+//!	Partial in the specified half-open range according to this Dilator's
+//!	stored initial and target (desired) times. 
+//!
+//!	\param dilate_begin is the beginning of a sequence of Partials to dilate.
+//!	\param dilate_end is (one-past) the end of a sequence of Partials to dilate.
+//!
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+//!	only PartialList::const_iterator arguments. Otherwise, this member
+//! also works for sequences of Markers.
+//!	
+//!	\sa Dilator::dilate( Partial & p ) const
+//!	\sa Dilator::dilate( Marker & m ) const
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void Dilator::dilate( Iter dilate_begin, Iter dilate_end  ) const
+#else
+inline
+void Dilator::dilate( PartialList::iterator dilate_begin, 
+					  PartialList::iterator dilate_end  ) const
+#endif
+{
+	while ( dilate_begin != dilate_end )
+	{
+		dilate( *(dilate_begin++) );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	Function call operator (sequence of Partials or Markers)
+// ---------------------------------------------------------------------------
+//!	Function call operator: same as 
+//!	dilate( Iter dilate_begin, Iter dilate_end )
+//!
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+//!	only PartialList::const_iterator arguments. Otherwise, this member
+//! also works for sequences of Markers.
+//!	
+//!	\sa Dilator::dilate( Partial & p ) const
+//!	\sa Dilator::dilate( Marker & m ) const
+//	 
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void Dilator::operator() ( Iter dilate_begin, Iter dilate_end  ) const
+#else
+inline
+void Dilator::operator() ( PartialList::iterator dilate_begin, 
+						   PartialList::iterator dilate_end ) const
+#endif
+{ 
+	dilate( dilate_begin, dilate_end ); 
+}
+
+// ---------------------------------------------------------------------------
+//	Function call operator (single Partial)
+// ---------------------------------------------------------------------------
+//!	Function call operator: same as dilate( Partial & p ).
+//!	
+//!	\sa Dilator::dilate( Partial & p ) const
+//
+inline 
+void Dilator::operator() ( Partial & p ) const
+{ 
+	dilate( p ); 
+}
+
+// ---------------------------------------------------------------------------
+//	Function call operator (single Marker)
+// ---------------------------------------------------------------------------
+//!	Function call operator: same as dilate( Marker & m ).
+//!	
+//!	\sa Dilator::dilate( Marker & m ) const
+//
+inline 
+void Dilator::operator() ( Marker & m ) const
+{ 
+	dilate( m ); 
+}
+
+// ---------------------------------------------------------------------------
+//	dilate (static)
+// ---------------------------------------------------------------------------
+//!   Static member that constructs an instance and applies
+//!   it to a sequence of Partials. 
+//!   Construct a Dilator using the specified initial and 
+//!   target times, and apply it to a sequence of Partials.
+//!
+//!	\param   dilate_begin is the beginning of a sequence of Partials to dilate.
+//!	\param   dilate_end is (one-past) the end of a sequence of Partials to dilate.
+//!	\param 	ibegin is the beginning of a sequence of initial, or source,
+//!	         time points.
+//!	\param 	iend is (one-past) the end of a sequence of initial, or
+//!	         source, time points.
+//!	\param 	tbegin is the beginning of a sequence of target time points; 
+//!	         this sequence must be as long as the sequence of initial time
+//!	         point described by ibegin and iend.
+//!
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+//!	only PartialList::const_iterator arguments. Otherwise, this member
+//!   also works for sequences of Markers.
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+//!	only const double * arguments for the times, otherwise, any iterator
+//!   will do..
+//!	
+//!	\sa Dilator::dilate( Partial & p ) const
+//!	\sa Dilator::dilate( Marker & m ) const
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename PartialsIter, typename TimeIter1, typename TimeIter2 >
+void Dilator::dilate( PartialsIter dilate_begin, PartialsIter dilate_end,
+			 		  TimeIter1 ibegin, TimeIter1 iend, TimeIter2 tbegin  )
+#else
+inline
+void Dilator::dilate( PartialList::iterator dilate_begin, 
+			 		  PartialList::iterator dilate_end,
+			 		  const double * ibegin, const double * iend, 
+			 		  const double * tbegin  )
+#endif
+{ 
+  	Dilator instance( ibegin, iend, tbegin );
+	instance.dilate( dilate_begin, dilate_end ); 
+}
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_DILATOR_H */
diff --git a/src/loris/Distiller.C b/src/loris/Distiller.C
new file mode 100644
index 0000000..09c9d19
--- /dev/null
+++ b/src/loris/Distiller.C
@@ -0,0 +1,483 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Distiller.C
+ *
+ * Implementation of class Distiller.
+ *
+ * Kelly Fitz, 20 Oct 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "Distiller.h"
+#include "Breakpoint.h"
+#include "BreakpointUtils.h"
+#include "LorisExceptions.h"
+#include "Partial.h"
+#include "PartialList.h"
+#include "PartialUtils.h"
+#include "Notifier.h"
+
+#include <algorithm>
+#include <functional>
+#include <utility>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	Distiller constructor
+// ---------------------------------------------------------------------------
+//!	Construct a new Distiller using the specified fade time
+//!	for gaps between Partials. When two non-overlapping Partials
+//!	are distilled into a single Partial, the distilled Partial
+//!	fades out at the end of the earlier Partial and back in again
+//!	at the onset of the later one. The fade time is the time over
+//!	which these fades occur. By default, use a 5 ms fade time.
+//!	The gap time is the additional time over which a Partial faded
+//!	out must remain at zero amplitude before it can fade back in.
+//!	By default, use a gap time of one millisecond, to 
+//!	prevent a pair of arbitrarily close null Breakpoints being
+//!	inserted.
+//!
+//!   \param   partialFadeTime is the time (in seconds) over
+//!            which Partials joined by distillation fade to
+//!            and from zero amplitude. Default is 0.005 (one
+//!            millisecond).
+//!   \param   partialSilentTime is the minimum duration (in seconds) 
+//!            of the silent (zero-amplitude) gap between two 
+//!            Partials joined by distillation. (Default is
+//!            0.001 (one millisecond).
+//
+Distiller::Distiller( double partialFadeTime, double partialSilentTime ) :
+	_fadeTime( partialFadeTime ),
+	_gapTime( partialSilentTime )
+{
+	if ( _fadeTime <= 0.0 )
+	{
+		Throw( InvalidArgument, "Distiller fade time must be positive." );
+	}
+	if ( _gapTime <= 0.0 )
+	{
+		Throw( InvalidArgument, "Distiller gap time must be positive." );
+	}
+}
+
+// -- helpers --
+
+// ---------------------------------------------------------------------------
+//	fadeInAndOut		(STATIC)
+// ---------------------------------------------------------------------------
+//  Add zero-amplitude Breakpoints to the ends of a Partial if necessary.
+//  Do this to all Partials before distilling to make distillation easier.
+//
+static void fadeInAndOut( Partial & p, double fadeTime )
+{
+    if ( p.first().amplitude() != 0 )
+    {
+        p.insert( 
+            p.startTime() - fadeTime,
+            BreakpointUtils::makeNullBefore( p.first(), fadeTime ) );
+    }
+    
+    if ( p.last().amplitude() != 0 )
+    {
+        p.insert( 
+            p.endTime() + fadeTime,
+            BreakpointUtils::makeNullAfter( p.last(), fadeTime ) );
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	merge	(STATIC)
+// ---------------------------------------------------------------------------
+//	Merge the Breakpoints in the specified iterator range into the
+//	distilled Partial. The beginning of the range may overlap, and 
+//	will replace, some non-zero-amplitude portion of the distilled
+//	Partial. Assume that there is no such overlap at the end of the 
+//	range (could check), because findContribution only leaves overlap
+//  at the beginning of the range.
+//
+static void merge( Partial::const_iterator beg, 
+				   Partial::const_iterator end, 
+				   Partial & destPartial, double fadeTime, 
+				   double gapTime = 0. )
+{	
+	//	absorb energy in distilled Partial that overlaps the
+	//	range to merge:
+	Partial toMerge( beg, end );
+	toMerge.absorb( destPartial );  
+    fadeInAndOut( toMerge, fadeTime );
+
+		
+    //  find the first Breakpoint in destPartial that is after the
+    //  range of merged Breakpoints, plus the required gap:
+	Partial::iterator removeEnd = destPartial.findAfter( toMerge.endTime() + gapTime );
+    
+    //  if this Breakpoint has non-zero amplitude, need to leave time
+    //  for a fade in:
+	while ( removeEnd != destPartial.end() &&
+            removeEnd.breakpoint().amplitude() != 0 &&
+            removeEnd.time() < toMerge.endTime() + gapTime + fadeTime )
+    {
+        ++removeEnd;
+    }   
+    
+	//	find the first Breakpoint in the destination Partial that needs
+    //  to be removed because it is in the overlap region:
+	Partial::iterator removeBegin = destPartial.findAfter( toMerge.startTime() - gapTime );
+        
+    //  if beforeMerge has non-zero amplitude, need to leave time
+    //  for a fade out:
+    if ( removeBegin != destPartial.begin() )
+	{
+        Partial::iterator beforeMerge = --Partial::iterator(removeBegin);
+        
+        while ( removeBegin != destPartial.begin() &&
+                beforeMerge.breakpoint().amplitude() != 0 &&
+                beforeMerge.time() > toMerge.startTime() - gapTime - fadeTime )
+        {
+            --removeBegin;
+            if ( beforeMerge != destPartial.begin() )
+            {
+                --beforeMerge;
+            }
+        }   
+        
+	}
+	
+	//	remove the Breakpoints in the merge range from destPartial:
+    double rbt = (removeBegin != destPartial.end())?(removeBegin.time()):(destPartial.endTime());
+    double ret = (removeEnd != destPartial.end())?(removeEnd.time()):(destPartial.endTime());
+    Assert( rbt <= ret );
+	destPartial.erase( removeBegin, removeEnd );
+
+    //  how about doing the fades here instead?
+    //  fade in if necessary:
+	if ( removeEnd != destPartial.end() &&
+         removeEnd.breakpoint().amplitude() != 0 )
+	{
+        Assert( removeEnd.time() - fadeTime > toMerge.endTime() );
+
+        //	update removeEnd so that we don't remove this 
+        //	null we are inserting:
+        destPartial.insert( 
+            removeEnd.time() - fadeTime, 
+            BreakpointUtils::makeNullBefore( removeEnd.breakpoint(), fadeTime ) );
+	}
+
+    if ( removeEnd != destPartial.begin() )
+    {
+        Partial::iterator beforeMerge = --Partial::iterator(removeEnd);
+        if ( beforeMerge.breakpoint().amplitude() > 0 )
+        {
+            Assert( beforeMerge.time() + fadeTime < toMerge.startTime() );
+            
+            destPartial.insert( 
+                beforeMerge.time() + fadeTime, 
+                BreakpointUtils::makeNullAfter( beforeMerge.breakpoint(), fadeTime ) );
+        }
+    }		
+    
+    //	insert the Breakpoints in the range:
+	for ( Partial::const_iterator insert = toMerge.begin(); insert != toMerge.end(); ++insert )
+	{
+		destPartial.insert( insert.time(), insert.breakpoint() );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	findContribution		(STATIC)
+// ---------------------------------------------------------------------------
+//	Find and return an iterator range delimiting the portion of pshort that
+// 	should be spliced into the distilled Partial plong. If any Breakpoint 
+//	falls in a zero-amplitude region of plong, then pshort should contribute,
+//	AND its onset should be retained (!!! This is the weird part!!!). 
+//  Therefore, if cbeg is not equal to cend, then cbeg is pshort.begin().
+//
+std::pair< Partial::iterator, Partial::iterator >
+findContribution( Partial & pshort, const Partial & plong, 
+				  double fadeTime, double gapTime )
+{
+	//	a Breakpoint can only fit in the gap if there's
+	//	enough time to fade out pshort, introduce a
+	//	space of length gapTime, and fade in the rest
+	//	of plong (don't need to worry about the fade
+	//	in, because we are checking that plong is zero
+	//	at cbeg.time() + clearance anyway, so the fade 
+	//	in must occur after that, and already be part of 
+	//	plong):
+    //
+    //  WRONG if cbeg is before the start of plong.
+    //  Changed so that all Partials are faded in and
+    //  out before distilling, so now the clearance 
+    //  need only be the gap time:
+	double clearance = gapTime; // fadeTime + gapTime;
+	
+	Partial::iterator cbeg = pshort.begin();
+	while ( cbeg != pshort.end() && 
+			( plong.amplitudeAt( cbeg.time() ) > 0 ||
+			  plong.amplitudeAt( cbeg.time() + clearance ) > 0 ) )
+	{
+		++cbeg;
+	}
+	
+	Partial::iterator cend = cbeg;
+	
+	// if a gap is found, find the end of the
+	// range of Breakpoints that fit in that
+	// gap:
+	while ( cend != pshort.end() &&
+			plong.amplitudeAt( cend.time() ) == 0 &&
+			plong.amplitudeAt( cend.time() + clearance ) == 0 )
+	{
+		++cend;
+	}
+
+	// if a gap is found, and it is big enough for at
+	// least one Breakpoint, then include the 
+	// onset of the Partial:
+	if ( cbeg != pshort.end()  )
+	{
+		cbeg = pshort.begin();
+	}
+	
+	return std::make_pair( cbeg, cend );
+}
+
+// ---------------------------------------------------------------------------
+//	distillSorter (static helper)
+// ---------------------------------------------------------------------------
+//  Helper for sorting Partials for distilling.
+//
+static bool distillSorter( const Partial & lhs, const Partial & rhs )
+{
+    double ldur = lhs.duration(), rdur = rhs.duration();
+    if ( ldur != rdur )
+    {        
+        return ldur > rdur;      
+    }
+    else
+    {
+        //  What to do for same-duration Partials?
+        //  Need to do something consistent, should look
+        //  for energy?
+        return lhs.startTime() < rhs.startTime();
+        /*
+        double lpeak = PartialUtils::peakAmp( lhs );
+        double rpeak = PartialUtils::peakAmp( rhs );
+        return lhs > rhs;
+        */
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	distillOne
+// ---------------------------------------------------------------------------
+//	Distill a list of Partials having a common label
+// 	into a single Partial with that label, and append it
+//  to the distilled collection. If an empty list of Partials
+//  is passed, then an empty Partial having the specified
+//  label is appended.
+//
+void Distiller::distillOne( PartialList & partials, Partial::label_type label,
+                            PartialList & distilled )
+{
+	debugger << "Distiller found " << partials.size() 
+			 << " Partials labeled " << label << endl;
+
+	Partial newp;
+    newp.setLabel( label );
+
+    if ( partials.size() == 1 )
+    {
+        //  trivial if there is only one partial to distill
+        newp = partials.front();
+    }
+	else if ( partials.size() > 0 )  //  it will be an empty Partial otherwise
+    {	
+    	//	sort Partials by duration, longer
+    	//	Partials will be prefered:
+    	partials.sort( distillSorter );
+    	
+    	// keep the longest Partial:
+    	PartialList::iterator it = partials.begin();
+    	newp = *it;
+    	fadeInAndOut( newp, _fadeTime );
+        	
+    	//	Iterate over remaining Partials:
+    	for ( ++it; it != partials.end(); ++it )
+    	{            
+            fadeInAndOut( *it, _fadeTime );
+            
+    		std::pair< Partial::iterator, Partial::iterator > range = 
+    			findContribution( *it, newp, _fadeTime, _gapTime );
+    		Partial::iterator cb = range.first, ce = range.second;
+
+            //  There can only be one contributing regions because
+            //  (and only because) the partials are sorted by length
+            //  first!
+    		
+    		//	merge Breakpoints into the new Partial, if
+    		//	there are any that contribute, otherwise
+    		//	just absorb the current Partial as noise:
+    		if ( cb != ce )
+    		{
+    			//	absorb the non-contributing part:
+    			if ( ce != it->end() )
+    			{
+    				Partial absorbMe( --Partial::iterator(ce), it->end() );
+    				    //  shouldn't this just be ce?
+    				newp.absorb( absorbMe );
+    			
+                    //	There cannot be a non-contributing part
+                    //	at the beginning of the Partial too, because
+                    //  we always retain the beginning of the Partial.
+                    //  If findContribution were changed, then 
+                    //  we might also want to absorb the beginning.
+                    //
+    				// Partial absorbMeToo( it->begin(), cb );
+    				// newp.absorb( absorbMeToo );
+    			}
+
+    			// merge the contributing part:
+    			merge( cb, ce, newp, _fadeTime, _gapTime );
+    		}
+    		else
+    		{
+    			//	no contribution, absorb the whole thing:
+    			newp.absorb( *it );
+    		}		
+    	}
+    }	
+
+    //  take the null Breakpoints off the ends
+    //  should check whether this is appropriate?
+    //
+    // 	This is a bit of a kludge here, sometimes we must
+    //	be inserting more than one null Breakpoint at the
+    //	front end (at least), sometimes shows up as a Partial
+    //	that begins before 0. The idea is to have no nulls at
+    //	the ends, so just remove all nulls at the ends.
+	while ( 0 < newp.numBreakpoints() &&
+			0 == newp.begin().breakpoint().amplitude() )
+	{
+		newp.erase( newp.begin() );
+	}
+
+    Partial::iterator lastBpPos = newp.end();
+    while ( 0 < newp.numBreakpoints() &&
+			0 == (--lastBpPos).breakpoint().amplitude() )
+    {
+        lastBpPos = newp.erase( lastBpPos );
+    }
+    
+    //  insert the new Partial in the distilled collection 
+    //  in label order:
+    distilled.insert( std::lower_bound( distilled.begin(), distilled.end(), 
+                                        newp, 
+                                        PartialUtils::compareLabelLess() ),
+                      newp );
+}
+
+// ---------------------------------------------------------------------------
+//	distill_list
+// ---------------------------------------------------------------------------
+//! Distill labeled Partials in a PartialList leaving only a single 
+//!	Partial per non-zero label. 
+//!
+//!	Unlabeled (zero-labeled) Partials are left unmodified at 
+//! the end of the distilled Partials.
+//!
+//!	Return an iterator refering to the position of the first unlabeled Partial,
+//!	or the end of the distilled collection if there are no unlabeled Partials.
+//! Since distillation is in-place, the Partials collection may be smaller
+//! (fewer Partials) after distillation, and any iterators on the collection
+//! may be invalidated.
+//!
+//! \post   All labeled Partials in the collection are uniquely-labeled,
+//!         and all unlabeled Partials have been moved to the end of the
+//!         sequence.
+//! \param  partials is the collection of Partials to distill in-place
+//! \return the position of the end of the range of distilled Partials,
+//!         which is either the end of the collection, or the position
+//!         or the first unlabeled Partial.
+//
+PartialList::iterator Distiller::distill_list( PartialList & partials )
+{  
+    //  sort the Partials by label, this is why it
+    //  is so much better to distill a list!    
+    partials.sort( PartialUtils::compareLabelLess() );
+
+    //  temporary container of distilled Partials:
+    PartialList distilled; 
+	
+	PartialList::iterator lower = partials.begin();
+	while ( lower != partials.end() )
+	{
+		Partial::label_type label = lower->label();
+
+        //  identify a sequence of Partials having the same label:
+	    PartialList::iterator upper = 
+	        std::find_if( lower, partials.end(),
+	                      std::not1( PartialUtils::isLabelEqual( label ) ) );
+                            
+        //  upper is the first Partial after lower whose label is not
+        //  equal to that of lower.
+		//	[lower, upper) is a range of all the
+		//	partials labeled `label'.
+
+        if ( 0 != label )
+        {
+            //	make a container of the Partials having the same 
+            //	label, and distill them:
+            PartialList samelabel;
+            samelabel.splice( samelabel.begin(), partials, lower, upper );
+            distillOne( samelabel, label, distilled );
+        }
+        lower = upper;
+    }
+        
+#if defined(Debug_Loris) && Debug_Loris
+    // only unlabeled Partials should remain in partials:
+    Assert( partials.end() ==
+            std::find_if( partials.begin(), partials.end(), 
+                          std::not1( PartialUtils::isLabelEqual( 0 ) ) ) );
+#endif    
+    
+    //  remember where the unlabeled Partials start:
+    PartialList::iterator beginUnlabeled = partials.begin(); 
+    
+    //  splice in the distilled Partials at the beginning:
+    partials.splice( partials.begin(), distilled );
+
+    return beginUnlabeled;
+}
+
+}	//	end of namespace Loris
diff --git a/src/loris/Distiller.h b/src/loris/Distiller.h
new file mode 100644
index 0000000..f1672ce
--- /dev/null
+++ b/src/loris/Distiller.h
@@ -0,0 +1,370 @@
+#ifndef INCLUDE_DISTILLER_H
+#define INCLUDE_DISTILLER_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Distiller.h
+ *
+ * Definition of class Distiller.
+ *
+ * Kelly Fitz, 20 Oct 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "Partial.h"
+#include "PartialList.h"
+#include "PartialUtils.h"
+
+#include "Notifier.h"   //  for debugging only
+
+#include <algorithm>
+
+//  begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//  class Distiller
+//
+//! Class Distiller represents an algorithm for "distilling" a group of
+//! Partials that logically represent a single component into a single
+//! Partial.
+//! 
+//! The sound morphing algorithm in Loris requires that Partials in a
+//! given source be labeled uniquely, that is, no two Partials can have
+//! the same label. The Distiller enforces this condition. All Partials
+//! identified with a particular frequency channel (see Channelizer), and,
+//! therefore, having a common label, are distilled into a single Partial,
+//! leaving at most a single Partial per frequency channel and label.
+//! Channels that contain no Partials are not represented in the distilled
+//! data. Partials that are not labeled, that is, Partials having label 0,
+//! are are left unmodified at the end of the Partial sequence.
+//! 
+//! Distillation modifies the Partial container (a PartialList). All
+//! Partials in the distilled range having a common label are replaced by
+//! a single Partial in the distillation process. Only labeled
+//! Partials are affected by distillation. 
+//
+class Distiller
+{
+//  -- instance variables --
+
+    double _fadeTime, _gapTime;         // distillation parameters
+        
+//  -- public interface --
+public:
+
+//  -- global defaults and constants --
+
+	enum 
+	{
+	
+		//! Default time in milliseconds over which Partials joined by
+		//! distillation fade to and from zero amplitude. Divide by 
+		//!	1000 to use as a member function parameter. This parameter
+		//!	should be the same in Distiller, Sieve, and Collator.
+		DefaultFadeTimeMs = 5,
+		
+		//! Default minimum duration in milliseconds of the silent 
+		//! (zero-amplitude) gap between two Partials joined by 
+		//!	distillation. Divide by 1000 to use as a member function 
+		//!	parameter. This parameter should be the same in Distiller, 
+		//!	Sieve, and Collator.
+		DefaultSilentTimeMs = 1
+    };
+
+//  -- construction --
+
+    //! Construct a new Distiller using the specified fade time
+    //! for gaps between Partials. When two non-overlapping Partials
+    //! are distilled into a single Partial, the distilled Partial
+    //! fades out at the end of the earlier Partial and back in again
+    //! at the onset of the later one. The fade time is the time over
+    //! which these fades occur. By default, use a 1 ms fade time.
+    //! The gap time is the additional time over which a Partial faded
+    //! out must remain at zero amplitude before it can fade back in.
+    //! By default, use a gap time of one tenth of a millisecond, to 
+    //! prevent a pair of arbitrarily close null Breakpoints being
+    //! inserted.
+    //!
+    //!   \param   partialFadeTime is the time (in seconds) over
+    //!            which Partials joined by distillation fade to
+    //!            and from zero amplitude. (Default is 
+    //!            Distiller::DefaultFadeTime).
+    //!   \param   partialSilentTime is the minimum duration (in seconds) 
+    //!            of the silent (zero-amplitude) gap between two 
+    //!            Partials joined by distillation. (Default is
+    //!            Distiller::DefaultSilentTime).
+    explicit
+    Distiller( double partialFadeTime = Distiller::DefaultFadeTimeMs/1000.0,
+               double partialSilentTime = Distiller::DefaultSilentTimeMs/1000.0 );
+     
+    //  Use compiler-generated copy, assign, and destroy.
+    
+//  -- distillation --
+
+    //! Distill labeled Partials in a collection leaving only a single 
+    //! Partial per non-zero label. 
+    //!
+    //! Unlabeled (zero-labeled) Partials are left unmodified at 
+    //! the end of the distilled Partials.
+    //!
+    //! Return an iterator refering to the position of the first unlabeled Partial,
+    //! or the end of the distilled collection if there are no unlabeled Partials.
+    //! Since distillation is in-place, the Partials collection may be smaller
+    //! (fewer Partials) after distillation, and any iterators on the collection
+    //! may be invalidated.
+    //!
+    //! \post   All labeled Partials in the collection are uniquely-labeled,
+    //!         and all unlabeled Partials have been moved to the end of the
+    //!         sequence.
+    //! \param  partials is the collection of Partials to distill in-place
+    //! \return the position of the end of the range of distilled Partials,
+    //!         which is either the end of the collection, or the position
+    //!         or the first unlabeled Partial.
+    //!
+    //! If compiled with NO_TEMPLATE_MEMBERS defined, then partials
+    //! must be a PartialList, otherwise it can be any container type
+    //! storing Partials that supports at least bidirectional iterators.
+    //!
+    //! \sa Distiller::distill( Container & partials )
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    template< typename Container >
+    typename Container::iterator distill( Container & partials );
+#else
+    inline
+    PartialList::iterator distill( PartialList & partials );
+#endif
+
+    //! Function call operator: same as distill( PartialList & partials ).
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    template< typename Container >
+    typename Container::iterator operator() ( Container & partials );
+#else
+    PartialList::iterator operator() ( PartialList & partials );
+#endif
+    
+    //! Static member that constructs an instance and applies
+    //! it to a sequence of Partials. 
+    //!
+    //! \post   All labeled Partials in the collection are uniquely-labeled,
+    //!         and all unlabeled Partials have been moved to the end of the
+    //!         sequence.
+    //! \param  partials is the collection of Partials to distill in-place
+    //! \param  partialFadeTime is the time (in seconds) over
+    //!         which Partials joined by distillation fade to
+    //!         and from zero amplitude.
+    //! \param  partialSilentTime is the minimum duration (in seconds) 
+    //!         of the silent (zero-amplitude) gap between two 
+    //!         Partials joined by distillation. (Default is
+    //!         Distiller::DefaultSilentTime).
+    //! \return the position of the end of the range of distilled Partials,
+    //!         which is either the end of the collection, or the position
+    //!         or the first unlabeled Partial.
+    //!
+    //! If compiled with NO_TEMPLATE_MEMBERS defined, then partials
+    //! must be a PartialList, otherwise it can be any container type
+    //! storing Partials that supports at least bidirectional iterators.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    template< typename Container >
+    static typename Container::iterator 
+    distill( Container & partials, double partialFadeTime,
+             double partialSilentTime = DefaultSilentTimeMs/1000.0 );
+#else
+    static inline PartialList::iterator
+    distill( PartialList & partials, double partialFadeTime,
+             double partialSilentTime = DefaultSilentTimeMs/1000.0 );
+#endif
+
+private:
+
+//  -- helpers --
+
+    //! Distill labeled Partials in a PartialList leaving only a single 
+    //! Partial per non-zero label. 
+    //!
+    //! Unlabeled (zero-labeled) Partials are left unmodified at 
+    //! the end of the distilled Partials.
+    //!
+    //! Return an iterator refering to the position of the first unlabeled Partial,
+    //! or the end of the distilled collection if there are no unlabeled Partials.
+    //! Since distillation is in-place, the Partials collection may be smaller
+    //! (fewer Partials) after distillation, and any iterators on the collection
+    //! may be invalidated.
+    //!
+    //! \post   All labeled Partials in the collection are uniquely-labeled,
+    //!         and all unlabeled Partials have been moved to the end of the
+    //!         sequence.
+    //! \param  partials is the collection of Partials to distill in-place
+    //! \return the position of the end of the range of distilled Partials,
+    //!         which is either the end of the collection, or the position
+    //!         or the first unlabeled Partial.
+    PartialList::iterator distill_list( PartialList & partials );
+
+    //! Distill a list of Partials having a common label
+    //! into a single Partial with that label, and append it
+    //! to the distilled collection. If an empty list of Partials
+    //! is passed, then an empty Partial having the specified
+    //! label is appended.
+    void distillOne( PartialList & partials, Partial::label_type label,
+                     PartialList & distilled );
+    
+};  //  end of class Distiller
+
+// ---------------------------------------------------------------------------
+//  distill
+// ---------------------------------------------------------------------------
+//! Distill labeled Partials in a collection leaving only a single 
+//! Partial per non-zero label. 
+//!
+//! Unlabeled (zero-labeled) Partials are left unmodified at 
+//! the end of the distilled Partials.
+//!
+//! Return an iterator refering to the position of the first unlabeled Partial,
+//! or the end of the distilled collection if there are no unlabeled Partials.
+//! Since distillation is in-place, the Partials collection may be smaller
+//! (fewer Partials) after distillation, and any iterators on the collection
+//! may be invalidated.
+//!
+//!   \post   All labeled Partials in the collection are uniquely-labeled,
+//!           and all unlabeled Partials have been moved to the end of the
+//!           sequence.
+//!   \param  partials is the collection of Partials to distill in-place
+//!   \return the position of the end of the range of distilled Partials,
+//!           which is either the end of the collection, or the position
+//!           or the first unlabeled Partial.
+//!
+//! If compiled with NO_TEMPLATE_MEMBERS defined, then partials
+//! must be a PartialList, otherwise it can be any container type
+//! storing Partials that supports at least bidirectional iterators.
+//!
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename Container >
+typename Container::iterator Distiller::distill( Container & partials )
+{
+    //  This can be done so much more easily and
+    //  efficiently on a list than on other containers
+    //  that it is worth copying the Partials to a
+    //  list for distillation, and then transfering
+    //  them back.
+    //
+    //  See below for a specialization for the case
+    //  of the Container being a list, so no copy
+    //  is needed.
+    PartialList pl( partials.begin(), partials.end() );
+    PartialList::iterator it = distill_list( pl );
+        
+    //  pl has distilled Partials at beginning, and
+    //  unlabeled Partials at end:
+    typename Container::iterator beginUnlabeled = 
+        std::copy( pl.begin(), it, partials.begin() );
+    
+    typename Container::iterator endUnlabeled = 
+        std::copy( it, pl.end(), beginUnlabeled );
+
+    
+    partials.erase( endUnlabeled, partials.end() );
+    
+    return beginUnlabeled;
+}
+
+//  specialization for PartialList container
+template< >
+inline
+PartialList::iterator Distiller::distill( PartialList & partials )
+{
+    debugger << "using PartialList version of distill to avoid copying" << endl;
+    return distill_list( partials );
+}
+#else
+inline
+PartialList::iterator Distiller::distill( PartialList & partials )
+{
+    return distill_list( partials );
+}
+#endif
+
+// ---------------------------------------------------------------------------
+//  Function call operator 
+// ---------------------------------------------------------------------------
+//! Function call operator: same as distill( PartialList & partials ).
+//! 
+//! \sa Distiller::distill( Container & partials )
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename Container >
+typename Container::iterator Distiller::operator()( Container & partials )
+#else
+inline
+PartialList::iterator Distiller::operator()( PartialList & partials )
+#endif
+{ 
+    return distill( partials );
+}
+
+// ---------------------------------------------------------------------------
+//  distill
+// ---------------------------------------------------------------------------
+//! Static member that constructs an instance and applies
+//! it to a sequence of Partials. 
+//!
+//!   \post   All labeled Partials in the collection are uniquely-labeled,
+//!           and all unlabeled Partials have been moved to the end of the
+//!           sequence.
+//!   \param  partials is the collection of Partials to distill in-place
+//!   \param  partialFadeTime is the time (in seconds) over
+//!           which Partials joined by distillation fade to
+//!           and from zero amplitude.
+//!   \param  partialSilentTime is the minimum duration (in seconds) 
+//!           of the silent (zero-amplitude) gap between two 
+//!           Partials joined by distillation. (Default is
+//!           Distiller::DefaultSilentTime).
+//!   \return the position of the end of the range of distilled Partials,
+//!           which is either the end of the collection, or the position
+//!           or the first unlabeled Partial.
+//!
+//! If compiled with NO_TEMPLATE_MEMBERS defined, then partials
+//! must be a PartialList, otherwise it can be any container type
+//! storing Partials that supports at least bidirectional iterators.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename Container >
+typename Container::iterator 
+Distiller::distill( Container & partials, double partialFadeTime,
+                                          double partialSilentTime )
+#else
+inline
+PartialList::iterator 
+Distiller::distill( PartialList & partials, double partialFadeTime,
+                                            double partialSilentTime )
+#endif
+{
+    Distiller instance( partialFadeTime, partialSilentTime );
+    return instance.distill( partials );
+}
+
+}   //  end of namespace Loris
+
+#endif /* ndef INCLUDE_DISTILLER_H */
diff --git a/src/loris/Envelope.C b/src/loris/Envelope.C
new file mode 100644
index 0000000..019a7c2
--- /dev/null
+++ b/src/loris/Envelope.C
@@ -0,0 +1,54 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Envelope.C
+ *
+ * Implementation of class Envelope.
+ *
+ * Kelly Fitz, 21 July 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "Envelope.h"
+
+//	Since Envelope is just an interface, there's nothing interesting in 
+//	the implementation file.
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	destructor
+// ---------------------------------------------------------------------------
+//
+Envelope::~Envelope(void)
+{
+}
+
+}	//	end of namespace Loris
diff --git a/src/loris/Envelope.h b/src/loris/Envelope.h
new file mode 100644
index 0000000..832619a
--- /dev/null
+++ b/src/loris/Envelope.h
@@ -0,0 +1,170 @@
+#ifndef INCLUDE_ENVELOPE_H
+#define INCLUDE_ENVELOPE_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Envelope.h
+ *
+ * Definition of abstract interface class Envelope.
+ *
+ * Kelly Fitz, 21 July 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include <memory>	//	 for autoptr
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	class Envelope
+//
+//! Envelope is an base class for objects representing real functions
+//! of time.
+//!
+//! Class Envelope is an abstract base class, specifying interface for
+//! prototypable (clonable) objects representing generic, real-valued
+//! (double) functions of one real-valued (double) time argument. Derived
+//! classes (like BreakpointEnvelope) must implement valueAt() and
+//! clone(), the latter to support the Prototype pattern. Clients of
+//! Envelope, like Morpher and Distiller, can use prototype Envelopes to
+//! make their own private Envelopes.
+//!
+//! \sa Distiller, Envelope, Morpher
+//
+class Envelope
+{
+//	-- public interface --
+public:
+//	-- construction --
+
+    // allow compiler to generate constructors
+
+	//!	Destroy this Envelope (virtual to allow subclassing).
+	virtual ~Envelope( void );
+
+//	-- Envelope interface --
+
+	//!	Return an exact copy of this Envelope (following the Prototype
+	//!	pattern).
+	virtual Envelope * clone( void ) const = 0;
+
+	//!	Return the value of this Envelope at the specified time. 	 
+	virtual double valueAt( double x ) const = 0;	
+	
+};	//	end of abstract class Envelope
+
+
+// ---------------------------------------------------------------------------
+//	class ScaleAndOffsetEnvelope
+//
+//! ScaleAndOffsetEnvelope is an derived Envelope class for objects 
+//! representing envelopes having a scale and offset applied (in that order).
+
+class ScaleAndOffsetEnvelope : public Envelope
+{
+//	-- public interface --
+public:
+//	-- construction --
+
+    //! Construct a new envelope that is a scaled and offset 
+    //! version of another.
+    ScaleAndOffsetEnvelope( const Envelope & e, double scale, double offset ) :
+    	m_env( e.clone() ),
+    	m_scale( scale ),
+    	m_offset( offset )
+    {
+    }
+
+	//!	Construct a copy of an envelope.
+	ScaleAndOffsetEnvelope( const ScaleAndOffsetEnvelope & rhs ) :
+		m_env( rhs.m_env->clone() ),
+    	m_scale( rhs.m_scale ),
+    	m_offset( rhs.m_offset )
+    {
+    }
+
+	//!	Assignment from another envelope.
+	ScaleAndOffsetEnvelope & 
+	operator=( const ScaleAndOffsetEnvelope & rhs )
+	{
+        if ( &rhs != this )
+        {
+            m_env.reset( rhs.m_env->clone() );
+            m_scale = rhs.m_scale;
+            m_offset = rhs.m_offset;
+        }
+        return *this;
+    }
+
+//	-- Envelope interface --
+
+	//!	Return an exact copy of this Envelope (following the Prototype
+	//!	pattern).
+	ScaleAndOffsetEnvelope * clone( void ) const 
+	{
+		return new ScaleAndOffsetEnvelope( *this );
+	}
+
+	//!	Return the value of this Envelope at the specified time. 	 
+	virtual double valueAt( double x ) const
+	{
+		return m_offset + ( m_scale * m_env->valueAt( x ) );
+	}
+	
+//  -- private member variables --
+
+private:
+
+    std::auto_ptr< Envelope > m_env;   	
+    double m_scale, m_offset;
+	
+};	//	end of class ScaleAndOffsetEnvelope
+
+
+// ---------------------------------------------------------------------------
+//	math operators
+// ---------------------------------------------------------------------------
+
+inline
+ScaleAndOffsetEnvelope
+operator*( const Envelope & e, double x )
+{
+	return ScaleAndOffsetEnvelope( e, x, 0 );
+}
+
+inline
+ScaleAndOffsetEnvelope
+operator*( double x, const Envelope & e )
+{
+	return e * x;
+}
+
+
+
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_ENVELOPE_H */
diff --git a/src/loris/Exception.h b/src/loris/Exception.h
new file mode 100644
index 0000000..e21355c
--- /dev/null
+++ b/src/loris/Exception.h
@@ -0,0 +1,41 @@
+#ifndef INCLUDE_EXCEPTION_H_DEPRECATED
+#define INCLUDE_EXCEPTION_H_DEPRECATED
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Exception.h
+ *
+ * This file formerly defined class Exception, a generic exception class, and 
+ * commonly-used derived exception classes, but the name caused build problems
+ * on case-insensitive systems having a system header called exception.h, so 
+ * the name has been changed to LorisExceptions.h. This file is included as 
+ * legacy support. New code should use LorisExceptions.h.
+ *
+ * Kelly Fitz, 17 Aug 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#include "LorisExceptions.h"
+
+#endif /* ndef INCLUDE_EXCEPTION_H_DEPRECATED */
diff --git a/src/loris/F0Estimate.C b/src/loris/F0Estimate.C
new file mode 100644
index 0000000..d03c136
--- /dev/null
+++ b/src/loris/F0Estimate.C
@@ -0,0 +1,697 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * F0Estimate.C
+ *
+ * Implementation of an iterative alrogithm for computing an 
+ * estimate of fundamental frequency from a sequence of sinusoidal
+ * frequencies and amplitudes using a likelihood estimator
+ * adapted from Quatieri's Speech Signal Processing text. The 
+ * algorithm here takes advantage of the fact that spectral peaks
+ * have already been identified and extracted in the analysis/modeling
+ * process.
+ *
+ * Kelly Fitz, 28 March 2006
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "F0Estimate.h"
+
+#include "LorisExceptions.h"	// for Assert
+
+#include "Notifier.h"
+
+#include <algorithm>
+#include <cmath>
+#include <numeric>
+
+#include <vector>
+using std::vector;
+
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+	const double Pi = M_PI;
+#else
+	const double Pi = 3.14159265358979324;
+#endif
+
+// #if defined(HAVE_ISFINITE) && (HAVE_ISFINITE)
+//     using std::isfinite;
+//    
+//	isfinite is not, after all, part of the standard, 
+//	it is an extension. If it is not provided, the following
+//	checks for NaN and finite-ness.
+//
+//	Use this instead.
+// 	This code is taken from 
+//		http://www.johndcook.com/IEEE_exceptions_in_cpp.html
+
+#include <float.h>
+inline bool IsFiniteNumber( double x )
+{
+	//	DBL_MAX is defined in float.h.
+	//	Comparisons with NaN always fail. 
+	
+    return (x <= DBL_MAX && x >= -DBL_MAX);		
+}
+	
+
+
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	forward declarations for helpers, defined below
+//  Q is the likelihood function, Qprime is its derivative w.r.t. frequency
+
+static double
+secant_method( const vector<double> & amps, 
+               const vector<double> & freqs, 
+               double f1, double f2,
+               double precision );
+
+static void
+compute_candidate_freqs( const vector< double > & peak_freqs,
+                         double fmin, double fmax, 
+                         vector< double > & eval_freqs );                    			
+static void
+evaluate_Q( const vector<double> & amps, 
+			const vector<double> & freqs, 
+			const vector<double> & eval_freqs, 
+			vector<double> & Q );
+                    
+static double
+evaluate_Q( const vector<double> & amps, 
+			const vector<double> & freqs, 
+			double eval_freq,
+            double norm );
+
+static double
+evaluate_Qprime( const vector<double> & amps, 
+                 const vector<double> & freqs, 
+                 double eval_freq );
+         
+static void
+evaluate_Q( const vector<double> & amps, 
+            const vector<double> & freqs, 
+            const vector<double> & eval_freqs, 
+            vector<double> & Q,
+            double norm );
+            
+// ---------------------------------------------------------------------------
+                                    
+               
+// ---------------------------------------------------------------------------
+//  F0Estimate constructor
+// ---------------------------------------------------------------------------
+//  Construct from parameters of the iterative F0 estimation 
+//  algorithm. Find candidate F0 estimates as integer divisors
+//  of the peak frequencies, pick the highest frequency of the
+//  most likely candidates, and refine that estiamte using the
+//  secant method. 
+//
+//  Store the frequency and the normalized value of the 
+//  likelihood function at that frequency (1.0 indicates that
+//  all the peaks are perfect harmonics of the estimated
+//  frequency).
+//
+//  See the F0Estimate.h for a description of the algorithm, also
+//  outlined inline below.
+
+F0Estimate::F0Estimate( const vector<double> & amps, 
+                        const vector<double> & freqs, 
+                        double fmin, double fmax,
+                        double resolution ) :
+    m_frequency( 0 ), 
+    m_confidence( 0 )
+{
+    if ( fmin > fmax )
+    {
+        std::swap( fmin, fmax );
+    }
+	//	never consider DC (0 Hz) to be a valid fundamental
+	fmin = std::max( 1., fmin );
+    
+    // -------------------------------------------------------------------------    
+    // 1)  Identify candidate F0s as the integer divisors of the sinusoidal 
+    //     frequencies provided, within the specified range (this algorithm
+    //     relies on the reasonable assumption that for any frequency recognized 
+    //     as a likely F0, at least one of the sinusoidal frequencies must 
+    //     represent a harmonic, the likelihood function makes this same     
+    
+    //  First collect candidate frequencies: all integer 
+    //  divisors of the peak frequencies that are between 
+    //  fmin and fmax.
+    vector< double > eval_freqs;
+    compute_candidate_freqs( freqs, fmin, fmax, eval_freqs );
+
+    if ( ! eval_freqs.empty() )
+    {
+        //  Compute a normalization factor equal to the total
+        //  energy represented by all the peaks passed in
+        //  amps and freqs, so that the value of the likelihood
+        //  function does not depend on the overall signal 
+        //  amplitude, but instead depends only on the quality
+        //  of the estimate, or the confidence in the result, 
+        //  and the quality of the final estimate can be evaluated
+        //  by the value of the likelihood function.
+        double normalization = 
+            1.0 / std::inner_product( amps.begin(), amps.end(), amps.begin(), 0.0 );
+            
+        //  Evaluate the likelihood function at the candidate frequencies.
+        vector < double > Q( eval_freqs.size() );
+        evaluate_Q( amps, freqs, eval_freqs, Q, normalization );
+
+        // -------------------------------------------------------------------------    
+        // 2)  Select the highest frequency candidate that nearly maximizes the 
+        //     likelihood function (because all subharmonics of the true F0 will
+        //     be equal in likelihood to the true F0, but no higher frequency can
+        //     be as likely).
+    
+        //  Find the highest frequency corresponding to a high value of Q
+        //  (the most likely candidate).            
+
+        vector<double>::size_type idx = 
+            std::max_element( Q.begin(), Q.end() ) - Q.begin();
+        
+        double bestFreq = eval_freqs[ idx ];
+        double bestQ = Q[ idx ];
+        
+        // -------------------------------------------------------------------------    
+        // 2a) Check the likelihood of integer multiples of the best candidate,
+        //     choose the highest multiple (within the specified range) that
+        //     as likely as the best candidate frequency to be the new best
+        //     candidate. 
+
+        //  Check integer multiples of the best candidate frequency, 
+        //  so that we can be certain that the peak doesn't 
+        //  correspond to a subharmonic of the true most-likely
+        //  F0 in the range [fmin,fmax].
+        //
+        //  While the next octave up is in range, and its likelihood
+        //  is within 5% of the previously found peak, accept the
+        //  octave as the better candidate (when we reach the true
+        //  best candidate frequency, the next multiple should be
+        //  much less likely).
+        
+        double nextF = 2 * bestFreq;
+        double nextQ = evaluate_Q( amps, freqs, nextF, normalization );
+        
+        while ( fmax > nextF && ( 0.95 * bestQ ) <  nextQ )
+        {
+            //  update best candidate:
+            bestFreq = nextF;
+            bestQ = nextQ;
+            
+            //  consider the next multiple
+            nextF += bestFreq;
+            nextQ = evaluate_Q( amps, freqs, nextF, normalization );                        
+        }          
+  
+//        notifier << "peak is : " << bestFreq
+//                 << " Hz, Q: " << bestQ << endl;
+        
+        // -------------------------------------------------------------------------    
+        // 3)  Refine the best candidate using the secant method for refining the 
+        //     root of the derivative of the likelihood function in the neighborhood
+        //     of the best candidate (because a peak in the likelihood function is
+        //     a root of the derivative of that function).
+
+
+        //  Refine this estimate using the secant method.    
+        //
+        //  Check the derivative function: if the slope (derivative)
+        //  is positive, then assume that bestFreq is just below the
+        //  root, and choose a second frequency just greater than
+        //  bestFreq. Otherwise, assume that bestFreq is just above
+        //  the root of the derivative function, and choose a second
+        //  frequency just below bestFreq.
+        
+        double altFreq = bestFreq - resolution;
+        if ( 0 < evaluate_Qprime( amps, freqs, bestFreq ) )
+        {
+            altFreq = bestFreq + resolution;
+        }
+        
+        //  Now invoke the secant method to attempt to refine
+        //  the root estimate:
+        m_frequency = secant_method( amps, freqs, 
+                                     bestFreq, altFreq,
+                                     resolution );
+
+
+//        notifier << "best candidate is : " << bestFreq
+//                 << " Hz, Q: " << bestQ << endl;
+//        notifier << "secant method found : " << m_frequency
+//                 << " Hz, Q: " 
+//                 << evaluate_Q( amps, freqs, m_frequency, normalization ) << endl;
+//                 
+        
+        //  What if the secant method flies off to some other root? 
+        //  Check that the root is still between fmin and fmax.
+        if ( m_frequency < fmin || m_frequency > fmax )
+        {
+            //  If refining fails, just use the best candidate estimate.
+            m_frequency = bestFreq;
+        }
+        
+        
+        //
+        //  Could also use the bisection method, or the false position method, which 
+        //  always converge. All that is required is that two points on the
+        //  function (the derivative of the likelihood function, in this case)
+        //  having opposite signs are used to begin the search. So we need
+        //  to first find a nearby freq at which the derivative of Q evaluates
+        //  with the opposite sign as bestFreq.         
+        //
+        
+                        
+        //  Compute the value of the likelihood function at this frequency.
+        m_confidence = evaluate_Q( amps, freqs, m_frequency, normalization );  
+        
+        //  If the secant method makes things worse, then just go with the
+        //  the most likely candidate.
+        //
+        //  This is a sanity measure, should never happen.
+        if ( bestQ > m_confidence )
+        {
+            m_confidence = bestQ;
+            m_frequency = bestFreq;
+        }
+        
+//        notifier << "refined to: " << m_frequency
+//                 << " Hz, Q: " << m_confidence << endl;
+    
+    }
+
+}
+                                        
+
+// ---------------------------------------------------------------------------
+//  --- local helpers ---
+// ---------------------------------------------------------------------------
+
+
+//  Collect candidate frequencies in eval_freqs.
+//  Candidates are all integer divisors
+//  between fmin and fmax of any frequency in the
+//  vector of peak frequencies provided.
+
+static void
+compute_candidate_freqs( const vector< double > & peak_freqs,
+                         double fmin, double fmax, 
+                         vector< double > & eval_freqs )
+{
+	Assert( fmax > fmin );
+    
+    eval_freqs.clear();
+    
+    for ( vector< double >::const_iterator pk = peak_freqs.begin();
+         pk != peak_freqs.end();
+         ++pk )
+    {    
+        //  check all integer divisors of *pk
+        double div = 1;
+        double f = *pk;
+
+        //  reject all the ones greater than fmax
+        while( f > fmax )
+        {
+            ++div;
+            f = *pk / div;
+        }          
+        
+        //  keep the the ones that are between fmin 
+        //  and fmax
+        while( f >= fmin )
+        {
+            eval_freqs.push_back( f );
+            ++div;
+            f = *pk / div;
+        }        
+    }
+    
+    //  sort the candidats
+    sort( eval_freqs.begin(), eval_freqs.end() );
+}
+
+
+// ---------------------------------------------------------------------------
+//  --- likelihood function evaluation ---
+// ---------------------------------------------------------------------------
+
+
+//	Qterm is a functor to help compute terms
+//	in the likelihood function sum.
+
+struct Qterm
+{
+	double f0;
+	Qterm( double f ) : f0(f) {}
+	
+	double operator()( double amp, double freq ) const
+	{
+		double arg = 2*Pi*freq/f0;
+		return amp*amp*std::cos(arg);
+	}
+};
+
+//	evaluate_Q
+//
+//	Evaluate the likelihood function at the specified
+//	frequency.
+
+static double
+evaluate_Q( const vector<double> & amps, 
+            const vector<double> & freqs, 
+            double eval_freq,
+            double norm )
+{
+    double prod = 
+        std::inner_product( amps.begin(), amps.end(),
+                            freqs.begin(),
+                            0.,
+                            std::plus< double >(),
+                            Qterm( eval_freq ) );
+                            
+    return prod * norm;
+}    
+
+//	evaluate_Q
+//
+//	Evaluate the normalized likelihood function at a range of 
+//	frequencies, return the results in the vector Q.
+
+static void
+evaluate_Q( const vector<double> & amps, 
+            const vector<double> & freqs, 
+            const vector<double> & eval_freqs, 
+            vector<double> & Q )
+{
+	Assert( eval_freqs.size() == Q.size() );
+	Assert( amps.size() == freqs.size() );
+	
+    //  Compute a normalization factor equal to the total
+    //  energy represented by all the peaks passed in
+    //  amps and freqs, so that the value of the likelihood
+    //  function does not depend on the overall signal 
+    //  amplitude, but instead depends only on the quality
+    //  of the estimate, or the confidence in the result, 
+    //  and the quality of the final estimate can be evaluated
+    //  by the value of the likelihood function.
+    double etotal = std::inner_product( amps.begin(), amps.end(), amps.begin(), 0.0 );
+	double norm = 1.0 / etotal;
+    
+    evaluate_Q( amps, freqs, eval_freqs, Q, norm );
+}
+
+
+                                                    
+//	evaluate_Q
+//
+//	Evaluate the normalized likelihood function at a range of 
+//	frequencies, using the normalization factor provided, and
+//  return the results in the vector Q.
+
+static void
+evaluate_Q( const vector<double> & amps, 
+            const vector<double> & freqs, 
+            const vector<double> & eval_freqs, 
+            vector<double> & Q,
+            double norm )
+{
+	Assert( eval_freqs.size() == Q.size() );
+	Assert( amps.size() == freqs.size() );
+    
+	//	iterate over the frequencies at which to 
+	//	evaluate the likelihood function:
+	vector<double>::const_iterator freq_it = eval_freqs.begin();
+	vector<double>::iterator Q_it = Q.begin();
+	while ( freq_it != eval_freqs.end() )
+	{
+        double f = *freq_it;
+        
+		double result = evaluate_Q( amps, freqs, f, norm );
+                                                              
+		*Q_it++ = result;
+		++freq_it;
+	}
+}
+            
+// ---------------------------------------------------------------------------
+//  --- likelihood function derivative evaluation ---
+// ---------------------------------------------------------------------------
+
+
+//	Qprimeterm is a functor to help compute terms
+//	in the likelihood function derivative sum, used
+//  in the secant method of root refinement.
+
+struct Qprimeterm
+{
+	double f0;
+	Qprimeterm( double f ) : f0(f) {}
+	
+	double operator()( double amp, double freq ) const
+	{
+		double arg = 2*Pi*freq/f0;
+		return amp*amp*std::sin(arg)*arg/f0;
+	}
+};
+
+
+//	evaluate_Qprime
+//
+//	Evaluate the derivative of the likelihood function (w.r.t. frequency)
+//  at the specified frequency.
+
+static double
+evaluate_Qprime( const vector<double> & amps, 
+                 const vector<double> & freqs, 
+                 double eval_freq )
+{
+    double prod = 
+        std::inner_product( amps.begin(), amps.end(),
+                            freqs.begin(),
+                            0.,
+                            std::plus< double >(),
+                            Qprimeterm( eval_freq ) );
+
+    return prod;
+}                                        
+
+// ---------------------------------------------------------------------------
+//  --- secant method of refining a root/peak estimate ---
+// ---------------------------------------------------------------------------
+
+//	secant_method
+//
+//	Find roots of the derivative of the likelihood
+// 	function using the secant method, return the 
+//  value of x (frequency) at which the roots is found.
+
+static double
+secant_method( const vector<double> & amps, 
+               const vector<double> & freqs, 
+               double f1, double f2, double precision )
+{
+	double xn = f1;
+	double xnm1 = f2;
+	double fxnm1 = evaluate_Qprime( amps, freqs, xnm1 );
+    
+    const unsigned int MaxIters = 20;
+    
+    unsigned int iters = 0;
+    double deltax = 0.0;
+	
+    //  Iterate until delta is small, or blows up, 
+    //  or we have iterated too many times.
+	do 
+    {        		        
+		double fxn = evaluate_Qprime( amps, freqs, xn );
+
+		deltax = fxn * (xn - xnm1)/(fxn - fxnm1);
+        
+        xnm1 = xn;
+        xn = xn - deltax;	
+        
+        fxnm1 = fxn;
+
+	} 	while( // fabs( deltax ) > precision && 
+               IsFiniteNumber( deltax )  &&
+               ++iters < MaxIters );
+    
+    
+    //  Check whether delta blew up. If it did, revert to the
+    //  previous value of x.
+    
+    if ( ! IsFiniteNumber( deltax )  )
+    {
+        xn = xnm1;
+    }
+	
+	return xn;
+}
+
+#if 0
+// ---------------------------------------------------------------------------
+//  --- local helpers - dumb old way ---
+// ---------------------------------------------------------------------------
+
+               
+static void
+compute_eval_freqs( double fmin, double fmax, 
+                    vector<double> & eval_freqs );	
+                    
+static vector<double>::const_iterator
+choose_peak( const vector<double> & Q );
+
+// ---------------------------------------------------------------------------
+//  F0Estimate constructor -- iterative method
+// ---------------------------------------------------------------------------
+//	Iteratively compute the value of the likelihood function
+//	at a range of frequencies around the peak likelihood.
+//	Store the maximum value when the range of likelihood
+//	values computed is less than the specified resolution.
+//  Store the frequency and the normalized value of the 
+//  likelihood function at that frequency (1.0 indicates that
+//  all the peaks are perfect harmonics of the estimated
+//  frequency).
+    
+void 
+F0Estimate::construct_iterative_method( const vector<double> & amps, 
+                                        const vector<double> & freqs, 
+                                        double fmin, double fmax,
+                                        double resolution )
+{
+
+    //	when the frequency range is small, few samples are
+    //	needed, but initially make sure to sample at least
+    //	every 20 Hz. 
+    // Scratch that, 20 Hz isn't fine enough, could miss a 
+    // peak that way, try 2 Hz. There might be some room to
+    // adjust this parameter to trade off speed for robustness.
+	int Nsamps = std::max( 8, (int)std::ceil((fmax-fmin)*0.5) );
+	vector<double> eval_freqs, Q;
+	double peak_freq = fmin, peak_Q = 0;
+	
+	//	invariant:
+	//	the likelihood function for the estimate of the fundamental
+	//	frequency is maximized at some frequency between
+	//	fmin and fmax (stop when that range is smaller
+	//	than the resolution)
+	do
+	{
+		//	determine the frequencies at which to evaluate
+		//	the likelihood function
+		eval_freqs.resize( Nsamps );
+		compute_eval_freqs( fmin, fmax, eval_freqs );
+		
+		//	evaluate the likelihood function at those 
+		//	frequencies:
+		Q.resize( Nsamps );
+		evaluate_Q( amps, freqs, eval_freqs, Q );
+		
+		//	find the highest frequency at which the likelihood
+		//	function peaks:
+		vector<double>::const_iterator peak = choose_peak( Q );
+		int peak_idx = peak - Q.begin();
+		peak_Q = *peak;
+		peak_freq = eval_freqs[ peak_idx ];
+		
+		//	update search range:
+		fmin = eval_freqs[ std::max(peak_idx - 1, 0) ];
+		fmax = eval_freqs[ std::min(peak_idx + 1, Nsamps - 1) ];
+		Nsamps = std::max( 8, (int)std::ceil((fmax-fmin)*0.05) );
+		
+	} while ( (fmax - fmin) > resolution );
+
+    m_frequency = peak_freq;
+    m_confidence = peak_Q;
+}
+
+//	compute_eval_freqs
+//
+//	Fill the frequency vector with a sampling
+//	of the range [fmin,fmax].
+//
+//  (used by dumb old iterative method)
+//
+static void
+compute_eval_freqs( double fmin, double fmax, 
+					vector<double> & eval_freqs )
+{
+	Assert( fmax > fmin );
+	
+	double delta = (fmax-fmin)/(eval_freqs.size()-1);
+	double f = fmin;
+	vector<double>::iterator it = eval_freqs.begin();
+	while( it != eval_freqs.end() )
+	{
+		*it++ = f;
+		f += delta;
+	}
+	eval_freqs.back() = fmax;
+}
+
+//	choose_peak
+//
+//	Return the position of last peak that 
+//	in the vector Q.
+//
+static vector<double>::const_iterator
+choose_peak( const vector<double> & Q )
+{
+	Assert( !Q.empty() );
+	
+	double Qmax = *std::max_element( Q.begin(), Q.end() );
+	vector<double>::const_iterator it = (Q.end()) - 1;
+	double tmp = *it;
+	
+   // this threshold determines how strong the 
+   // highest-frequency peak in the likelihood 
+   // function needs to be relative to the overall
+   // peak. For strongly periodic signals, this can
+   // be quite near to 1, but for things that are 
+   // somewhat non-harmonic, setting it too high
+   // gives octave errors. Cannot tell whether errors
+   // will be introduced by having it too low.
+	const double threshold = 0.85 * Qmax;
+	while( (it != Q.begin()) && ((*it < threshold) || (*it < *(it-1))) )
+	{
+		--it;
+		tmp = *it;
+	}
+	
+	return it;
+}
+
+#endif
+
+}	//	end of namespace Loris
diff --git a/src/loris/F0Estimate.h b/src/loris/F0Estimate.h
new file mode 100644
index 0000000..a20e81e
--- /dev/null
+++ b/src/loris/F0Estimate.h
@@ -0,0 +1,135 @@
+#ifndef INCLUDE_F0ESTIMATE_H
+#define INCLUDE_F0ESTIMATE_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * F0Estimate.h
+ *
+ * Implementation of an iterative alrogithm for computing an 
+ * estimate of fundamental frequency from a sequence of sinusoidal
+ * frequencies and amplitudes using a likelihood estimator
+ * adapted from Quatieri's Speech Signal Processing text. The 
+ * algorithm here takes advantage of the fact that spectral peaks
+ * have already been identified and extracted in the analysis/modeling
+ * process.
+ *
+ * Kelly Fitz, 28 March 2006
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//  class F0Estimate
+//
+//! Represents a configuration of an iterative alrogithm for computing an 
+//! estimate of fundamental frequency from a sequence of sinusoidal
+//! frequencies and amplitudes using a likelihood estimator adapted
+//! from Quatieri's Speech Signal Processing text. This algorithm takes 
+//! advantage of the fact that spectral peaks have already been identified 
+//! and extracted in the analysis/modeling process.
+//!
+//! The algorithm consists of the following steps:
+//! 1)  Identify candidate F0s as the integer divisors of the sinusoidal 
+//!     frequencies provided, within the specified range (this algorithm
+//!     relies on the reasonable assumption that for any frequency recognized 
+//!     as a likely F0, at least one of the sinusoidal frequencies must 
+//!     represent a harmonic, the likelihood function makes this same 
+//!     assumption)
+//! 2)  Select the highest frequency candidate (within range) that maximizes 
+//!     the likelihood function (because all subharmonics of the true F0 will
+//!     be equal in likelihood to the true F0, but no higher frequency can
+//!     be as likely).
+//! 2a) Check the likelihood of integer multiples of the best candidate,
+//!     choose the highest multiple (within the specified range) that
+//!     as likely as the best candidate frequency to be the new best
+//!     candidate. 
+//! 3)  Refine the best candidate using the secant method for refining the 
+//!     root of the derivative of the likelihood function in the neighborhood
+//!     of the best candidate (because a peak in the likelihood function is
+//!     a root of the derivative of that function).
+//
+
+class F0Estimate
+{
+private:
+
+    double m_frequency;   //!  estimated fundamental frequency in Hz
+    double m_confidence;  //!  normalized confidence for this estimate, 
+                          //!  equal to 1.0 when all frequencies are perfect
+                          //!  harmonics of this estimate's frequency
+
+public:
+
+    //  --- lifecycle ---
+
+    //! Construct from parameters of the iterative F0 estimation 
+    //! algorithm. Find candidate F0 estimates as integer divisors
+    //! of the peak frequencies, pick the highest frequency of the
+    //! most likely candidates, and refine that estiamte using the
+    //! secant method. 
+    //!
+    //! Store the frequency and the normalized value of the 
+    //! likelihood function at that frequency (1.0 indicates that
+    //! all the peaks are perfect harmonics of the estimated
+    //! frequency).
+
+    F0Estimate( const std::vector<double> & amps, 
+                const std::vector<double> & freqs, 
+                double fmin, double fmax,
+                double resolution );
+                
+    //  default copy/assign/destroy are OK
+
+
+    //  Not sure whether or why these would be useful.
+    //
+    // F0Estimate( void ) : m_frequency( 0 ), m_confidence( 0 ) {}
+    // F0Estimate( double f, double c ) : m_frequency( f ), m_confidence( c ) {}
+    
+    
+    //  --- accessors ---
+    
+    //! Return the F0 frequency estimate, in Hz, for this estimate.
+        
+    double frequency( void ) const { return m_frequency; }
+    
+    //! Return the normalized confidence for this estimate, 
+    //! equal to 1.0 when all frequencies are perfect
+    //! harmonics of this estimate's frequency.
+        
+    double confidence( void ) const { return m_confidence; }
+    
+
+                    
+};  //  end of class F0Estimate
+
+
+}	//	end of namespace Loris
+
+#endif  //  ndef INCLUDE_F0ESTIMATE_H
diff --git a/src/loris/Filter.C b/src/loris/Filter.C
new file mode 100644
index 0000000..c60fddd
--- /dev/null
+++ b/src/loris/Filter.C
@@ -0,0 +1,204 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Filter.C
+ *
+ * Implementation of class Loris::Filter, a generic digital filter of 
+ * arbitrary order having both feed-forward and feedback coefficients. 
+ *
+ * Kelly Fitz, 1 Sept 1999
+ * revised 9 Oct 2009
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+    #include "config.h"
+#endif
+
+#include "Filter.h"
+
+#include <algorithm>
+#include <numeric>
+
+//  begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//  default construction
+// ---------------------------------------------------------------------------
+//! Construct a filter with an all-pass unity gain response.    
+//
+Filter::Filter( void ) :
+    m_ffwdcoefs( 1, 1.0 ),
+    m_fbackcoefs( 1, 1.0 ),
+    m_delayline( 1, 0 ),
+    m_gain( 1.0 )
+{
+}
+
+// ---------------------------------------------------------------------------
+//  copy construction
+// ---------------------------------------------------------------------------
+//! Make a copy of another digital filter. 
+//! Do not copy the filter state (delay line).
+//
+Filter::Filter( const Filter & other ) :
+    m_delayline( other.m_delayline.size(), 0. ),
+    m_ffwdcoefs( other.m_ffwdcoefs ),
+    m_fbackcoefs( other.m_fbackcoefs ),
+    m_gain( other.m_gain )
+{
+    Assert( m_delayline.size() >= m_ffwdcoefs.size() - 1 );
+    Assert( m_delayline.size() >= m_fbackcoefs.size() - 1 );
+}
+
+// ---------------------------------------------------------------------------
+//  assignment
+// ---------------------------------------------------------------------------
+//! Make a copy of another digital filter. 
+//! Do not copy the filter state (delay line).
+//
+Filter &
+Filter::operator=( const Filter & rhs )
+{
+    if ( &rhs != this )
+    {
+        m_delayline.resize( rhs.m_delayline.size() );
+        clear();
+        
+        m_ffwdcoefs = rhs.m_ffwdcoefs;
+        m_fbackcoefs = rhs.m_fbackcoefs;
+        m_gain = rhs.m_gain;
+
+        Assert( m_delayline.size() >= m_ffwdcoefs.size() - 1 );
+        Assert( m_delayline.size() >= m_fbackcoefs.size() - 1 );
+    }
+    return *this;
+}
+
+// ---------------------------------------------------------------------------
+//  destructor
+// ---------------------------------------------------------------------------
+//! Destructor is virtual to enable subclassing. Subclasses may specialize
+//! construction, and may add functionality, but for efficiency, the filtering
+//! operation is non-virtual.
+//
+Filter::~Filter( void )
+{
+}
+
+
+// ---------------------------------------------------------------------------
+//  apply
+// ---------------------------------------------------------------------------
+//! Compute a filtered sample from the next input sample.
+//!
+//
+double
+Filter::apply( double input )
+{ 
+    // Implement the recurrence relation. m_ffwdcoefs holds the feed-forward
+    // coefficients, m_fbackcoefs holds the feedback coeffs. The coefficient
+    // vectors and delay lines are ordered by increasing age.
+
+    double wn = - std::inner_product( m_fbackcoefs.begin()+1, m_fbackcoefs.end(), 
+                                      m_delayline.begin(), -input );
+        //  negate input, then negate the inner product
+        
+    m_delayline.push_front( wn );
+    
+    double output = std::inner_product( m_ffwdcoefs.begin(), m_ffwdcoefs.end(), 
+                                        m_delayline.begin(), 0. );
+    m_delayline.pop_back();
+        
+    return output * m_gain;
+}
+
+//  --- access/mutation ---
+
+// ---------------------------------------------------------------------------
+//  numerator
+// ---------------------------------------------------------------------------
+//! Provide access to the numerator (feed-forward) coefficients
+//! of this filter. The coefficients are stored in order of increasing
+//! delay (lowest order coefficient first).
+
+std::vector< double > 
+Filter::numerator( void )
+{
+    return m_ffwdcoefs;
+}
+
+// ---------------------------------------------------------------------------
+//  numerator
+// ---------------------------------------------------------------------------
+//! Provide access to the numerator (feed-forward) coefficients
+//! of this filter. The coefficients are stored in order of increasing
+//! delay (lowest order coefficient first).
+
+const std::vector< double > 
+Filter::numerator( void ) const
+{
+    return m_ffwdcoefs;
+}
+
+// ---------------------------------------------------------------------------
+//  denominator
+// ---------------------------------------------------------------------------
+//! Provide access to the denominator (feedback) coefficients
+//! of this filter. The coefficients are stored in order of increasing
+//! delay (lowest order coefficient first).
+
+std::vector< double > 
+Filter::denominator( void )
+{
+    return m_fbackcoefs;
+}
+
+// ---------------------------------------------------------------------------
+//  denominator
+// ---------------------------------------------------------------------------
+//! Provide access to the denominator (feedback) coefficients
+//! of this filter. The coefficients are stored in order of increasing
+//! delay (lowest order coefficient first).
+
+const std::vector< double > 
+Filter::denominator( void ) const
+{
+    return m_fbackcoefs;
+}
+
+// ---------------------------------------------------------------------------
+//  clear
+// ---------------------------------------------------------------------------
+//! Clear the filter state. 
+//
+void
+Filter::clear( void )
+{
+    std::fill( m_delayline.begin(), m_delayline.end(), 0 );
+}
+
+}   //  end of namespace Loris
diff --git a/src/loris/Filter.h b/src/loris/Filter.h
new file mode 100644
index 0000000..5a23a3e
--- /dev/null
+++ b/src/loris/Filter.h
@@ -0,0 +1,249 @@
+#ifndef INCLUDE_FILTER_H
+#define INCLUDE_FILTER_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Filter.h
+ *
+ * Definition of class Loris::Filter, a generic digital filter of 
+ * arbitrary order having both feed-forward and feedback coefficients. 
+ *
+ * Kelly Fitz, 1 Sept 1999
+ * revised 9 Oct 2009
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "LorisExceptions.h"
+#include "Notifier.h"
+
+#include <algorithm>
+#include <deque>
+#include <vector>
+
+//  begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//  class Filter
+//
+//! Filter is an Direct Form II realization of a filter specified
+//! by its difference equation coefficients and (optionally) gain,  
+//! applied to the filter output (defaults to 1.). Coefficients are
+//! specified and stored in order of increasing delay.
+//!
+//! Implements the rational transfer function
+//!
+//!                               -1               -nb
+//!                   b[0] + b[1]z  + ... + b[nb] z
+//!         Y(z) = G ---------------------------------- X(z)
+//!                               -1               -na
+//!                   a[0] + a[1]z  + ... + a[na] z
+//!
+//! where b[k] are the feed forward coefficients, and a[k] are the feedback 
+//! coefficients. If a[0] is not 1, then both a and b are normalized by a[0].
+//! G is the additional filter gain, and is unity if unspecified.
+//!
+//!
+//! Filter is implemented using a std::deque to store the filter state, 
+//! and relies on the efficiency of that class. If deque is not implemented
+//! using some sort of circular buffer (as it should be -- deque is guaranteed
+//! to be efficient for repeated insertion and removal at both ends), then
+//! this filter class will be slow.
+//
+class Filter
+{
+public:
+
+//  --- lifecycle ---
+
+    //  default construction
+    //! Construct a filter with an all-pass unity gain response.    
+    Filter( void );
+    
+    //  initialized construction
+    //! Initialize a Filter having the specified coefficients, and
+    //! order equal to the larger of the two coefficient ranges.
+    //! Coefficients in the sequences are stored in increasing order
+    //! (lowest order coefficient first).
+    //!
+    //! If template members are allowed, then the coefficients
+    //! can be stored in any kind of iterator range, otherwise,
+    //! they must be in an array of doubles.
+    //!
+    //! \param ffwdbegin is the beginning of a sequence of feed-forward coefficients
+    //! \param ffwdend is the end of a sequence of feed-forward coefficients
+    //! \param fbackbegin is the beginning of a sequence of feedback coefficients
+    //! \param fbackend is the end of a sequence of feedback coefficients   
+    //! \param gain is an optional gain scale applied to the filtered signal
+    //
+#if !defined(NO_TEMPLATE_MEMBERS)
+    template<typename IterT1, typename IterT2>
+    Filter( IterT1 ffwdbegin, IterT1 ffwdend,   //  feed-forward coeffs
+            IterT2 fbackbegin, IterT2 fbackend, //  feedback coeffs
+            double gain = 1. );
+#else
+    Filter( const double * ffwdbegin, const double * ffwdend, //    feed-forward coeffs
+            const double * fbackbegin, const double * fbackend, //  feedback coeffs
+            double gain = 1. );
+#endif
+
+    
+    // copy constructor 
+    //! Make a copy of another digital filter. 
+    //! Do not copy the filter state (delay line).
+    Filter( const Filter & other );
+    
+    //  assignment operator
+    //! Make a copy of another digital filter. 
+    //! Do not copy the filter state (delay line).
+    Filter & operator=( const Filter & rhs );
+    
+    //! Destructor is virtual to enable subclassing. Subclasses may specialize
+    //! construction, and may add functionality, but for efficiency, the filtering
+    //! operation is non-virtual.
+    ~Filter( void );
+    
+
+//  --- filtering ---
+
+    //! Compute a filtered sample from the next input sample.
+    //!
+    //!	\param input is the next input sample
+    //! \return the next output sample
+    double apply( double input );
+
+    //! Function call operator, same as sample().
+    //!
+    //! \sa apply
+    double operator() ( double input ) { return apply(input); }    
+
+//  --- access/mutation ---
+
+	//!	Provide access to the numerator (feed-forward) coefficients
+	//! of this filter. The coefficients are stored in order of increasing
+	//! delay (lowest order coefficient first).
+	
+	std::vector< double > numerator( void );
+
+	//!	Provide access to the numerator (feed-forward) coefficients
+	//! of this filter. The coefficients are stored in order of increasing
+	//! delay (lowest order coefficient first).
+	
+	const std::vector< double > numerator( void ) const;
+    
+	//!	Provide access to the denominator (feedback) coefficients
+	//! of this filter. The coefficients are stored in order of increasing
+	//! delay (lowest order coefficient first).
+	
+	std::vector< double > denominator( void );
+
+	//!	Provide access to the denominator (feedback) coefficients
+	//! of this filter. The coefficients are stored in order of increasing
+	//! delay (lowest order coefficient first).
+	
+	const std::vector< double > denominator( void ) const;
+	
+    
+    //! Clear the filter state. 
+    void clear( void );
+
+    
+private:    
+    
+//  --- implementation ---
+
+    //! single delay line for Direct-Form II implementation
+    std::deque< double > m_delayline;
+        
+    //! feed-forward coefficients
+    std::vector< double > m_ffwdcoefs;  
+
+    //! feedback coefficients
+    std::vector< double > m_fbackcoefs; 
+    
+    //! filter gain (applied to output)
+    double m_gain;      
+
+};  //  end of class Filter
+
+
+
+// ---------------------------------------------------------------------------
+//  constructor
+// ---------------------------------------------------------------------------
+//! Initialize a Filter having the specified coefficients, and
+//! order equal to the larger of the two coefficient ranges.
+//! Coefficients in the sequences are stored in increasing order
+//! (lowest order coefficient first).
+//!
+//! If template members are allowed, then the coefficients
+//! can be stored in any kind of iterator range, otherwise,
+//! they must be in an array of doubles.
+//!
+//! \param ffwdbegin is the beginning of a sequence of feed-forward coefficients
+//! \param ffwdend is the end of a sequence of feed-forward coefficients
+//! \param fbackbegin is the beginning of a sequence of feedback coefficients
+//! \param fbackend is the end of a sequence of feedback coefficients   
+//! \param gain is an optional gain scale applied to the filtered signal
+//
+#if !defined(NO_TEMPLATE_MEMBERS)
+template<typename IterT1, typename IterT2>
+Filter::Filter( IterT1 ffwdbegin, IterT1 ffwdend,   //  feed-forward coeffs
+                IterT2 fbackbegin, IterT2 fbackend, //  feedback coeffs
+                double gain ) :
+#else
+inline 
+Filter::Filter( const double * ffwdbegin, const double * ffwdend, //    feed-forward coeffs
+                const double * fbackbegin, const double * fbackend, //  feedback coeffs
+                double gain ) :
+#endif
+    m_ffwdcoefs( ffwdbegin, ffwdend ),
+    m_fbackcoefs( fbackbegin, fbackend ),
+    m_delayline( std::max( ffwdend-ffwdbegin, fbackend-fbackbegin ) - 1, 0. ),
+    m_gain( gain )
+{
+    if ( *fbackbegin == 0. )
+    {
+        Throw( InvalidObject, 
+               "Tried to create a Filter with feeback coefficient at zero delay equal to 0.0" );
+    }
+
+    //  normalize the coefficients by 1/a[0], if a[0] is not equal to 1.0
+    //  (already checked for a[0] == 0 above)
+    if ( *fbackbegin != 1. )
+    {
+        //  scale all filter coefficients by a[0]:
+        std::transform( m_ffwdcoefs.begin(), m_ffwdcoefs.end(), m_ffwdcoefs.begin(),
+                        std::bind2nd( std::divides<double>(), *fbackbegin ) );
+        std::transform( m_fbackcoefs.begin(), m_fbackcoefs.end(), m_fbackcoefs.begin(), 
+                        std::bind2nd( std::divides<double>(), *fbackbegin ) );
+        m_fbackcoefs[0] = 1.;
+    }
+}
+
+
+}   //  end of namespace Loris
+
+#endif /* ndef INCLUDE_FILTER_H */
diff --git a/src/loris/FourierTransform.C b/src/loris/FourierTransform.C
new file mode 100644
index 0000000..2a29238
--- /dev/null
+++ b/src/loris/FourierTransform.C
@@ -0,0 +1,641 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * FourierTransform.C
+ *
+ * Implementation of class Loris::FourierTransform, providing a simplified
+ * uniform interface to the FFTW library (www.fftw.org), version 2.1.3
+ * or newer (including version 3), or to the General Purpose FFT package
+ * by Takuya OOURA, http://momonga.t.u-tokyo.ac.jp/~ooura/fft.html if
+ * FFTW is unavailable. 
+ *
+ * Kelly Fitz, 2 Jun 2006
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "FourierTransform.h"
+#include "LorisExceptions.h"
+#include "Notifier.h"
+
+#include <cmath>
+#include <complex>
+
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+	const double Pi = M_PI;
+#else
+	const double Pi = std::acos( -1.0 );
+#endif
+
+#if defined(HAVE_FFTW3_H) && HAVE_FFTW3_H
+    #include <fftw3.h>
+#elif defined(HAVE_FFTW_H) && HAVE_FFTW_H
+    #include <fftw.h>
+#endif
+
+// ---------------------------------------------------------------------------
+//	isPO2 - return true if N is a power of two
+// ---------------------------------------------------------------------------
+//  If out_expon is non-zero, return the exponent in that address.
+//
+static bool isPO2( unsigned int N, int * out_expon = 0 )
+{
+    unsigned int M = 1;
+    int exp = 0;
+    while ( M < N )
+    {
+        M *= 2;
+        ++exp;
+    }
+    if ( 0 != out_expon && M == N )
+    {
+        *out_expon = exp;
+    }
+    return M == N;
+}
+
+// ===========================================================================
+// No longer matters that fftw and this class use the same floating point
+// data format. The insulating implementation class now does its job of
+// really insulating clients completely from FFTW, by copying data between
+// buffers of std::complex< double > and fftw_complex, rather than 
+// relying on those two complex types to have the same memory layout.
+// The overhead of copying is probably not significant, compared to 
+// the expense of computing the transform. 
+//
+// about complex math functions for fftw_complex:
+//
+// These functions are all defined as templates in <complex>.
+// Regrettably, they are all implemented using real() and 
+// imag() _member_ functions of the template argument, T. 
+// If they had instead been implemented in terms of the real()
+// and imag() (template) free functions, then I could just specialize
+// those two for the fftw complex data type, and the other template
+// functions would work. Instead, I have to specialize _all_ of
+// those functions that I want to use. I hope this was a learning 
+// experience for someone... In the mean time, the alternative I 
+// have is to take advantage of the fact that fftw_complex and 
+// std::complex<double> have the same footprint, so I can just
+// cast back and forth between the two types. Its icky, but it 
+// works, and its a lot faster than converting, and more palatable
+// than redefining all those operators.
+//
+// On the subject of brilliant designs, fftw_complex is defined as
+// a typedef of an anonymous struct, as in typedef struct {...} fftw_complex,
+// so I cannot forward-declare that type.
+//
+// In other good news, the planning structure got a slight name change
+// in version 3, making it even more important to remove all traces of
+// FFTW from the FourierTransform class definition.
+//
+// ===========================================================================
+
+//	begin namespace
+namespace Loris {
+
+using std::complex;
+using std::vector;
+
+// --- private implementation class ---
+
+// ---------------------------------------------------------------------------
+//  FTimpl
+//
+// Insulating implementation class to insulate clients
+// completely from everything about the interaction between
+// Loris and FFTW. There is more copying of data between buffers,
+// but this is not the expensive part of computing Fourier transforms
+// and we don't have to do unsavory things that require std::complex
+// and fftw_complex to have the same memory layout (we could even get
+// by with single-precision floats in FFTW if necessary). Also got
+// rid of lots of shared buffer stuff that just made the implementation
+// lots more complicated than necessary. This one is simple, if not
+// as memory efficient.
+//
+
+#if defined(HAVE_FFTW3_H) && HAVE_FFTW3_H
+
+class FTimpl    //  FFTW version 3
+{
+private:
+
+	fftw_plan plan;
+	FourierTransform::size_type N;
+	fftw_complex * ftIn;   
+	fftw_complex * ftOut;
+
+public:
+   
+	// Construct an implementation instance:
+	// allocate an input buffer, and an output buffer
+	// and make a plan.
+	FTimpl( FourierTransform::size_type sz ) : 
+	  plan( 0 ), N( sz ), ftIn( 0 ), ftOut( 0 ) 
+	{      
+		// allocate buffers:
+		ftIn = (fftw_complex *)fftw_malloc( sizeof( fftw_complex ) * N );
+		ftOut = (fftw_complex *)fftw_malloc( sizeof( fftw_complex ) * N );
+		if ( 0 == ftIn || 0 == ftOut )
+		{
+			fftw_free( ftIn );
+			fftw_free( ftOut );
+			throw RuntimeError( "cannot allocate Fourier transform buffers" );
+		}
+	  
+		//	create a plan:
+		plan = fftw_plan_dft_1d( N, ftIn, ftOut, FFTW_FORWARD, FFTW_ESTIMATE );
+
+		//	verify:
+		if ( 0 == plan )
+		{
+			Throw( RuntimeError, "FourierTransform could not make a (fftw) plan." );
+		}
+	}
+   
+	// Destroy the implementation instance:
+	// dump the plan.
+	~FTimpl( void )
+	{
+		if ( 0 != plan )
+		{
+            fftw_destroy_plan( plan );
+		}         
+		
+		fftw_free( ftIn );
+		fftw_free( ftOut );
+	}
+	
+	// Copy complex< double >'s from a buffer into ftIn, 
+	// the buffer must be as long as ftIn.
+	void loadInput( const complex< double > * bufPtr )
+	{
+		for ( FourierTransform::size_type k = 0; k < N; ++k )
+		{
+			ftIn[ k ][0] = bufPtr->real();  //  real part
+			ftIn[ k ][1] = bufPtr->imag();  //  imaginary part
+			++bufPtr;
+		}
+	}
+   
+	// Copy complex< double >'s from ftOut into a buffer,
+	// which must be as long as ftOut.
+	void copyOutput( complex< double > * bufPtr ) const
+	{
+		for ( FourierTransform::size_type k = 0; k < N; ++k )
+		{
+			*bufPtr = complex< double >( ftOut[ k ][0], ftOut[ k ][1] );
+			++bufPtr;
+		}
+	}
+    
+    // Compute a forward transform.
+    void forward( void )
+    {
+        fftw_execute( plan );
+    }
+    
+}; // end of class FTimpl for FFTW version 3
+
+#elif defined(HAVE_FFTW_H) && HAVE_FFTW_H
+
+//	"die hook" for FFTW, which otherwise try to write to a
+//	non-existent console.
+static void fftw_die_Loris( const char * s )
+{
+	using namespace std; // exit might be hidden in there
+	
+	notifier << "The FFTW library used by Loris has encountered a fatal error: " << s << endl;
+	exit(EXIT_FAILURE);
+}
+
+class FTimpl    //  FFTW version 2
+{
+private:
+
+	fftw_plan plan;
+	FourierTransform::size_type N;
+	fftw_complex * ftIn;   
+	fftw_complex * ftOut;
+   
+public:
+
+	// Construct an implementation instance:
+	// allocate an input buffer, and an output buffer
+	// and make a plan.
+	FTimpl( FourierTransform::size_type sz ) : 
+	  plan( 0 ), N( sz ), ftIn( 0 ), ftOut( 0 ) 
+	{      
+		// allocate buffers:
+		ftIn = (fftw_complex *)fftw_malloc( sizeof( fftw_complex ) * N );
+		ftOut = (fftw_complex *)fftw_malloc( sizeof( fftw_complex ) * N );
+		if ( 0 == ftIn || 0 == ftOut )
+		{
+			fftw_free( ftIn );
+			fftw_free( ftOut );
+			Throw( RuntimeError, "cannot allocate Fourier transform buffers" );
+		}
+	  
+		//	create a plan:
+		plan = fftw_create_plan_specific( N, FFTW_FORWARD, FFTW_ESTIMATE,
+                                          ftIn, 1, ftOut, 1 );
+
+		//	verify:
+		if ( 0 == plan )
+		{
+			Throw( RuntimeError, "FourierTransform could not make a (fftw) plan." );
+		}
+
+        //	FFTW calls fprintf a lot, which may be a problem in
+        //	non-console-enabled applications. Catch fftw_die()
+        //	calls by routing the error message to our own Notifier
+        //	and exiting, using the function defined above.
+        //
+        //	(version 2 only)
+        fftw_die_hook = fftw_die_Loris;
+	}
+   
+	// Destroy the implementation instance:
+	// dump the plan.
+	~FTimpl( void )
+	{
+		if ( 0 != plan )
+		{
+            fftw_destroy_plan( plan );
+		}         
+		
+		fftw_free( ftIn );
+		fftw_free( ftOut );
+	}
+	
+	// Copy complex< double >'s from a buffer into ftIn, 
+	// the buffer must be as long as ftIn.
+	void loadInput( const complex< double > * bufPtr )
+	{
+		for ( FourierTransform::size_type k = 0; k < N; ++k )
+		{
+			c_re( ftIn[ k ] ) = bufPtr->real();
+			c_im( ftIn[ k ] ) = bufPtr->imag();
+			++bufPtr;
+		}
+	}
+   
+	// Copy complex< double >'s from ftOut into a buffer,
+	// which must be as long as ftOut.
+	void copyOutput( complex< double > * bufPtr ) const
+	{
+		for ( FourierTransform::size_type k = 0; k < N; ++k )
+		{
+			*bufPtr = complex< double >( c_re( ftOut[ k ] ), c_im( ftOut[ k ] ) );
+			++bufPtr;
+		}
+	}
+    
+    // Compute a forward transform.
+    void forward( void )
+    {
+        fftw_one( plan, ftIn, ftOut );	
+    }
+    
+}; // end of class FTimpl for FFTW version 2
+
+#else
+
+#define SORRY_NO_FFTW  1
+
+//  function prototype, definition in fftsg.c
+extern "C" void cdft(int, int, double *, int *, double *);
+
+//  function prototype, definition below
+static void slowDFT( double * in, double * out, int N );
+
+//  Uses General Purpose FFT (Fast Fourier/Cosine/Sine Transform) Package
+//  by Takuya OOURA, http://momonga.t.u-tokyo.ac.jp/~ooura/fft.html defined
+//  in fftsg.c.
+//
+//  In the event that the size is not a power of two, uses a (very) slow
+//  direct DFT computation, defined below. In this case, the workspace
+//  array is not used, and the twiddle factor array is used to store the
+//  transform result.
+
+class FTimpl    //  platform-neutral stand-alone implementation
+{
+private:
+
+	double * mTxInOut;      //	input/output buffer for in-place transform                                
+	double * mTwiddle;      //	storage for twiddle factors
+	int * mWorkspace;		//	workspace storage
+
+	FourierTransform::size_type N;
+    
+    bool mIsPO2;
+   
+public:
+
+	// Construct an implementation instance:
+	// allocate buffers and workspace, and
+	// initialize the twiddle factors.
+	FTimpl( FourierTransform::size_type sz ) : 
+	  mTxInOut( 0 ), mTwiddle( 0 ), mWorkspace( 0 ), N( sz ), mIsPO2( isPO2( sz ) )
+	{      
+        mTxInOut = new double[ 2*N ]; 	
+            //	input/output buffer for in-place transform
+            
+        if ( mIsPO2 )
+        {    
+            mTwiddle = new double[ N/2 ]; 		
+                //	storage for twiddle factors
+                
+            mWorkspace = new int[ 2*int( std::sqrt((double)N) + 0.5 ) ];		
+                //	workspace 
+                
+            if ( 0 == mTxInOut || 0 == mTwiddle || 0 == mWorkspace )
+            {
+                delete [] mTxInOut;
+                delete [] mTwiddle;
+                delete [] mWorkspace;
+                Throw( RuntimeError, "FourierTransform: could not initialize tranform" );
+            }
+
+            mWorkspace[0] = 0;  // first time only, triggers setup    
+                                // no need to do it now, it will happen the 
+                                // first time a transform is computed
+            // cdft_double( 2*N, -1, mTxInOut, mWorkspace, mTwiddle );
+        }
+        else
+        {
+            mTwiddle = new double[ 2*N ]; 	
+                //	use for result in slowDFT 
+                
+            if ( 0 == mTxInOut || 0 == mTwiddle )
+            {
+                delete [] mTxInOut;
+                delete [] mTwiddle;
+                Throw( RuntimeError, "FourierTransform: could not initialize tranform" );
+            }
+        }
+	}
+   
+	// Destroy the implementation instance:
+	~FTimpl( void )
+	{
+        delete [] mTxInOut;
+        delete [] mTwiddle;
+        delete [] mWorkspace;
+	}
+	
+	// Copy complex< double >'s from a buffer into ftIn, 
+	// the buffer must be as long as ftIn.
+	void loadInput( const complex< double > * bufPtr )
+	{
+		for ( FourierTransform::size_type k = 0; k < N; ++k )
+		{
+			mTxInOut[ 2*k ] = bufPtr->real();
+			mTxInOut[ 2*k+1 ] = bufPtr->imag();
+			++bufPtr;
+		}
+	}
+   
+	//  Copy complex< double >'s from ftOut into a buffer,
+	//  which must be as long as ftOut. Result might be
+    //  stored in the twiddle factor array if this is not
+    //  power of two length DFT.
+	void copyOutput( complex< double > * bufPtr ) const
+	{
+        double * result = mTxInOut;
+        if ( !mIsPO2 )
+        {
+            result = mTwiddle;
+        }
+
+		for ( FourierTransform::size_type k = 0; k < N; ++k )
+		{
+			*bufPtr = complex< double >( result[ 2*k ], result[ 2*k+1 ] );
+			++bufPtr;
+		}
+	}
+    
+    // Compute a forward transform.
+    void forward( void )
+    {        
+        if ( mIsPO2 )
+        {
+            cdft( 2*N, -1, mTxInOut, mWorkspace, mTwiddle );
+        }
+        else
+        {
+            slowDFT( mTxInOut, mTwiddle, N );
+        }
+    }
+    
+}; // end of class platform-neutral stand-alone FTimpl 
+
+#endif
+
+// --- FourierTransform members ---
+
+// ---------------------------------------------------------------------------
+//	FourierTransform constructor
+// ---------------------------------------------------------------------------
+//! Initialize a new FourierTransform of the specified size.
+//!
+//! \param  len is the length of the transform in samples (the
+//!         number of samples in the transform)
+//! \throw  RuntimeError if the necessary buffers cannot be 
+//!         allocated, or there is an error configuring FFTW.
+//
+FourierTransform::FourierTransform( size_type len ) :
+	_buffer( len ),
+	_impl( new FTimpl( len ) )
+{
+	//	zero:
+	std::fill( _buffer.begin(), _buffer.end(), 0. );
+}
+
+// ---------------------------------------------------------------------------
+//	FourierTransform copy constructor
+// ---------------------------------------------------------------------------
+//! Initialize a new FourierTransform that is a copy of another,
+//! having the same size and the same buffer contents.
+//!
+//! \param  rhs is the instance to copy
+//! \throw  RuntimeError if the necessary buffers cannot be 
+//!         allocated, or there is an error configuring FFTW.
+//
+FourierTransform::FourierTransform( const FourierTransform & rhs ) :
+	_buffer( rhs._buffer ),
+	_impl( new FTimpl( rhs._buffer.size() ) ) // not copied
+{
+}
+
+// ---------------------------------------------------------------------------
+//	FourierTransform destructor
+// ---------------------------------------------------------------------------
+//! Free the resources associated with this FourierTransform.
+//
+FourierTransform::~FourierTransform( void )
+{	
+   delete _impl;
+}
+
+// ---------------------------------------------------------------------------
+//	FourierTransform assignment operator
+// ---------------------------------------------------------------------------
+//! Make this FourierTransform a copy of another, having
+//! the same size and buffer contents.
+//!
+//! \param  rhs is the instance to copy
+//! \return a refernce to this instance
+//! \throw  RuntimeError if the necessary buffers cannot be 
+//!         allocated, or there is an error configuring FFTW.
+//
+FourierTransform &
+FourierTransform::operator=( const FourierTransform & rhs )
+{
+   if ( this != &rhs )
+   {
+      _buffer = rhs._buffer;
+      
+      // The implementation instance is not assigned, 
+      // but a new one is created.
+      delete _impl;
+      _impl = 0;
+      _impl = new FTimpl( _buffer.size() );
+   }
+   
+   return *this;
+}
+
+// ---------------------------------------------------------------------------
+//	size
+// ---------------------------------------------------------------------------
+//! Return the length of the transform (in samples).
+//! 
+//! \return the length of the transform in samples.
+FourierTransform::size_type 
+FourierTransform::size( void ) const 
+{ 
+   return _buffer.size(); 
+}
+	
+// ---------------------------------------------------------------------------
+//	transform
+// ---------------------------------------------------------------------------
+//! Compute the Fourier transform of the samples stored in the 
+//! transform buffer. The samples stored in the transform buffer
+//! (accessed by index or by iterator) are replaced by the 
+//! transformed samples, in-place. 
+//
+void
+FourierTransform::transform( void )
+{
+    // copy data into the transform input buffer:
+    _impl->loadInput( &_buffer.front() );
+    
+    //	crunch:	
+    _impl->forward();
+    
+    // copy the data out of the transform output buffer:
+    _impl->copyOutput( &_buffer.front() );
+}
+
+
+// --- slow non-power-of-two DFT implementation ---
+
+#if defined(SORRY_NO_FFTW) 
+
+// ---------------------------------------------------------------------------
+//	slowDFT
+// ---------------------------------------------------------------------------
+//  Non-power-of-two DFT implementation. in and out cannot be the same,
+//  and each is 2*N long, storing interleaved complex numbers.
+//  This version is only used when FFTW is unavailable.
+//
+static
+void slowDFT( double * in, double * out, int N )
+{
+#if 1 
+    // slow DFT 
+    // This version of the direct DFT computation is tolerably
+    // speedy, even for rather long transforms (like 8k).
+    // There is only one expensive call to std::polar, and
+    // twiddle factors are updated by multiplying. This
+    // causes some loss in numerical accuracy, worse for
+    // longer transforms, but even for 10k long transforms,
+    // accuracy is within hundredths of a percent in my experiments.
+    
+    const std::complex< double > eminj2pioN = 
+        std::polar( 1.0, -2.0 * Pi / N );
+              
+    std::complex< double > Wn = 1;
+    for ( int n = 0; n < N; ++n )
+    {
+        std::complex< double > Wkn = 1;
+        std::complex< double > Xkn = 0;
+        for ( int k = 0; k < N; ++k )
+        {
+            Xkn += std::complex< double >( in[ 2*k ], in[ 2*k+1 ] ) * Wkn;
+            Wkn *= Wn;
+        }
+        
+        out[ 2*n ] = Xkn.real();
+        out[ 2*n+1 ] = Xkn.imag();
+        Wn *= eminj2pioN;
+    }
+
+#else 
+    // very, very slow
+    // This version of the direct DFT computation is slightly
+    // more accurate, increasingly so for longer transforms, 
+    // but it is so much slower (4-5x) that the small improvement
+    // in accuracy is probably not worth the extra wait. For
+    // short transforms, the accuracy of both algorithms is
+    // very high, and for long transforms, this algorithm is
+    // too slow.
+    //
+    // Both algorithms are retained here, so that this 
+    // tradeoff can be re-evaluated if necessary.
+
+    for ( int n = 0; n < N; ++n )
+    {
+        std::complex< double > Xkn = 0;
+        for ( int k = 0; k < N; ++k )
+        {
+            std::complex< double > Wkn = std::polar( 1.0, -2.0 * Pi * k * n / N );
+            Xkn += std::complex< double >( in[ 2*k ], in[ 2*k+1 ] ) * Wkn;
+        }
+        
+        out[ 2*n ] = Xkn.real();
+        out[ 2*n+1 ] = Xkn.imag();
+    }
+    
+#endif    
+}
+
+#endif  //  defined(SORRY_NO_FFTW)
+
+}	//	end of namespace Loris
diff --git a/src/loris/FourierTransform.h b/src/loris/FourierTransform.h
new file mode 100644
index 0000000..34867ee
--- /dev/null
+++ b/src/loris/FourierTransform.h
@@ -0,0 +1,223 @@
+#ifndef INCLUDE_FOURIERTRANSFORM_H
+#define INCLUDE_FOURIERTRANSFORM_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * FourierTransform.h
+ *
+ * Definition of class Loris::FourierTransform, providing a simplified
+ * uniform interface to the FFTW library (www.fftw.org), version 2.1.3
+ * or newer (including version 3), or to the General Purpose FFT package
+ * by Takuya OOURA, http://momonga.t.u-tokyo.ac.jp/~ooura/fft.html if
+ * FFTW is unavailable. 
+ *
+ * Kelly Fitz, 2 Jun 2006
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#include <complex>
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+//  insulating implementation class, defined in FourierTransform.C
+class FTimpl;
+
+// ---------------------------------------------------------------------------
+//	class FourierTransform
+//
+//! FourierTransform provides a simplified interface to the FFTW library 
+//! (www.fftw.org). Loris uses the FFTW library to perform efficient 
+//! Fourier transforms of arbitrary length. Clients store and access 
+//! the in-place transform data as a sequence of std::complex< double >.
+//! Samples are stored in the FourierTransform instance using subscript
+//! or iterator access, the transform is computed by the transform member,
+//! and the transformed samples replace the input samples, and are 
+//! accessed by subscript or iterator. FourierTransform computes a complex
+//! transform, so it can be used to invert a transform of real samples
+//! as well. Uses the standard library complex class, which implements
+//! arithmetic operations. 
+//!
+//! Supports FFTW versions 2 and 3.
+//! Does not make use of FFTW "wisdom" to speed up transform computation.
+//!
+//! If FFTW is unavailable, uses instead the General Purpose FFT package
+//! by Takuya OOURA, http://momonga.t.u-tokyo.ac.jp/~ooura/fft.html defined
+//! in fftsg.c for power-of-two transforms, and a very slow direct DFT
+//! implementation for non-PO2 transforms. 
+//
+class FourierTransform 
+{
+//	-- public interface --
+public:
+   
+    //! An unsigned integral type large enough
+    //! to represent the length of any transform.
+    typedef std::vector< std::complex< double > >::size_type size_type;
+
+    //! The type of a non-const iterator of (complex) transform samples.
+    typedef std::vector< std::complex< double > >::iterator iterator;
+
+    //! The type of a const iterator of (complex) transform samples.		
+    typedef std::vector< std::complex< double > >::const_iterator const_iterator;
+
+//	--- lifecycle ---
+
+    //! Initialize a new FourierTransform of the specified size.
+    //!
+    //! \param  len is the length of the transform in samples (the
+    //!         number of samples in the transform)
+    //! \throw  RuntimeError if the necessary buffers cannot be 
+    //!         allocated, or there is an error configuring FFTW.
+    FourierTransform( size_type len );
+
+    //! Initialize a new FourierTransform that is a copy of another,
+    //! having the same size and the same buffer contents.
+    //!
+    //! \param  rhs is the instance to copy
+    //! \throw  RuntimeError if the necessary buffers cannot be 
+    //!         allocated, or there is an error configuring FFTW.
+    FourierTransform( const FourierTransform & rhs );
+
+    //! Free the resources associated with this FourierTransform.
+    ~FourierTransform( void );	
+
+//	--- operators ---
+		
+    //! Make this FourierTransform a copy of another, having
+    //! the same size and buffer contents.
+    //!
+    //! \param  rhs is the instance to copy
+    //! \return a refernce to this instance
+    //! \throw  RuntimeError if the necessary buffers cannot be 
+    //!         allocated, or there is an error configuring FFTW.
+    FourierTransform & operator= ( const FourierTransform & rhs );
+
+
+//	--- access/mutation ---
+
+    //! Access (read/write) a transform sample by index.
+    //! Use this member to fill the transform buffer before
+    //! computing the transform, and to access the samples
+    //! after computing the transform. (inlined for speed)
+    //!
+    //! \param  index is the index or rank of the complex
+    //!         transform sample to access. Zero is the first
+    //!         position in the buffer.
+    //! \return non-const reference to the std::complex< double >
+    //!         at the specified position in the buffer.
+    std::complex< double > & operator[] ( size_type index )
+    { 
+        return _buffer[ index ]; 
+    }
+
+    //! Access (read-only) a transform sample by index.
+    //! Use this member to fill the transform buffer before
+    //! computing the transform, and to access the samples
+    //! after computing the transform. (inlined for speed)
+    //!
+    //! \param  index is the index or rank of the complex
+    //!         transform sample to access. Zero is the first
+    //!         position in the buffer.
+    //! \return const reference to the std::complex< double >
+    //!         at the specified position in the buffer.
+    const std::complex< double > & operator[] ( size_type index ) const
+    { 
+        return _buffer[ index ]; 
+    }
+
+    //! Return an iterator refering to the beginning of the sequence of
+    //! complex samples in the transform buffer.
+    //!
+    //! \return a non-const iterator refering to the first position
+    //!         in the transform buffer. 
+    iterator begin( void )	
+    { 
+        return _buffer.begin(); 
+    }
+	
+    //! Return an iterator refering to the end of the sequence of
+    //! complex samples in the transform buffer.
+    //!
+    //! \return a non-const iterator refering to one past the last 
+    //!         position in the transform buffer. 
+    iterator end( void )	
+    { 
+        return _buffer.end(); 
+    }
+
+    //! Return a const iterator refering to the beginning of the sequence of
+    //! complex samples in the transform buffer.
+    //!
+    //! \return a const iterator refering to the first position
+    //!         in the transform buffer. 
+    const_iterator begin( void ) const	
+    { 
+        return _buffer.begin(); 
+    }
+	
+    //! Return a const iterator refering to the end of the sequence of
+    //! complex samples in the transform buffer.
+    //!
+    //! \return a const iterator refering to one past the last 
+    //!         position in the transform buffer. 
+    const_iterator end( void ) const 	
+    { 
+        return _buffer.end(); 
+    }
+
+//	--- operations ---
+		
+    //! Compute the Fourier transform of the samples stored in the 
+    //! transform buffer. The samples stored in the transform buffer
+    //! (accessed by index or by iterator) are replaced by the 
+    //! transformed samples, in-place. 
+    void transform( void );
+
+//	--- inquiry ---
+
+    //! Return the length of the transform (in samples).
+    //! 
+    //! \return the length of the transform in samples.
+    size_type size( void ) const ;
+                
+//	-- instance variables --
+private:
+
+    //! buffer containing the complex transform input before
+    //! computing the transform, and the complex transform output
+    //! after computing the transform
+    std::vector< std::complex< double > > _buffer;
+
+    // insulating implementation instance (defined in 
+    // FourierTransform.C), conceals interface to FFTW
+    FTimpl * _impl;
+
+};	//	end of class FourierTransform
+
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_FOURIERTRANSFORM_H */
diff --git a/src/loris/FrequencyReference.C b/src/loris/FrequencyReference.C
new file mode 100644
index 0000000..3561e15
--- /dev/null
+++ b/src/loris/FrequencyReference.C
@@ -0,0 +1,293 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * FrequencyReference.C
+ *
+ * Implementation of class FrequencyReference.
+ *
+ * Kelly Fitz, 3 Dec 2001
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "FrequencyReference.h"
+
+#include "Breakpoint.h"
+#include "Fundamental.h"
+#include "LinearEnvelope.h"
+#include "Notifier.h"
+#include "Partial.h"
+#include "PartialList.h"
+#include "PartialUtils.h"
+
+#include <algorithm>
+#include <cmath>
+
+//	begin namespace
+namespace Loris {
+
+
+// ---------------------------------------------------------------------------
+//	createEstimator (static)
+// ---------------------------------------------------------------------------
+//  This class is now a wrapper providing the legacy interface to an improved
+//  and more flexible fundamental frequency estimator. This function 
+//  constructs and configures an instance of the new estimator that 
+//  provides the functionality of the older (Loris 1.4 through 1.5.2) 
+//  FrequencyReference class.
+//
+
+static const double Range = 50;
+static const double Ceiling = 20000;
+static const double Floor = -60;
+static const double Precision = 0.1;
+static const double Confidence = 0.9;
+static const double Interval = 0.01;
+
+FundamentalFromPartials createEstimator( void )
+{
+    FundamentalFromPartials eparts;
+    
+    eparts.setAmpFloor( Floor );
+    eparts.setAmpRange( Range );
+    eparts.setFreqCeiling( Ceiling );
+    eparts.setPrecision( Precision );
+    
+    return eparts;
+}
+
+// ---------------------------------------------------------------------------
+//	construction
+// ---------------------------------------------------------------------------
+//!	Construct a new fundamental FrequencyReference derived from the 
+//!	specified half-open (STL-style) range of Partials that lies
+//!	within the speficied average frequency range. Construct the 
+//!	reference envelope with approximately numSamps points.
+//!
+//! \param	begin The beginning of a range of Partials from which to
+//!			construct a frequency refence envelope.
+//! \param	end The end of a range of Partials from which to
+//!			construct a frequency refence envelope.
+//!	\param	minFreq The minimum expected fundamental frequency.
+//! \param	maxFreq The maximum expected fundamental frequency.
+//! \param	numSamps The approximate number of estimate of the 
+//!			fundamental frequency from which to construct the 
+//!			frequency reference envelope.
+//
+FrequencyReference::FrequencyReference( PartialList::const_iterator begin, 
+										PartialList::const_iterator end, 
+										double minFreq, double maxFreq,
+										long numSamps ) :
+	_env( new LinearEnvelope() )
+{
+	if ( numSamps < 1 )
+	{
+		Throw( InvalidArgument, "A frequency reference envelope must have a positive number of samples." );
+    }
+    
+	//	sanity:
+	if ( maxFreq < minFreq )
+	{
+		std::swap( minFreq, maxFreq );
+    }
+    
+#ifdef Loris_Debug
+	debugger << "Finding frequency reference envelope in range " <<
+	debugger << minFreq << " to " << maxFreq << " Hz, from " <<
+	debugger << std::distance(begin,end) << " Partials" << std::endl;
+#endif
+
+	
+	FundamentalFromPartials est = createEstimator();
+	std::pair< double, double > span = PartialUtils::timeSpan( begin, end );
+	double dt = ( span.second - span.first ) / ( numSamps + 1 );
+	*_env = est.buildEnvelope( begin, end, 
+                               span.first, span.second, dt,
+                               minFreq, maxFreq,
+                               Confidence );
+}
+
+// ---------------------------------------------------------------------------
+//	construction
+// ---------------------------------------------------------------------------
+//!	Construct a new fundamental FrequencyReference derived from the 
+//!	specified half-open (STL-style) range of Partials that lies
+//!	within the speficied average frequency range. Construct the 
+//!	reference envelope from fundamental estimates taken every
+//! five milliseconds.
+//!
+//! \param	begin The beginning of a range of Partials from which to
+//!			construct a frequency refence envelope.
+//! \param	end The end of a range of Partials from which to
+//!			construct a frequency refence envelope.
+//!	\param	minFreq The minimum expected fundamental frequency.
+//! \param	maxFreq The maximum expected fundamental frequency.
+//
+FrequencyReference::FrequencyReference( PartialList::const_iterator begin, 
+										PartialList::const_iterator end, 
+										double minFreq, double maxFreq ) :
+	_env( new LinearEnvelope() )
+{
+	//	sanity:
+	if ( maxFreq < minFreq )
+	{
+		std::swap( minFreq, maxFreq );
+	}
+	
+#ifdef Loris_Debug
+	debugger << "Finding frequency reference envelope in range " <<
+	debugger << minFreq << " to " << maxFreq << " Hz, from " <<
+	debugger << std::distance(begin,end) << " Partials" << std::endl;
+#endif
+    
+	FundamentalFromPartials est = createEstimator();
+	std::pair< double, double > span = PartialUtils::timeSpan( begin, end );
+	*_env = est.buildEnvelope( begin, end, 
+                               span.first, span.second, Interval,
+                               minFreq, maxFreq,
+                               Confidence );
+    
+}
+
+// ---------------------------------------------------------------------------
+//	copy construction
+// ---------------------------------------------------------------------------
+//
+FrequencyReference::FrequencyReference( const FrequencyReference & other ) :
+	_env( other._env->clone() )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	destruction
+// ---------------------------------------------------------------------------
+//
+FrequencyReference::~FrequencyReference()
+{
+}
+
+// ---------------------------------------------------------------------------
+//	assignment
+// ---------------------------------------------------------------------------
+//
+FrequencyReference &
+FrequencyReference::operator = ( const FrequencyReference & rhs )
+{
+	if ( &rhs != this )
+	{
+		_env.reset( rhs._env->clone() );
+	}
+	return *this;
+}
+
+// ---------------------------------------------------------------------------
+//	clone
+// ---------------------------------------------------------------------------
+//
+FrequencyReference * 
+FrequencyReference::clone( void ) const
+{
+	return new FrequencyReference( *this );
+}
+
+// ---------------------------------------------------------------------------
+//	valueAt
+// ---------------------------------------------------------------------------
+//
+double
+FrequencyReference::valueAt( double x ) const
+{
+	return _env->valueAt(x);
+}
+
+// ---------------------------------------------------------------------------
+//	envelope
+// ---------------------------------------------------------------------------
+//	Conversion to LinearEnvelope return a BreakpointEnvelope that 
+//	evaluates indentically to this FrequencyReference at all time.
+//
+LinearEnvelope 
+FrequencyReference::envelope( void ) const 
+{ 
+    return *_env; 
+}
+
+// ---------------------------------------------------------------------------
+//	timeOfPeakEnergy (static helper function)
+// ---------------------------------------------------------------------------
+//	Return the time at which the given Partial attains its
+//	maximum sinusoidal energy.
+//
+static double timeOfPeakEnergy( const Partial & p )
+{
+	Partial::const_iterator partialIter = p.begin();
+	double maxAmp = 
+		partialIter->amplitude() * std::sqrt( 1. - partialIter->bandwidth() );
+	double time = partialIter.time();
+	
+	for ( ++partialIter; partialIter != p.end(); ++partialIter ) 
+	{
+		double a = partialIter->amplitude() * 
+					std::sqrt( 1. - partialIter->bandwidth() );
+		if ( a > maxAmp ) 
+		{
+			maxAmp = a;
+			time = partialIter.time();
+		}
+	}			
+	
+	return time;
+}
+// ---------------------------------------------------------------------------
+//	IsInFrequencyRange
+// ---------------------------------------------------------------------------
+//	Function object for finding Partials that attain their maximum
+//	sinusoidal energy at a frequency within a specified range.
+//
+struct IsInFrequencyRange
+{
+	double minFreq, maxFreq;
+	IsInFrequencyRange( double min, double max ) :
+		minFreq( min ),
+		maxFreq( max )
+	{
+		//	sanity:
+		if ( maxFreq < minFreq )
+			std::swap( minFreq, maxFreq );
+	}
+	
+	bool operator() ( const Partial & p )
+	{
+		double compareFreq = p.frequencyAt( timeOfPeakEnergy( p ) );
+		return compareFreq >= minFreq  && compareFreq <= maxFreq;
+	}
+};
+
+				   
+
+}	//	end of namespace Loris
diff --git a/src/loris/FrequencyReference.h b/src/loris/FrequencyReference.h
new file mode 100644
index 0000000..366c57f
--- /dev/null
+++ b/src/loris/FrequencyReference.h
@@ -0,0 +1,132 @@
+#ifndef INCLUDE_FREQUENCYREFERENCE_H
+#define INCLUDE_FREQUENCYREFERENCE_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * FrequencyReference.h
+ *
+ * Definition of class FrequencyReference.
+ *
+ * Kelly Fitz, 3 Dec 2001
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "Envelope.h"
+#include "PartialList.h"
+#include <memory>
+
+//	begin namespace
+namespace Loris {
+
+class LinearEnvelope;
+
+// ---------------------------------------------------------------------------
+//	class FrequencyReference
+//
+//!	Class FrequencyReference represents a reference frequency envelope
+//!	derived from an estimate of the fundamental frequency of a given range 
+//! of Partials within in a specified frequency range. This reference envelope
+//!	can be used for channelizing the Partials in preparation for morphing
+//!	(see Channelizer.h).
+//!	
+//!	FrequencyReference implements the Envelope interface (see
+//!	Envelope.h).
+//
+class FrequencyReference : public Envelope
+{
+//	-- instance variables --
+	std::auto_ptr< LinearEnvelope > _env;
+	
+//	-- public interface --
+public:
+//	-- construction --
+
+	//!	Construct a new fundamental FrequencyReference derived from the 
+	//!	specified half-open (STL-style) range of Partials that lies
+	//!	within the speficied average frequency range. Construct the 
+	//!	reference envelope with approximately numSamps points.
+	//!
+	//! \param	begin The beginning of a range of Partials from which to
+	//!			construct a frequency refence envelope.
+	//! \param	end The end of a range of Partials from which to
+	//!			construct a frequency refence envelope.
+	//!	\param	minFreq The minimum expected fundamental frequency.
+	//! \param	maxFreq The maximum expected fundamental frequency.
+	//! \param	numSamps The approximate number of estimate of the 
+	//!			fundamental frequency from which to construct the 
+	//!			frequency reference envelope.
+	FrequencyReference( PartialList::const_iterator begin, 
+						PartialList::const_iterator end, 
+						double minFreq, double maxFreq, long numSamps );
+	 
+	//!	Construct a new fundamental FrequencyReference derived from the 
+	//!	specified half-open (STL-style) range of Partials that lies
+	//!	within the speficied average frequency range. Construct the 
+	//!	reference envelope from fundamental estimates taken every
+	//! five milliseconds.
+	//!
+	//! \param	begin The beginning of a range of Partials from which to
+	//!			construct a frequency refence envelope.
+	//! \param	end The end of a range of Partials from which to
+	//!			construct a frequency refence envelope.
+	//!	\param	minFreq The minimum expected fundamental frequency.
+	//! \param	maxFreq The maximum expected fundamental frequency.
+	FrequencyReference( PartialList::const_iterator begin, 
+						PartialList::const_iterator end, 
+						double minFreq, double maxFreq );
+
+	 
+	//!	Construct a new FrequencyReference that is an exact copy of the
+	//!	specified FrequencyReference.
+	FrequencyReference( const FrequencyReference & other );
+	 
+	//!	Assignment operator: make this FrequencyReference an exact copy 
+	//! of the specified FrequencyReference.
+	FrequencyReference & operator= ( const FrequencyReference & other );
+	 
+	//! Destroy this FrequencyReference.
+	~FrequencyReference();
+	 
+//	-- conversion to LinearEnvelope --
+
+    //!	Return a LinearEnvelope that evaluates indentically to this
+	//!	FrequencyReference at all time.
+	LinearEnvelope envelope( void ) const;
+     
+//	-- Envelope interface --
+
+	//!	Return an exact copy of this FrequencyReference (following the
+	//!	Prototype pattern).
+	virtual FrequencyReference * clone( void ) const;
+	
+	//!	Return the frequency value (in Hz) of this FrequencyReference at the
+	//!	specified time.
+	virtual double valueAt( double x ) const;	
+
+};	// end of class FrequencyReference
+
+}	//	end of namespace Loris
+
+#endif	// ndef INCLUDE_FREQUENCYREFERENCE_H
diff --git a/src/loris/Fundamental.C b/src/loris/Fundamental.C
new file mode 100644
index 0000000..cddb226
--- /dev/null
+++ b/src/loris/Fundamental.C
@@ -0,0 +1,712 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Fundamental.C
+ *
+ * Definition of classes for computing an estimate of time-varying
+ * fundamental frequency from either a sequence of samples or a
+ * collection of Partials using a frequency domain maximum likelihood 
+ * algorithm adapted from Quatieri's speech signal processing textbook. 
+ *
+ * Kelly Fitz, 25 March 2008
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "Fundamental.h"
+
+#include "LorisExceptions.h"
+#include "KaiserWindow.h"
+#include "LinearEnvelope.h"
+#include "Notifier.h"
+#include "PartialUtils.h"
+#include "ReassignedSpectrum.h"
+#include "SpectralPeakSelector.h"
+
+#include "F0Estimate.h" 
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
+using namespace std;
+
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+	const double Pi = M_PI;
+#else
+	const double Pi = 3.14159265358979324;
+#endif
+
+//	begin namespace
+namespace Loris {
+
+
+
+#define VERIFY_ARG(func, test)											\
+	do {																\
+		if (!(test)) 													\
+			Throw( Loris::InvalidArgument, #func ": " #test  );			\
+	} while (false)
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//  FundamentalEstimator members
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+
+//  -- lifecycle --
+
+// ---------------------------------------------------------------------------
+//  constructor (protected)
+// ---------------------------------------------------------------------------
+//! Construct a new estimator with specified precision and
+//! other parameters given default values.
+//!
+//! The specified precision is used to terminate the iterative
+//! estimation procedure. 
+//!
+//! \param precisionHz is the precision in Hz with which the 
+//! fundamental estimates will be made.
+
+FundamentalEstimator::FundamentalEstimator( double precisionHz ) :
+    m_precision( precisionHz ),
+    m_ampFloor( DefaultAmpFloor ),
+    m_ampRange( DefaultAmpRange ),
+    m_freqCeiling( DefaultFreqCeiling )
+{
+	VERIFY_ARG( FundamentalEstimator, precisionHz > 0 );
+}
+
+// ---------------------------------------------------------------------------
+//  destructor
+// ---------------------------------------------------------------------------
+    
+FundamentalEstimator::~FundamentalEstimator( void )
+{
+}
+
+//  -- spectral analysis parameter access --
+
+// ---------------------------------------------------------------------------
+//	ampFloor
+// ---------------------------------------------------------------------------
+//! Return the absolute amplitude threshold in (negative) dB, 
+//! below which spectral peaks will not be considered in the 
+//! estimation of the fundamental (default is 30 dB).            
+double 
+FundamentalEstimator::ampFloor( void ) const
+{ 
+    return m_ampFloor; 
+}
+
+// ---------------------------------------------------------------------------
+//	ampRange
+// ---------------------------------------------------------------------------
+//!	Return the amplitude range in dB, 
+//! relative to strongest peak in a frame, floating
+//! amplitude threshold below which spectral
+//! peaks will not be considered in the estimation of 
+//! the fundamental (default is 30 dB).			
+//
+double 
+FundamentalEstimator::ampRange( void ) const 
+{ 
+    return m_ampRange; 
+}
+
+// ---------------------------------------------------------------------------
+//	freqCeiling
+// ---------------------------------------------------------------------------
+//!	Return the frequency ceiling in Hz, the
+//! frequency threshold above which spectral
+//! peaks will not be considered in the estimation of 
+//! the fundamental (default is 10 kHz).			
+//
+double 
+FundamentalEstimator::freqCeiling( void ) const 
+{ 
+    return m_freqCeiling; 
+}
+
+// ---------------------------------------------------------------------------
+//	precision
+// ---------------------------------------------------------------------------
+//!	Return the precision of the estimate in Hz, the
+//! fundamental frequency will be estimated to 
+//! within this range (default is 0.1 Hz).
+//
+double 
+FundamentalEstimator::precision( void ) const 
+{ 
+    return m_precision; 
+}
+
+                       
+//  -- spectral analysis parameter mutation --
+
+// ---------------------------------------------------------------------------
+//	setAmpFloor
+// ---------------------------------------------------------------------------
+//! Set the absolute amplitude threshold in (negative) dB, 
+//! below which spectral peaks will not be considered in the 
+//! estimation of the fundamental (default is 30 dB).            
+//! 
+//! \param x is the new value of this parameter.            
+void 
+FundamentalEstimator::setAmpFloor( double x )
+{ 
+	VERIFY_ARG( setAmpFloor, x < 0 );
+    m_ampFloor = x; 
+}
+
+// ---------------------------------------------------------------------------
+//	setAmpRange
+// ---------------------------------------------------------------------------
+//!	Set the amplitude range in dB, 
+//! relative to strongest peak in a frame, floating
+//! amplitude threshold (negative) below which spectral
+//! peaks will not be considered in the estimation of 
+//! the fundamental (default is 30 dB).	
+//!	
+//!	\param x is the new value of this parameter. 				
+//
+void 
+FundamentalEstimator::setAmpRange( double x ) 
+{ 
+	VERIFY_ARG( setAmpRange, x > 0 );
+    m_ampRange = x; 
+}
+
+// ---------------------------------------------------------------------------
+//	setFreqCeiling
+// ---------------------------------------------------------------------------
+//!	Set the frequency ceiling in Hz, the
+//! frequency threshold above which spectral
+//! peaks will not be considered in the estimation of 
+//! the fundamental (default is 10 kHz). Must be
+//! greater than the lower bound.
+//!	
+//!	\param x is the new value of this parameter. 				
+//
+void 
+FundamentalEstimator::setFreqCeiling( double x ) 
+{ 
+    m_freqCeiling = x; 
+}
+
+// ---------------------------------------------------------------------------
+//	setPrecision
+// ---------------------------------------------------------------------------
+//!	Set the precision of the estimate in Hz, the
+//! fundamental frequency will be estimated to 
+//! within this range (default is 0.1 Hz).
+//!	
+//!	\param x is the new value of this parameter. 				
+//
+void 
+FundamentalEstimator::setPrecision( double x ) 
+{ 
+	VERIFY_ARG( setPrecision, x > 0 );
+    m_precision = x; 
+}
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//  FundamentalFromSamples members
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+//  -- lifecycle --
+
+// ---------------------------------------------------------------------------
+//  constructor
+// ---------------------------------------------------------------------------
+//! Construct a new estimator configured with the given  
+//! analysis window width (main lobe, zero-to-zero). All other 
+//! spectrum analysis parameters are computed from the specified 
+//! window width. 
+//!
+//! The specified precision is used to terminate the iterative
+//! estimation procedure. If unspecified, the default value,
+//! DefaultPrecisionOver100 * 100 is used. 
+//! 
+//! \param windowWidthHz is the main lobe width of the Kaiser
+//! analysis window in Hz.
+//!
+//! \param precisionHz is the precision in Hz with which the 
+//! fundamental estimates will be made.
+
+FundamentalFromSamples::FundamentalFromSamples( double winWidthHz, 
+                                                double precisionHz ) :
+    m_cacheSampleRate( 0 ),
+    m_windowWidth( winWidthHz ), 
+    FundamentalEstimator( precisionHz )
+{
+	VERIFY_ARG( FundamentalFromSamples, winWidthHz > 0 );
+}
+
+// ---------------------------------------------------------------------------
+//  destructor
+// ---------------------------------------------------------------------------
+    
+FundamentalFromSamples::~FundamentalFromSamples( void )
+{
+}
+
+//  -- fundamental frequency estimation --
+
+
+
+// ---------------------------------------------------------------------------
+//  buildEnvelope
+// ---------------------------------------------------------------------------
+//! Construct a linear envelope from fundamental frequency 
+//! estimates taken at the specified interval in seconds.
+//! 
+
+LinearEnvelope 
+FundamentalFromSamples::buildEnvelope( const double * sampsBeg, 
+                                       const double * sampsEnd, 
+                                       double sampleRate, 
+                                       double tbeg, double tend, 
+                                       double interval,
+                                       double lowerFreqBound, double upperFreqBound, 
+                                       double confidenceThreshold )
+{
+    //  sanity check
+    if ( tbeg > tend )
+    {
+        std::swap( tbeg, tend );
+    }
+
+    LinearEnvelope env;
+    
+    std::vector< double > amplitudes, frequencies;
+
+    double time = tbeg;
+    while ( time < tend )
+    {
+        collectFreqsAndAmps( sampsBeg, sampsEnd-sampsBeg, sampleRate,
+                             frequencies, amplitudes, time );
+        if ( ! amplitudes.empty() )
+        {
+            F0Estimate est( amplitudes, frequencies, lowerFreqBound, upperFreqBound, 
+                            m_precision );
+
+            if ( est.confidence() >= confidenceThreshold )
+            {   
+                env.insert( time, est.frequency() );
+            }
+        }
+        
+        time += interval;
+    }
+    
+    return env;            
+}                                       
+                             
+                             
+// ---------------------------------------------------------------------------
+//  estimateAt
+// ---------------------------------------------------------------------------
+//! Return an estimate of the fundamental frequency computed 
+//! at the specified time. 
+
+FundamentalFromSamples::value_type 
+FundamentalFromSamples::estimateAt( const double * sampsBeg, 
+                                    const double * sampsEnd, 
+                                    double sampleRate, 
+                                    double time,
+                                    double lowerFreqBound, double upperFreqBound )
+{
+    std::vector< double > amplitudes, frequencies;
+    
+    collectFreqsAndAmps( sampsBeg, sampsEnd-sampsBeg, sampleRate,
+                         frequencies, amplitudes, time );
+                         
+    F0Estimate est( amplitudes, frequencies, lowerFreqBound, upperFreqBound, m_precision );
+
+    return est;
+}                                    
+
+//  -- spectral analysis parameter access/mutation --
+
+// ---------------------------------------------------------------------------
+//  windowWidth
+// ---------------------------------------------------------------------------
+//! Return the frequency-domain main lobe width (in Hz) (measured between 
+//! zero-crossings) of the analysis window used in spectral
+//! analysis.               
+double FundamentalFromSamples::windowWidth( void ) const
+{
+    return m_windowWidth;
+}
+
+// ---------------------------------------------------------------------------
+//  setWindowWidth
+// ---------------------------------------------------------------------------
+//! Set the frequency-domain main lobe width (in Hz) (measured between 
+//! zero-crossings) of the analysis window used in spectral
+//! analysis.   
+//! 
+//! \param x is the new value of this parameter.            
+void FundamentalFromSamples::setWindowWidth( double x )
+{
+	VERIFY_ARG( setWindowWidth, x > 0 );
+    m_windowWidth = x; 
+}
+
+
+
+//  -- private auxiliary functions --
+
+// ---------------------------------------------------------------------------
+//  buildSpectrumAnalyzer
+// ---------------------------------------------------------------------------
+//! Construct the ReassignedSpectrum that will be used to perform
+//! spectral analysis from which peak frequencies and amplitudes 
+//! will be drawn. This construction is performed in a lazy fashion,
+//! and needs to be done again when certain of the parameters change.
+//!
+//! The spectrum analyzer cannot be constructed without knowledge of
+//! the sample rate, specified in Hz, which is needed to determine the
+//! parameters of the analysis window. (The sample rate is cached in
+//! this class in order that it be possible to determine whether the
+//! spectrum analyzer can be reused from one estimate to another.)
+//
+void 
+FundamentalFromSamples::buildSpectrumAnalyzer( double srate )
+{
+ 	//	configure the reassigned spectral analyzer, 
+    //	always use odd-length windows:
+    const double sidelobeLevel = - m_ampFloor; // amp floor is negative
+    double winshape = KaiserWindow::computeShape( sidelobeLevel );
+    long winlen = KaiserWindow::computeLength( m_windowWidth / srate, winshape );    
+    if ( 1 != (winlen % 2) ) 
+    {
+        ++winlen;
+    }
+    
+    std::vector< double > window( winlen );
+    KaiserWindow::buildWindow( window, winshape );
+    
+    std::vector< double > windowDeriv( winlen );
+    KaiserWindow::buildTimeDerivativeWindow( windowDeriv, winshape );
+   
+    m_spectrum.reset( new ReassignedSpectrum( window, windowDeriv ) );    
+    
+    //  remember the sample rate used to build this spectrum
+    //  analyzer:
+    m_cacheSampleRate = srate;
+}
+
+// ---------------------------------------------------------------------------
+//	sort_peaks_greater_amplitude
+// ---------------------------------------------------------------------------
+//	predicate used for sorting peaks in order of decreasing amplitude:
+static bool sort_peaks_greater_amplitude( const SpectralPeak & lhs, 
+										  const SpectralPeak & rhs )
+{ 
+	return lhs.amplitude() > rhs.amplitude(); 
+}
+
+// ---------------------------------------------------------------------------
+//  collectFreqsAndAmps
+// ---------------------------------------------------------------------------
+//! Perform spectral analysis on a sequence of samples, using
+//! an analysis window centered at the specified time in seconds.
+//! Collect the frequencies and amplitudes of the peaks and return
+//! them in the vectors provided. 
+//
+   
+void 
+FundamentalFromSamples::collectFreqsAndAmps( const double * samps,
+                                             unsigned long nsamps,
+                                             double sampleRate,
+                                             std::vector< double > & frequencies, 
+                                             std::vector< double > & amplitudes,
+                                             double time )
+{
+    amplitudes.clear();
+    frequencies.clear();
+
+    //  build the spectrum analyzer if necessary:
+    if ( m_cacheSampleRate != sampleRate ||
+         0 == m_spectrum.get() )
+    {
+        buildSpectrumAnalyzer( sampleRate );
+    }
+    
+    
+    //	configure the peak selection and partial formation policies:    
+    unsigned long winlen = m_spectrum->window().size();
+    const double maxTimeCorrection = 0.25 * winlen / sampleRate;   //  one-quarter the window width
+    SpectralPeakSelector selector( sampleRate, maxTimeCorrection );  
+ 	
+    
+     
+    //	compute reassigned spectrum:
+    //  sampsBegin is the position of the first sample to be transformed,
+    //	sampsEnd is the position after the last sample to be transformed.
+    //	(these computations work for odd length windows only)
+    unsigned long winMiddle = (unsigned long)( sampleRate * time );
+    unsigned long sampsBegin = std::max( long(winMiddle) - long(winlen / 2), 0L );
+    unsigned long sampsEnd = std::min( winMiddle + (winlen / 2) + 1, nsamps );
+    
+    if ( winMiddle < sampsEnd )
+    {
+        m_spectrum->transform( samps + sampsBegin, samps + winMiddle, samps + sampsEnd );
+                     
+        //	extract peaks from the spectrum, no fading:
+        Peaks peaks = selector.selectPeaks( *m_spectrum ); 
+        
+        if ( ! peaks.empty() )
+        {
+            //  sort the peaks in order of decreasing amplitude
+            //
+            //  (HEY is there any reason to do this, other than to find the largest?)
+            //std::sort( peaks.begin(), peaks.end(), sort_peaks_greater_amplitude );
+            Peaks::iterator maxpos = std::max_element( peaks.begin(), peaks.end(), sort_peaks_greater_amplitude );
+            
+            //  determine the floating amplitude threshold
+            const double thresh = 
+                std::max( std::pow( 10.0, - 0.05 * - m_ampFloor ), 
+                          std::pow( 10.0, - 0.05 * m_ampRange ) * maxpos->amplitude() );
+                        
+            //  collect amplitudes and frequencies and try to 
+            //  estimate the fundamental
+            for ( Peaks::const_iterator spkpos = peaks.begin(); spkpos != peaks.end(); ++spkpos )
+            {
+                if ( spkpos->amplitude() > thresh &&
+                     spkpos->frequency() < m_freqCeiling )
+                {
+                    amplitudes.push_back( spkpos->amplitude() );
+                    frequencies.push_back( spkpos->frequency() );
+                }
+            }
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//  FundamentalFromPartials members
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+//  constructor
+// ---------------------------------------------------------------------------
+//! Construct a new estimator configured with the given precision.
+//! The specified precision is used to terminate the iterative
+//! estimation procedure. If unspecified, the default value,
+//! DefaultPrecisionOver100 * 100 is used. 
+//!
+//! \param precisionHz is the precision in Hz with which the 
+//! fundamental estimates will be made.
+
+FundamentalFromPartials::FundamentalFromPartials( double precisionHz ) :
+    FundamentalEstimator( precisionHz )
+{
+}
+
+// ---------------------------------------------------------------------------
+//  copy constructor
+// ---------------------------------------------------------------------------
+//! Construct a copy of an estimator. Nothing much to do since this class
+//! has no data members.
+//
+
+FundamentalFromPartials::FundamentalFromPartials( const FundamentalFromPartials & rhs ) :
+    FundamentalEstimator( rhs )
+{
+}
+
+// ---------------------------------------------------------------------------
+//  destructor
+// ---------------------------------------------------------------------------
+    
+FundamentalFromPartials::~FundamentalFromPartials( void )
+{
+}
+
+// ---------------------------------------------------------------------------
+//  assignment
+// ---------------------------------------------------------------------------
+//! Pass the assignment opertion up to the base class.
+//
+
+FundamentalFromPartials &
+FundamentalFromPartials::operator=( const FundamentalFromPartials & rhs )
+{
+    FundamentalEstimator::operator=( rhs );
+    
+    return *this;
+}
+
+//  -- fundamental frequency estimation --
+
+// ---------------------------------------------------------------------------
+//  buildEnvelope
+// ---------------------------------------------------------------------------
+//! Construct a linear envelope from fundamental frequency 
+//! estimates taken at the specified interval in seconds.
+//! 
+
+LinearEnvelope 
+FundamentalFromPartials::buildEnvelope( PartialList::const_iterator begin_partials, 
+                                        PartialList::const_iterator end_partials,
+                                        double tbeg, double tend, 
+                                        double interval,
+                                        double lowerFreqBound, double upperFreqBound, 
+                                        double confidenceThreshold )
+{
+    //  sanity check
+    if ( tbeg > tend )
+    {
+        std::swap( tbeg, tend );
+    }
+
+    LinearEnvelope env;
+    
+    std::vector< double > amplitudes, frequencies;
+
+    double time = tbeg;
+    while ( time < tend )
+    {
+        collectFreqsAndAmps( begin_partials, end_partials, frequencies, amplitudes, time );
+                  
+        if (! amplitudes.empty() )
+        {
+            F0Estimate est( amplitudes, frequencies, lowerFreqBound, upperFreqBound, 
+                            m_precision );
+        
+            if ( est.confidence() >= confidenceThreshold )
+            {   
+                env.insert( time, est.frequency() );
+            }
+        }
+        
+        time += interval;
+    }
+    
+    return env;            
+}                         
+
+// ---------------------------------------------------------------------------
+//  estimateAt
+// ---------------------------------------------------------------------------
+//! Return an estimate of the fundamental frequency computed 
+//! at the specified time. 
+
+FundamentalFromPartials::value_type 
+FundamentalFromPartials::estimateAt( PartialList::const_iterator begin_partials, 
+                                     PartialList::const_iterator end_partials,
+                                     double time,
+                                     double lowerFreqBound, double upperFreqBound )
+{
+    std::vector< double > amplitudes, frequencies;
+    
+    collectFreqsAndAmps( begin_partials, end_partials, frequencies, amplitudes, time );
+                         
+    F0Estimate est( amplitudes, frequencies, lowerFreqBound, upperFreqBound, m_precision );
+
+    return est;
+}  
+
+
+//  -- private auxiliary functions --
+
+// ---------------------------------------------------------------------------
+//  collectFreqsAndAmps
+// ---------------------------------------------------------------------------
+//! Perform spectral analysis on a sequence of samples, using
+//! an analysis window centered at the specified time in seconds.
+//! Collect the frequencies and amplitudes of the peaks and return
+//! them in the vectors provided. 
+//
+   
+void 
+FundamentalFromPartials::collectFreqsAndAmps( PartialList::const_iterator begin_partials, 
+                                              PartialList::const_iterator end_partials,
+                                              std::vector< double > & frequencies, 
+                                              std::vector< double > & amplitudes,
+                                              double time )
+{
+    amplitudes.clear();
+    frequencies.clear();
+    
+    if ( begin_partials != end_partials )
+    {            
+        //  determine the absolute amplitude threshold 
+        double thresh = std::pow( 10.0, - 0.05 * - m_ampFloor );
+        
+        double max_amp = 0;        
+        for ( PartialList::const_iterator it = begin_partials; it != end_partials; ++it )
+        {
+            //  compute the sinusoidal amplitude (without bandwidth energy)
+            double sine_amp = std::sqrt(1 - it->bandwidthAt( time )) * it->amplitudeAt( time );        
+            double freq = it->frequencyAt( time );
+            
+            if ( sine_amp > thresh &&
+                 freq < m_freqCeiling )
+            {
+                amplitudes.push_back( sine_amp );
+                frequencies.push_back( freq );
+            }
+            
+            max_amp = std::max( sine_amp, max_amp );                        
+        }
+        
+        //  remove quietest ones - this isn't very efficient, 
+        //  but it is much faster than making two passes (and 
+        //  computing two sequences of sinusoidal amplitudes).
+        thresh = std::pow( 10.0, - 0.05 * m_ampRange ) * max_amp;
+        vector< double >::size_type N = amplitudes.size();
+        vector< double >::size_type k = 0;
+        while ( k < N )
+        {
+            if ( amplitudes[k] < thresh )
+            {
+                amplitudes.erase( amplitudes.begin() + k );
+                frequencies.erase( frequencies.begin() + k );
+                --N;
+            }
+            else
+            {
+                ++k;
+            }
+        }
+    }
+    
+}
+
+}   //  end of namespace Loris
diff --git a/src/loris/Fundamental.h b/src/loris/Fundamental.h
new file mode 100644
index 0000000..5971408
--- /dev/null
+++ b/src/loris/Fundamental.h
@@ -0,0 +1,737 @@
+#ifndef INCLUDE_FUNDAMENTAL_H
+#define INCLUDE_FUNDAMENTAL_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Fundamental.h
+ *
+ * Definition of classes for computing an estimate of time-varying
+ * fundamental frequency from either a sequence of samples or a
+ * collection of Partials using a frequency domain maximum likelihood 
+ * algorithm adapted from Quatieri's speech signal processing textbook. 
+ *
+ * Kelly Fitz, 25 March 2008
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "LinearEnvelope.h"
+#include "PartialList.h"
+#include "F0Estimate.h" 
+
+#include <memory>
+#include <vector>
+
+//  begin namespace
+namespace Loris {
+
+class ReassignedSpectrum;
+
+// ---------------------------------------------------------------------------
+//  class FundamentalEstimator
+//
+//! Base class for fundamental estimation, common storage for member
+//! variable parameters, type definitions, and constants.
+
+class FundamentalEstimator
+{
+public:
+
+//  -- types --
+
+    typedef F0Estimate value_type;
+
+//  -- constants --    
+
+    enum {
+    
+        DefaultAmpFloor = -60,          //! the default absolute amplitude threshold in dB
+        
+        DefaultAmpRange = 30,           //! the default floating amplitude threshold in dB
+    
+        DefaultFreqCeiling = 4000,      //! the default frequency threshold in Hz
+    
+        DefaultPrecisionOver100 = 10,   //! the default frequency precision in 1/100 Hz
+
+        DefaultMinConfidencePct = 90    //! the default required percent confidence to
+                                        //! return an estimate (100 is absolute confidence)
+    };
+    
+
+//  -- lifecycle --
+
+protected:
+
+    //! Construct a new estimator with specified precision and
+    //! other parameters given default values.
+    //!
+    //! The specified precision is used to terminate the iterative
+    //! estimation procedure. 
+    //!
+    //! \param precisionHz is the precision in Hz with which the 
+    //! fundamental estimates will be made.
+    FundamentalEstimator( double precisionHz );
+                                                        
+public: 
+
+    //! Destructor    
+    virtual ~FundamentalEstimator( void );    
+
+
+    //  compiler-generated copy and assignment are OK
+
+  
+//  -- parameter access --
+
+    //! Return the absolute amplitude threshold in (negative) dB, 
+    //! below which spectral peaks will not be considered in the 
+    //! estimation of the fundamental (default is 30 dB).            
+    double ampFloor( void ) const;
+
+    //!	Return the amplitude range in dB, 
+    //! relative to strongest peak in a frame, floating
+    //! amplitude threshold (negative) below which spectral
+    //! peaks will not be considered in the estimation of 
+    //! the fundamental (default is 30 dB).	
+    double ampRange( void ) const;
+
+    //! Return the frequency ceiling in Hz, the
+    //! frequency threshold above which spectral
+    //! peaks will not be considered in the estimation of 
+    //! the fundamental (default is 10 kHz).            
+    double freqCeiling( void ) const;
+
+    //! Return the precision of the estimate in Hz, the
+    //! fundamental frequency will be estimated to 
+    //! within this range (default is 0.1 Hz).
+    double precision( void ) const;
+     
+//  -- parameter mutation --
+
+    //! Set the absolute amplitude threshold in (negative) dB, 
+    //! below which spectral peaks will not be considered in the 
+    //! estimation of the fundamental (default is 30 dB).            
+    //! 
+    //! \param x is the new value of this parameter.            
+    void setAmpFloor( double x );
+
+    //!	Set the amplitude range in dB, 
+    //! relative to strongest peak in a frame, floating
+    //! amplitude threshold (negative) below which spectral
+    //! peaks will not be considered in the estimation of 
+    //! the fundamental (default is 30 dB).	
+    //! 
+    //! \param x is the new value of this parameter.            
+    void setAmpRange( double x );
+
+    //! Set the frequency ceiling in Hz, the
+    //! frequency threshold above which spectral
+    //! peaks will not be considered in the estimation of 
+    //! the fundamental (default is 10 kHz). Must be
+    //! greater than the lower bound.
+    //! 
+    //! \param x is the new value of this parameter.            
+    void setFreqCeiling( double x );
+
+    //! Set the precision of the estimate in Hz, the
+    //! fundamental frequency will be estimated to 
+    //! within this range (default is 0.1 Hz).
+    //! 
+    //! \param x is the new value of this parameter.            
+    void setPrecision( double x );
+
+
+protected:
+
+//  -- parameter member variables --
+
+
+    double m_precision;         //! in Hz, fundamental frequency will be estimated to 
+                                //! within this range (default is 0.1 Hz)
+                                
+    double m_ampFloor;          //! absolute amplitude threshold below which spectral
+                                //! peaks will not be considered in the estimation of 
+                                //! the fundamental (default is equivalent to 60 dB
+                                //! quieter than a full scale sinusoid)
+    
+    double m_ampRange;          //! floating amplitude threshold relative to the peak
+                                //! having the largest magnitude below which spectral
+                                //! peaks will not be considered in the estimation of 
+                                //! the fundamental (default is equivalent to 30 dB)
+        
+    double m_freqCeiling;       //! in Hz, frequency threshold above which spectral
+                                //! peaks will not be considered in the estimation of 
+                                //! the fundamental (default is 10 kHz)      
+
+
+};  //  end of base class FundamentalEstimator
+
+
+
+// ---------------------------------------------------------------------------
+//  class FundamentalFromSamples
+//
+//! Class FundamentalFromSamples represents an algorithm for 
+//! time-varying fundamental frequency estimation based on
+//! time-frequency reassigned spectral analysis of a sequence
+//! of samples. This class is adapted from the Analyzer class 
+//! (see Analyzer.h), and performs the same spectral analysis 
+//! and peak extraction, but does not form Partials.
+//! 
+//! For more information about Reassigned Bandwidth-Enhanced 
+//! Analysis and the Reassigned Bandwidth-Enhanced Additive Sound 
+//! Model, refer to the Loris website: www.cerlsoundgroup.org/Loris/.
+//
+class FundamentalFromSamples : public FundamentalEstimator
+{
+//  -- public interface --
+
+public:
+
+//  -- lifecycle --
+
+    //! Construct a new estimator configured with the given  
+    //! analysis window width (main lobe, zero-to-zero). All other 
+    //! spectrum analysis parameters are computed from the specified 
+    //! window width. 
+    //!
+    //! The specified precision is used to terminate the iterative
+    //! estimation procedure. If unspecified, the default value,
+    //! DefaultPrecisionOver100 * 100 is used. 
+    //! 
+    //! \param  windowWidthHz is the main lobe width of the Kaiser
+    //!         analysis window in Hz.
+    //!
+    //! \param  precisionHz is the precision in Hz with which the 
+    //!         fundamental estimates will be made.    
+    FundamentalFromSamples( double winWidthHz, 
+                            double precisionHz = DefaultPrecisionOver100 * 0.01 );
+                            
+                            
+
+    //! Destructor    
+    ~FundamentalFromSamples( void );
+
+//  -- fundamental frequency estimation --
+
+    //  buildEnvelope
+    //
+    //! Construct a linear envelope from fundamental frequency 
+    //! estimates taken at the specified interval in seconds
+    //! starting at tbeg (seconds) and ending before tend (seconds).
+    //! 
+    //! \param  samps is the beginning of a sequence of samples
+    //! \param  sampsEnd is the end of the sequence of samples
+    //! \param  sampleRate is the sampling rate (in Hz) associated
+    //!         with the sequence of samples (used to compute frequencies
+    //!         in Hz, and to convert the time from seconds to samples)
+    //! \param  tbeg is the beginning of the time interval (in seconds)
+    //! \param  tend is the end of the time interval (in seconds)
+    //! \param  interval is the time between breakpoints in the
+    //!         fundamental frequency envelope (in seconds)
+    //! \param  lowerFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  upperFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  confidenceThreshold is the minimum confidence level
+    //!         resuired for a fundamental frequency estimate to be
+    //!         added to the envelope. Lower confidence estimates are
+    //!         not added, the envelope returned will not contain
+    //!         breakpoints at times associated with low confidence 
+    //!         estimates
+    //! \return a LinearEnvelope composed of breakpoints corresponding to
+    //!         the fundamental frequency estimates at samples of the span
+    //!         tbeg to tend at the specified sampling interval, only estimates
+    //!         having confidence level exceeding the specified confidence
+    //!         threshold are added to the envelope    
+    LinearEnvelope buildEnvelope( const double * sampsBeg, 
+                                  const double * sampsEnd, 
+                                  double sampleRate, 
+                                  double tbeg, double tend, 
+                                  double interval,
+                                  double lowerFreqBound, double upperFreqBound, 
+                                  double confidenceThreshold );
+                                 
+    //  buildEnvelope
+    //
+    //! Construct a linear envelope from fundamental frequency 
+    //! estimates taken at the specified interval in seconds
+    //! starting at tbeg (seconds) and ending before tend (seconds).
+    //! 
+    //! \param  samps is the beginning of a sequence of samples
+    //! \param  nsamps is the length of the sequence of samples
+    //! \param  sampleRate is the sampling rate (in Hz) associated
+    //!         with the sequence of samples (used to compute frequencies
+    //!         in Hz, and to convert the time from seconds to samples)
+    //! \param  tbeg is the beginning of the time interval (in seconds)
+    //! \param  tend is the end of the time interval (in seconds)
+    //! \param  interval is the time between breakpoints in the
+    //!         fundamental frequency envelope (in seconds)
+    //! \param  lowerFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  upperFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  confidenceThreshold is the minimum confidence level
+    //!         resuired for a fundamental frequency estimate to be
+    //!         added to the envelope. Lower confidence estimates are
+    //!         not added, the envelope returned will not contain
+    //!         breakpoints at times associated with low confidence 
+    //!         estimates
+    //! \return a LinearEnvelope composed of breakpoints corresponding to
+    //!         the fundamental frequency estimates at samples of the span
+    //!         tbeg to tend at the specified sampling interval, only estimates
+    //!         having confidence level exceeding the specified confidence
+    //!         threshold are added to the envelope    
+    LinearEnvelope buildEnvelope( const double * sampsBeg, 
+                                  unsigned long nsamps,
+                                  double sampleRate, 
+                                  double tbeg, double tend, 
+                                  double interval,
+                                  double lowerFreqBound, double upperFreqBound, 
+                                  double confidenceThreshold )
+    {
+        return buildEnvelope( sampsBeg, sampsBeg + nsamps, sampleRate, 
+                              tbeg, tend, interval, 
+                              lowerFreqBound, upperFreqBound,
+                              confidenceThreshold );
+    }
+
+
+    //  buildEnvelope
+    //
+    //! Construct a linear envelope from fundamental frequency 
+    //! estimates taken at the specified interval in seconds
+    //! starting at tbeg (seconds) and ending before tend (seconds).
+    //! 
+    //! \param  samps is the sequence of samples
+    //! \param  sampleRate is the sampling rate (in Hz) associated
+    //!         with the sequence of samples (used to compute frequencies
+    //!         in Hz, and to convert the time from seconds to samples)
+    //! \param  tbeg is the beginning of the time interval (in seconds)
+    //! \param  tend is the end of the time interval (in seconds)
+    //! \param  interval is the time between breakpoints in the
+    //!         fundamental frequency envelope (in seconds)
+    //! \param  lowerFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  upperFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  confidenceThreshold is the minimum confidence level
+    //!         resuired for a fundamental frequency estimate to be
+    //!         added to the envelope. Lower confidence estimates are
+    //!         not added, the envelope returned will not contain
+    //!         breakpoints at times associated with low confidence 
+    //!         estimates
+    //! \return a LinearEnvelope composed of breakpoints corresponding to
+    //!         the fundamental frequency estimates at samples of the span
+    //!         tbeg to tend at the specified sampling interval, only estimates
+    //!         having confidence level exceeding the specified confidence
+    //!         threshold are added to the envelope    
+    LinearEnvelope buildEnvelope( const std::vector< double > & samps, 
+                                  double sampleRate, 
+                                  double tbeg, double tend, 
+                                  double interval,
+                                  double lowerFreqBound, double upperFreqBound, 
+                                  double confidenceThreshold )
+    {
+        return buildEnvelope( &samps[0], &samps[0] + samps.size(), sampleRate, 
+                              tbeg, tend, interval, 
+                              lowerFreqBound, upperFreqBound,
+                              confidenceThreshold );
+    }
+
+                                 
+    //  estimateAt
+    //
+    //! Return an estimate of the fundamental frequency computed 
+    //! at the specified time. The F0Estimate returned stores the
+    //! estimate of the fundamental frequency (in Hz) and the 
+    //! relative confidence (from 0 to 1) associated with that
+    //! estimate.
+    //!
+    //! \param  sampsBeg is the beginning of a sequence of samples
+    //! \param  sampsEnd is the end of the sequence of samples
+    //! \param  sampleRate is the sampling rate (in Hz) associated
+    //!         with the sequence of samples (used to compute frequencies
+    //!         in Hz, and to convert the time from seconds to samples)
+    //! \param  time is the time in seconds at which to attempt to estimate
+    //!         the fundamental frequency
+    //! \param  lowerFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  upperFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \return the estimate of fundamental frequency in Hz and the 
+    //!         confidence associated with that estimate (see 
+    //!         F0Estimate.h)
+    
+    value_type estimateAt( const double * sampsBeg, 
+                           const double * sampsEnd, 
+                           double sampleRate, 
+                           double time,
+                           double lowerFreqBound, double upperFreqBound );
+
+    //  estimateAt
+    //
+    //! Return an estimate of the fundamental frequency computed 
+    //! at the specified time. The F0Estimate returned stores the
+    //! estimate of the fundamental frequency (in Hz) and the 
+    //! relative confidence (from 0 to 1) associated with that
+    //! estimate.
+    //!
+    //! \param  samps is the beginning of a sequence of samples
+    //! \param  nsamps is the length of the sequence of samples
+    //! \param  sampleRate is the sampling rate (in Hz) associated
+    //!         with the sequence of samples (used to compute frequencies
+    //!         in Hz, and to convert the time from seconds to samples)
+    //! \param  time is the time in seconds at which to attempt to estimate
+    //!         the fundamental frequency
+    //! \param  lowerFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  upperFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \return the estimate of fundamental frequency in Hz and the 
+    //!         confidence associated with that estimate (see 
+    //!         F0Estimate.h)
+    
+    value_type estimateAt( const double * sampsBeg, 
+                           unsigned long nsamps,
+                           double sampleRate, 
+                           double time,
+                           double lowerFreqBound, double upperFreqBound )
+    {
+        return estimateAt( sampsBeg, sampsBeg + nsamps, sampleRate, 
+                           time, lowerFreqBound, upperFreqBound );
+    }
+                           
+    //  estimateAt
+    //
+    //! Return an estimate of the fundamental frequency computed 
+    //! at the specified time. The F0Estimate returned stores the
+    //! estimate of the fundamental frequency (in Hz) and the 
+    //! relative confidence (from 0 to 1) associated with that
+    //! estimate.
+    //!
+    //! \param  samps is the sequence of samples
+    //! \param  sampleRate is the sampling rate (in Hz) associated
+    //!         with the sequence of samples (used to compute frequencies
+    //!         in Hz, and to convert the time from seconds to samples)
+    //! \param  time is the time in seconds at which to attempt to estimate
+    //!         the fundamental frequency
+    //! \param  lowerFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  upperFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \return the estimate of fundamental frequency in Hz and the 
+    //!         confidence associated with that estimate (see 
+    //!         F0Estimate.h)
+    
+    value_type estimateAt( const std::vector< double > & samps, 
+                           double sampleRate, 
+                           double time,
+                           double lowerFreqBound, double upperFreqBound )
+    {
+        return estimateAt( &samps[0], &samps[0] + samps.size(), sampleRate, 
+                           time, lowerFreqBound, upperFreqBound );
+    }
+                              
+
+
+//  -- spectral analysis parameter access/mutation --
+
+    //! Return the frequency-domain main lobe width (in Hz measured 
+    //! between zero-crossings) of the analysis window used in spectral
+    //! analysis.               
+    double windowWidth( void ) const;
+    
+    //! Set the frequency-domain main lobe width (in Hz measured 
+    //! between zero-crossings) of the analysis window used in spectral
+    //! analysis.   
+    //! 
+    //! \param  w is the new main lobe width in Hz            
+    void setWindowWidth( double w );         
+
+    
+
+//  -- private auxiliary functions --
+
+private: 
+
+    //  buildSpectrumAnalyzer
+    //
+    //! Construct the ReassignedSpectrum that will be used to perform
+    //! spectral analysis from which peak frequencies and amplitudes 
+    //! will be drawn. This construction is performed in a lazy fashion,
+    //! and needs to be done again when certain of the parameters change.
+    //!
+    //! \param  srate is the sampling frequency in Hz, needed to compute
+    //!         analysis window parameters    
+    void buildSpectrumAnalyzer( double srate );
+        
+
+    //  collectFreqsAndAmps
+    //
+    //! Perform spectral analysis on a sequence of samples, using
+    //! an analysis window centered at the specified time in seconds.
+    //! Collect the frequencies and amplitudes of the peaks and return
+    //! them in the vectors provided. 
+    //!
+    //! \param  samps is the beginning of a sequence of samples
+    //! \param  nsamps is the length of the sequence of Partials
+    //! \param  sampleRate is the sampling rate (in Hz) associated
+    //!         with the sequence of samples (used to compute frequencies
+    //!         in Hz, and to convert the time from seconds to samples)
+    //! \param  frequencies is a vector in which to store a sequence of
+    //!         frequencies to be used to estimate the most likely 
+    //!         fundamental frequency
+    //! \param  amplitudes is a vector in which to store a sequence of
+    //!         amplitudes to be used to estimate the most likely 
+    //!         fundamental frequency
+    //! \param  time is the time in seconds at which to collect frequencies
+    //!         and amplitudes of spectral peaks
+    
+    void collectFreqsAndAmps( const double * samps,
+                              unsigned long nsamps,
+                              double sampleRate,
+                              std::vector< double > & frequencies, 
+                              std::vector< double > & amplitudes,
+                              double time );
+
+
+//  -- private member variables --
+
+    std::auto_ptr< ReassignedSpectrum > m_spectrum;
+                                //! the spectrum analyzer 
+                                
+    double m_cacheSampleRate;   //! the sample rate used to construct the 
+
+    double m_windowWidth;       //! the width of the main lobe of the window to 
+                                //! be used in spectral analysis, in Hz
+    
+//  disallow these until they are implemented
+
+    FundamentalFromSamples( const FundamentalFromSamples & );
+    FundamentalFromSamples & operator= ( const FundamentalFromSamples & );
+
+};   //  end of class FundamentalFromSamples
+
+
+
+// ---------------------------------------------------------------------------
+//  class FundamentalFromPartials
+//
+//! Class FundamentalFromPartials represents an algorithm for 
+//! time-varying fundamental frequency estimation from instantaneous
+//! Partial amplitudes and frequencies based on a likelihood
+//!	estimator adapted from Quatieri's Speech Signal Processing text
+
+class FundamentalFromPartials : public FundamentalEstimator
+{
+//  -- public interface --
+
+public:
+
+//  -- lifecycle --
+
+    //! Construct a new estimator.
+    //!
+    //! The specified precision is used to terminate the iterative
+    //! estimation procedure. If unspecified, the default value,
+    //! DefaultPrecisionOver100 * 100 is used. 
+    //!
+    //! \param precisionHz is the precision in Hz with which the 
+    //! fundamental estimates will be made.    
+    FundamentalFromPartials( double precisionHz = DefaultPrecisionOver100 * 0.01 );
+                                                        
+
+    //! Destructor    
+    ~FundamentalFromPartials( void );
+    
+    //! Construct a copy of an estimator. Nothing much to do since this class
+    //! has no data members.
+    FundamentalFromPartials( const FundamentalFromPartials & );
+    
+    //! Pass the assignment opertion up to the base class.
+    FundamentalFromPartials & operator= ( const FundamentalFromPartials & );
+
+//  -- fundamental frequency estimation --
+
+    //  buildEnvelope
+    //
+    //! Construct a linear envelope from fundamental frequency 
+    //! estimates taken at the specified interval in seconds 
+    //! starting at tbeg (seconds) and ending before tend (seconds).
+    //!
+    //! \param  begin_partials is the beginning of a sequence of Partials
+    //! \param  end_partials is the end of a sequence of Partials
+    //! \param  tbeg is the beginning of the time interval (in seconds)
+    //! \param  tend is the end of the time interval (in seconds)
+    //! \param  interval is the time between breakpoints in the
+    //!         fundamental frequency envelope (in seconds)
+    //! \param  lowerFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  upperFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  confidenceThreshold is the minimum confidence level
+    //!         resuired for a fundamental frequency estimate to be
+    //!         added to the envelope. Lower confidence estimates are
+    //!         not added, the envelope returned will not contain
+    //!         breakpoints at times associated with low confidence 
+    //!         estimates
+    //! \return a LinearEnvelope composed of breakpoints corresponding to
+    //!         the fundamental frequency estimates at samples of the span
+    //!         tbeg to tend at the specified sampling interval, only estimates
+    //!         having confidence level exceeding the specified confidence
+    //!         threshold are added to the envelope
+    LinearEnvelope buildEnvelope( PartialList::const_iterator begin_partials, 
+                                  PartialList::const_iterator end_partials,
+                                  double tbeg, double tend, 
+                                  double interval,
+                                  double lowerFreqBound, double upperFreqBound, 
+                                  double confidenceThreshold );
+                                  
+    //  buildEnvelope
+    //
+    //! Construct a linear envelope from fundamental frequency 
+    //! estimates taken at the specified interval in seconds 
+    //! starting at tbeg (seconds) and ending before tend (seconds).
+    //!
+    //! \param  partials is the sequence of Partials
+    //! \param  tbeg is the beginning of the time interval (in seconds)
+    //! \param  tend is the end of the time interval (in seconds)
+    //! \param  interval is the time between breakpoints in the
+    //!         fundamental frequency envelope (in seconds)
+    //! \param  lowerFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  upperFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  confidenceThreshold is the minimum confidence level
+    //!         resuired for a fundamental frequency estimate to be
+    //!         added to the envelope. Lower confidence estimates are
+    //!         not added, the envelope returned will not contain
+    //!         breakpoints at times associated with low confidence 
+    //!         estimates
+    //! \return a LinearEnvelope composed of breakpoints corresponding to
+    //!         the fundamental frequency estimates at samples of the span
+    //!         tbeg to tend at the specified sampling interval, only estimates
+    //!         having confidence level exceeding the specified confidence
+    //!         threshold are added to the envelope                                        
+    LinearEnvelope buildEnvelope( const PartialList & partials, 
+                                  double tbeg, double tend, 
+                                  double interval,
+                                  double lowerFreqBound, double upperFreqBound, 
+                                  double confidenceThreshold )
+    {
+        return buildEnvelope( partials.begin(), partials.end(),
+                              tbeg, tend, interval,
+                              lowerFreqBound, upperFreqBound,
+                              confidenceThreshold );
+    }
+    
+                                 
+    //  estimateAt
+    //
+    //! Return an estimate of the fundamental frequency computed 
+    //! at the specified time. The F0Estimate returned stores the
+    //! estimate of the fundamental frequency (in Hz) and the 
+    //! relative confidence (from 0 to 1) associated with that
+    //! estimate.
+    //!
+    //! \param  begin_partials is the beginning of a sequence of Partials
+    //! \param  end_partials is the end of a sequence of Partials
+    //! \param  time is the time in seconds at which to attempt to estimate
+    //!         the fundamental frequency
+    //! \param  lowerFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  upperFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \return the estimate of fundamental frequency in Hz and the 
+    //!         confidence associated with that estimate (see 
+    //!         F0Estimate.h)
+    value_type estimateAt( PartialList::const_iterator begin_partials, 
+                           PartialList::const_iterator end_partials,
+                           double time,
+                           double lowerFreqBound, double upperFreqBound );
+                           
+    //  estimateAt
+    //
+    //! Return an estimate of the fundamental frequency computed 
+    //! at the specified time. The F0Estimate returned stores the
+    //! estimate of the fundamental frequency (in Hz) and the 
+    //! relative confidence (from 0 to 1) associated with that
+    //! estimate.
+    //!
+    //! \param  partials is the sequence of Partials
+    //! \param  time is the time in seconds at which to attempt to estimate
+    //!         the fundamental frequency
+    //! \param  lowerFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \param  upperFreqBound is the lower bound on the fundamental
+    //!         frequency estimate (in Hz)
+    //! \return the estimate of fundamental frequency in Hz and the 
+    //!         confidence associated with that estimate (see 
+    //!         F0Estimate.h)
+    value_type estimateAt( const PartialList & partials, 
+                           double time,
+                           double lowerFreqBound, double upperFreqBound )
+    {
+            return estimateAt( partials.begin(), partials.end(),
+                               time,
+                               lowerFreqBound, upperFreqBound );
+    }
+
+
+
+//  -- private auxiliary functions --
+
+private: 
+
+    //  collectFreqsAndAmps
+    //
+    //! Collect the frequencies and amplitudes of a range of partials 
+    //! at the specified time and return them in the vectors provided. 
+    //!
+    //! \param  begin_partials is the beginning of a sequence of Partials
+    //! \param  end_partials is the end of a sequence of Partials
+    //! \param  frequencies is a vector in which to store a sequence of
+    //!         frequencies to be used to estimate the most likely 
+    //!         fundamental frequency
+    //! \param  amplitudes is a vector in which to store a sequence of
+    //!         amplitudes to be used to estimate the most likely 
+    //!         fundamental frequency
+    //! \param  time is the time in seconds at which to collect frequencies
+    //!         and amplitudes of the Partials
+    void collectFreqsAndAmps( PartialList::const_iterator begin_partials, 
+                              PartialList::const_iterator end_partials,
+                              std::vector< double > & frequencies, 
+                              std::vector< double > & amplitudes,
+                              double time );
+
+
+
+};   //  end of class FundamentalFromPartials
+
+
+
+}   //  end of namespace Loris
+
+#endif  // ndef INCLUDE_FUNDAMENTAL_H
diff --git a/src/loris/Harmonifier.C b/src/loris/Harmonifier.C
new file mode 100644
index 0000000..3a41c58
--- /dev/null
+++ b/src/loris/Harmonifier.C
@@ -0,0 +1,158 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Harmonifier.h
+ *
+ * Definition of class Harmonifier.
+ *
+ * Kelly Fitz, 26 Oct 2005
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#include "Harmonifier.h"
+
+#include "LinearEnvelope.h"
+
+#include <cmath>    // for pow
+
+using namespace Loris; 
+
+
+// ---------------------------------------------------------------------------
+//    Constructor
+// ---------------------------------------------------------------------------
+//! Construct a new Harmonifier that applies the specified 
+//! reference Partial to fix the frequencies of Breakpoints
+//! whose amplitude is below threshold_dB (0 by default,
+//! to apply only to quiet Partials, specify a threshold,
+//! like -90). 
+//
+Harmonifier::Harmonifier( const Partial & ref, double threshold_dB ) :
+    _refPartial( ref ),
+    _freqFixThresholdDb( threshold_dB ),
+    _weight( createDefaultEnvelope() )
+{
+    if ( 0 == _refPartial.numBreakpoints() )
+    {
+        Throw( InvalidArgument, 
+               "Cannot use an empty reference Partial in Harmonizer" );
+    }
+    if ( 0 == _refPartial.label() )
+    {
+        //  if the reference is unlabeled, assume that it is the fundamental
+        _refPartial.setLabel( 1 );
+    }
+    
+}
+
+// ---------------------------------------------------------------------------
+//    Constructor
+// ---------------------------------------------------------------------------
+//! Construct a new Harmonifier that applies the specified 
+//! reference Partial to fix the frequencies of Breakpoints
+//! whose amplitude is below threshold_dB (0 by default,
+//! to apply only to quiet Partials, specify a threshold,
+//! like -90). The Envelope is a time-varying weighting 
+//! on the harmonifing process. When 1, harmonic frequencies
+//! are used, when 0, breakpoint frequencies are unmodified. 
+//
+Harmonifier::Harmonifier( const Partial & ref, const Envelope & env, 
+                          double threshold_dB ) :
+    _refPartial( ref ),
+    _freqFixThresholdDb( threshold_dB ),
+    _weight( env.clone() )
+{
+    if ( 0 == _refPartial.numBreakpoints() )
+    {
+        Throw( InvalidArgument, 
+               "Cannot use an empty reference Partial in Harmonizer" );
+    }
+    if ( 0 == _refPartial.label() )
+    {
+        //  if the reference is unlabeled, assume that it is the fundamental
+        _refPartial.setLabel( 1 );
+    }
+    
+}
+
+// ---------------------------------------------------------------------------
+//    Destructor
+// ---------------------------------------------------------------------------
+Harmonifier::~Harmonifier( void )
+{
+}
+
+// ---------------------------------------------------------------------------
+//    harmonify
+// ---------------------------------------------------------------------------
+//! Apply the reference envelope to a Partial.
+//!
+//! \pre    The Partial p must be labeled with its harmonic number.
+//
+void Harmonifier::harmonify( Partial & p ) const
+{
+    //    compute absolute magnitude thresholds:
+    static const double FadeRangeDB = 10;
+    const double BeginFade = std::pow( 10., 0.05 * (_freqFixThresholdDb+FadeRangeDB) );
+    const double Threshold = std::pow( 10., 0.05 * _freqFixThresholdDb );
+    const double OneOverFadeSpan = 1. / ( BeginFade - Threshold );
+
+    double fscale = (double)p.label() / _refPartial.label();
+    
+    for ( Partial::iterator it = p.begin(); it != p.end(); ++it )
+    {
+        Breakpoint & bp = it.breakpoint();            
+                
+        if ( bp.amplitude() < BeginFade )
+        {
+            //  alpha is the harmonic frequency weighting:
+            //  when alpha is 1, the harmonic frequency is used,
+            //  when alpha is 0, the breakpoint frequency is
+            //  unmodified.
+            double alpha = 
+                std::min( ( BeginFade - bp.amplitude() ) * OneOverFadeSpan, 1. );
+                
+            //  alpha is scaled by the weigthing envelope
+            alpha *= _weight->valueAt( it.time() );
+            
+            double fRef = _refPartial.frequencyAt( it.time() );
+            
+            bp.setFrequency( ( alpha * ( fRef * fscale ) ) + 
+                             ( (1 - alpha) * bp.frequency() ) );
+        }
+
+    }
+}
+
+// ---------------------------------------------------------------------------
+//    createDefaultEnvelope (STATIC)
+// ---------------------------------------------------------------------------
+//! Return the default weighing envelope (always 1).
+//! Used in template constructors.
+//
+Envelope * Harmonifier::createDefaultEnvelope( void )
+{
+    return new LinearEnvelope( 1 );
+}    
+
diff --git a/src/loris/Harmonifier.h b/src/loris/Harmonifier.h
new file mode 100644
index 0000000..b1b04d8
--- /dev/null
+++ b/src/loris/Harmonifier.h
@@ -0,0 +1,441 @@
+#ifndef INCLUDE_HARMONIFIER_H
+#define INCLUDE_HARMONIFIER_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Harmonifier.h
+ *
+ * Definition of class Harmonifier.
+ *
+ * Kelly Fitz, 26 Oct 2005
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#include "Envelope.h" 
+#include "LorisExceptions.h" 
+#include "Partial.h"
+#include "PartialUtils.h"
+
+#include <algorithm>    // for find
+#include <memory>       // for auto_ptr
+
+//	begin namespace
+namespace Loris {
+
+
+// ---------------------------------------------------------------------------
+//	Class Harmonifier
+//
+//! A Harmonifier uses a reference frequency envelope to make the
+//! frequencies of labeled Partials harmonic. The amount of frequency
+//! adjustment can be controlled by a time-varying envelope, and a 
+//! threshold can be supplied so that only quiet Partials are affected.
+//
+class Harmonifier
+{
+//	-- instance variables --
+
+	Partial _refPartial;				//! the Partial whose frequency supplies the
+										//! reference frequency envelope.
+										
+	double _freqFixThresholdDb;		    //!	amplitude threshold below which Partial
+									    //!	frequencies are corrected according to
+									    //!	a reference Partial, if specified.
+
+	std::auto_ptr< Envelope > _weight;  //!	weighting function, when 1 harmonic
+                                        //! frequencies are used, when 0 breakpoint
+                                        //! frequencies are unmodified.
+    
+//	-- public interface --
+public:
+
+//	-- lifecycle --
+
+    //! Construct a new Harmonifier that applies the specified 
+    //! reference Partial to fix the frequencies of Breakpoints
+    //! whose amplitude is below threshold_dB (0 by default,
+    //! to apply only to quiet Partials, specify a threshold,
+    //! like -90). 
+   	Harmonifier( const Partial & ref, double threshold_dB = 0 );
+
+    //! Construct a new Harmonifier that applies the specified 
+    //! reference Partial to fix the frequencies of Breakpoints
+    //! whose amplitude is below threshold_dB (0 by default,
+    //! to apply only to quiet Partials, specify a threshold,
+    //! like -90). The Envelope is a time-varying weighting 
+    //! on the harmonifing process. When 1, harmonic frequencies
+    //! are used, when 0, breakpoint frequencies are unmodified. 
+   	Harmonifier( const Partial & ref, const Envelope & env, 
+   	             double threshold_dB = 0 );
+
+    //! Construct a new Harmonifier that applies the specified 
+    //! reference Partial to fix the frequencies of Breakpoints
+    //! whose amplitude is below threshold_dB (0 by default,
+    //! to apply only to quiet Partials, specify a threshold,
+    //! like -90). The reference Partial is the first Partial
+    //! in the range [b,e) having the specified label. 
+    //
+    //! \throw  InvalidArgument if no Partial in the range [b,e)
+    //!         has the specified label.
+    //
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+   	Harmonifier( Iter b, Iter e, Partial::label_type refLabel, 
+   	            double threshold_dB = 0 );
+#else
+   inline
+   	Harmonifier( PartialList::iterator b, PartialList::iterator e, 
+   	             Partial::label_type refLabel, double threshold_dB = 0 );
+#endif
+
+    //! Construct a new Harmonifier that applies the specified 
+    //! reference Partial to fix the frequencies of Breakpoints
+    //! whose amplitude is below threshold_dB (0 by default,
+    //! to apply only to quiet Partials, specify a threshold,
+    //! like -90). The reference Partial is the first Partial
+    //! in the range [b,e) having the specified label. 
+    //!
+    //! The Envelope is a time-varying weighting 
+    //! on the harmonifing process. When 1, harmonic frequencies
+    //! are used, when 0, breakpoint frequencies are unmodified. 
+    //
+    //! \throw  InvalidArgument if no Partial in the range [b,e)
+    //!         has the specified label.
+    //
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+   	Harmonifier( Iter b, Iter e, Partial::label_type refLabel, 
+   	             const Envelope & env, double threshold_dB = 0 );
+#else
+   inline
+   	Harmonifier( PartialList::iterator b, PartialList::iterator e, 
+   	             Partial::label_type refLabel, const Envelope & env,
+   	             double threshold_dB = 0 );
+#endif
+
+    //! Destructor.
+    ~Harmonifier( void );
+
+    // use compiler-generated copy and assign.
+
+//	-- operation --
+
+    //! Apply the reference envelope to a Partial.
+    void harmonify( Partial & p ) const;
+    
+    //! Apply the reference envelope to all Partials in a range.    
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+	void harmonify( Iter b, Iter e  );
+#else
+    inline
+    void harmonify( PartialList::iterator b, PartialList::iterator e  );
+#endif
+
+// -- static members --
+
+	//! Static member that constructs an instance and applies
+	//! it to a sequence of Partials. 
+	//! Construct a Harmonifier using as reference the Partial in
+	//! the specified range labeled refLabel, then apply
+	//! the instance to all Partials in the range.
+	//!
+  	//!	\param  b is the beginning of the range of Partials to harmonify
+	//!	\param  e is (one-past) the end of the range of Partials to harmonify
+	//! \param  refLabel is the label of the Partial in [b,e) to
+	//!         use as reference Partial. The reference Partial is the first
+    //!         Partial in the range [b,e) having the specified label. 
+	//! \param  threshold_dB is the amplitude below which breakpoint
+	//!         frequencies are harmonified (0 by default, to apply 
+    //!         only to quiet Partials, specify a threshold, like -90). 
+	//! 
+    //! \throw  InvalidArgument if no Partial in the range [b,e)
+    //!         has the specified label.	
+    //! \throw  InvalidArgument if refLabel is non-positive.	
+	//!	
+	//!	If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+	//!	must be PartialList::iterators, otherwise they can be any type
+	//!	of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template< typename Iter >
+	static 
+	void harmonify( Iter b, Iter e, 
+	                Partial::label_type refLabel,
+                    double threshold_dB = 0 );
+#else
+	static inline 
+	void harmonify( PartialList::iterator b, PartialList::iterator e,
+	                Partial::label_type refLabel,
+                    double threshold_dB = 0 );
+#endif	 
+
+	//! Static member that constructs an instance and applies
+	//! it to a sequence of Partials. 
+	//! Construct a Harmonifier using as reference the Partial in
+	//! the specified range labeled refLabel, then apply
+	//! the instance to all Partials in the range.
+	//!
+  	//!	\param  b is the beginning of the range of Partials to harmonify
+	//!	\param  e is (one-past) the end of the range of Partials to harmonify
+	//! \param  refLabel is the label of the Partial in [b,e) to
+	//!         use as reference Partial. The reference Partial is the first
+    //!         Partial in the range [b,e) having the specified label. 
+	//! \param  env is a weighting envelope to apply to the harmonification
+	//!         process: when env is 1, use harmonic frequencies, when env
+	//!         is 0, breakpoint frequencies are unmodified.
+	//! \param  threshold_dB is the amplitude below which breakpoint
+	//!         frequencies are harmonified (0 by default, to apply 
+    //!         only to quiet Partials, specify a threshold, like -90). 
+	//! 
+    //! \throw  InvalidArgument if no Partial in the range [b,e)
+    //!         has the specified label.	
+    //! \throw  InvalidArgument if refLabel is non-positive.	
+	//!	
+	//!	If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+	//!	must be PartialList::iterators, otherwise they can be any type
+	//!	of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template< typename Iter >
+	static 
+	void harmonify( Iter b, Iter e, 
+	                Partial::label_type refLabel,
+                    const Envelope & env, double threshold_dB = 0 );
+#else
+	static inline 
+	void harmonify( PartialList::iterator b, PartialList::iterator e,
+	                Partial::label_type refLabel,
+                    const Envelope & env, double threshold_dB = 0 );
+#endif	 
+
+private:
+
+//	-- helpers --
+
+    //! Return the default weighing envelope (always 1).
+    //! Used in template constructors.
+    static Envelope * createDefaultEnvelope( void );
+    
+};
+
+// ---------------------------------------------------------------------------
+//	constructor
+// ---------------------------------------------------------------------------
+//! Construct a new Harmonifier that applies the specified 
+//! reference Partial to fix the frequencies of Breakpoints
+//! whose amplitude is below threshold_dB (0 by default,
+//! to apply only to quiet Partials, specify a threshold,
+//! like -90). The reference Partial is the first Partial
+//! in the range [b,e) having the specified label. 
+//! \throw  InvalidArgument if no Partial in the range [b,e)
+//!         has the specified label.
+//! \throw  InvalidArgument if refLabel is non-positive.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+Harmonifier::Harmonifier( Iter b, Iter e, Partial::label_type refLabel, 
+                          double threshold_dB ) :
+#else
+inline
+Harmonifier::Harmonifier( PartialList::iterator b, PartialList::iterator e, 
+                          Partial::label_type refLabel, double threshold_dB ) :
+#endif
+    _freqFixThresholdDb( threshold_dB ),
+    _weight( createDefaultEnvelope() )
+{
+    if ( 1 > refLabel )
+    {
+        Throw( InvalidArgument, "The reference label must be positive." );
+    }
+
+    b = std::find_if( b, e, PartialUtils::isLabelEqual( refLabel ) );
+    if ( b == e )
+	{
+		Throw( InvalidArgument, "no Partial has the specified reference label" );
+	}
+
+    if ( 0 == b->numBreakpoints() )
+    {
+        Throw( InvalidArgument, 
+               "Cannot use an empty reference Partial in Harmonizer" );
+    }
+    _refPartial = *b;
+}
+
+// ---------------------------------------------------------------------------
+//	constructor
+// ---------------------------------------------------------------------------
+//! Construct a new Harmonifier that applies the specified 
+//! reference Partial to fix the frequencies of Breakpoints
+//! whose amplitude is below threshold_dB (0 by default,
+//! to apply only to quiet Partials, specify a threshold,
+//! like -90). The reference Partial is the first Partial
+//! in the range [b,e) having the specified label. 
+//!
+//! The Envelope is a time-varying weighting 
+//! on the harmonifing process. When 1, harmonic frequencies
+//! are used, when 0, breakpoint frequencies are unmodified. 
+//!
+//! \throw  InvalidArgument if no Partial in the range [b,e)
+//!         has the specified label.
+//! \throw  InvalidArgument if refLabel is non-positive.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+Harmonifier::Harmonifier( Iter b, Iter e, Partial::label_type refLabel, 
+                          const Envelope & env, double threshold_dB ) :
+#else
+inline
+Harmonifier::Harmonifier( PartialList::iterator b, PartialList::iterator e, 
+                          Partial::label_type refLabel, const Envelope & env,
+                          double threshold_dB ) :
+#endif
+    _freqFixThresholdDb( threshold_dB ),
+    _weight( env.clone() )
+{
+    if ( 1 > refLabel )
+    {
+        Throw( InvalidArgument, "The reference label must be positive." );
+    }
+
+    b = std::find_if( b, e, PartialUtils::isLabelEqual( refLabel ) );
+    if ( b == e )
+	{
+		Throw( InvalidArgument, "no Partial has the specified reference label" );
+	}
+
+    if ( 0 == b->numBreakpoints() )
+    {
+        Throw( InvalidArgument, 
+               "Cannot use an empty reference Partial in Harmonizer" );
+    }
+    _refPartial = *b;
+}
+
+// ---------------------------------------------------------------------------
+//	harmonify
+// ---------------------------------------------------------------------------
+//! Apply the reference envelope to all Partials in a range.    
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void Harmonifier::harmonify( Iter b, Iter e  )
+#else
+inline
+void Harmonifier::harmonify( PartialList::iterator b, PartialList::iterator e  )
+#endif
+{
+    while ( b != e )
+    {
+        harmonify( *b );
+        ++b;
+    }
+}    
+
+// ---------------------------------------------------------------------------
+//	harmonify (STATIC)
+// ---------------------------------------------------------------------------
+//! Static member that constructs an instance and applies
+//! it to a sequence of Partials. 
+//! Construct a Harmonifier using as reference the Partial in
+//! the specified range labeled refLabel, then apply
+//! the instance to all Partials in the range.
+//!
+//!	\param  b is the beginning of the range of Partials to harmonify
+//!	\param  e is (one-past) the end of the range of Partials to harmonify
+//! \param  refLabel is the label of the Partial in [b,e) to
+//!         use as reference Partial. The reference Partial is the first
+//!         Partial in the range [b,e) having the specified label. 
+//! \param  threshold_dB is the amplitude below which breakpoint
+//!         frequencies are harmonified (0 by default, to apply 
+//!         only to quiet Partials, specify a threshold, like -90). 
+//! 
+//! \throw  InvalidArgument if no Partial in the range [b,e)
+//!         has the specified label.	
+//! \throw  InvalidArgument if refLabel is non-positive.	
+//!	
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+//!	must be PartialList::iterators, otherwise they can be any type
+//!	of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename Iter >
+void Harmonifier::harmonify( Iter b, Iter e, 
+                             Partial::label_type refLabel,
+                             double threshold_dB )
+#else
+inline 
+void Harmonifier::harmonify( PartialList::iterator b, PartialList::iterator e,
+                             Partial::label_type refLabel,
+                             double threshold_dB )
+#endif	 
+{
+    Harmonifier instance( b, e, refLabel, threshold_dB );
+    instance.harmonify( b, e );
+}
+
+// ---------------------------------------------------------------------------
+//	harmonify (STATIC)
+// ---------------------------------------------------------------------------
+//! Static member that constructs an instance and applies
+//! it to a sequence of Partials. 
+//! Construct a Harmonifier using as reference the Partial in
+//! the specified range labeled refLabel, then apply
+//! the instance to all Partials in the range.
+//!
+//!	\param  b is the beginning of the range of Partials to harmonify
+//!	\param  e is (one-past) the end of the range of Partials to harmonify
+//! \param  refLabel is the label of the Partial in [b,e) to
+//!         use as reference Partial. The reference Partial is the first
+//!         Partial in the range [b,e) having the specified label. 
+//! \param  env is a weighting envelope to apply to the harmonification
+//!         process: when env is 1, use harmonic frequencies, when env
+//!         is 0, breakpoint frequencies are unmodified.
+//! \param  threshold_dB is the amplitude below which breakpoint
+//!         frequencies are harmonified (0 by default, to apply 
+//!         only to quiet Partials, specify a threshold, like -90). 
+//! 
+//! \throw  InvalidArgument if no Partial in the range [b,e)
+//!         has the specified label.	
+//! \throw  InvalidArgument if refLabel is non-positive.	
+//!	
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+//!	must be PartialList::iterators, otherwise they can be any type
+//!	of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename Iter >
+void Harmonifier::harmonify( Iter b, Iter e, 
+                             Partial::label_type refLabel,
+                             const Envelope & env, double threshold_dB )
+#else
+inline 
+void Harmonifier::harmonify( PartialList::iterator b, PartialList::iterator e,
+                             Partial::label_type refLabel,
+                             const Envelope & env, double threshold_dB )
+#endif	 
+{
+    Harmonifier instance( b, e, refLabel, env, threshold_dB );
+    instance.harmonify( b, e );
+}
+
+}	// namespace Loris
+
+#endif	/* ndef INCLUDE_HARMONIFIER_H */
diff --git a/src/loris/ImportLemur.C b/src/loris/ImportLemur.C
new file mode 100644
index 0000000..f14dc4b
--- /dev/null
+++ b/src/loris/ImportLemur.C
@@ -0,0 +1,519 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * ImportLemur.C
+ *
+ * Implementation of class Loris::ImportLemur for importing Partials stored 
+ * in Lemur 5 alpha files.
+ *
+ * Kelly Fitz, 10 Sept 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "ImportLemur.h"
+#include "BigEndian.h"
+#include "LorisExceptions.h"
+#include "Partial.h"
+#include "PartialList.h"
+#include "Breakpoint.h"
+#include "Notifier.h"
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <string>
+
+//	in case configure wasn't run (no config.h), 
+//	pick some (hopefully-) reasonable values for
+//	these things and hope for the best...
+#if ! defined( SIZEOF_SHORT )
+#define SIZEOF_SHORT 2
+#endif
+
+#if ! defined( SIZEOF_INT )
+#define SIZEOF_INT 4
+#endif
+
+#if ! defined( SIZEOF_LONG )
+#define SIZEOF_LONG 4	// not for DEC Alpha!
+#endif
+
+#if SIZEOF_SHORT == 2
+typedef short 			Int_16;
+typedef unsigned short 	Uint_16;
+#elif SIZEOF_INT == 2
+typedef int 			Int_16;
+typedef unsigned int 	Uint_16;
+#else
+#error "cannot find an appropriate type for 16-bit integers"
+#endif
+
+#if SIZEOF_INT == 4
+typedef int 			Int_32;
+typedef unsigned int 	Uint_32;
+#elif SIZEOF_LONG == 4
+typedef long 			Int_32;
+typedef unsigned long 	Uint_32;
+#else
+#error "cannot find an appropriate type for 32-bit integers"
+#endif
+
+
+#if ! defined( SIZEOF_FLOAT ) || SIZEOF_FLOAT == 4
+typedef float			Float_32;
+#else
+#error "cannot find an appropriate type for 32-bit floats"
+#endif
+
+#if ! defined( SIZEOF_DOUBLE ) || SIZEOF_DOUBLE == 8
+typedef double			Double_64;
+#else
+#error "cannot find an appropriate type for 64-bit double-precision floats"
+#endif
+
+
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+	const double Pi = M_PI;
+#else
+	const double Pi = 3.14159265358979324;
+#endif		
+
+//	begin namespace
+namespace Loris {
+
+//	-- types and ids --
+enum { 
+		ContainerId = 0x464f524d,				// 'FORM' 
+		LEMR_ID = 0x4c454d52,					// 'LEMR' 
+		AnalysisParamsID = 0x4c4d414e,			// 'LMAN' 
+		TrackDataID = 0x54524b53,				// 'TRKS'
+		FormatNumber = 4962 };
+
+//	for reading and writing files, the exact sizes and
+//	alignments are critical.
+typedef Int_32 ID;
+struct CkHeader 
+{
+	Int_32 id;
+	Int_32 size;
+};
+
+struct ContainerCk
+{
+	CkHeader header;
+	ID formType;
+};
+
+struct AnalysisParamsCk
+{
+	//Int_32 ckID;
+	//Int_32 ckSize;
+	CkHeader header;
+	
+	Int_32 formatNumber;
+	Int_32 originalFormatNumber;
+	
+	Int_32 ftLength;			//	samples, transform length
+	Float_32 winWidth;			//	Hz, main lobe width
+	Float_32 winAtten;			//	dB, sidelobe attenuation
+	Int_32	hopSize;			//	samples, frame length
+	Float_32 sampleRate;		// 	Hz, from analyzed sample
+	
+	Float_32 noiseFloor;		//	dB (negative)
+	Float_32 peakAmpRange;		//	dB, floating relative amplitde threshold
+	Float_32 maskingRolloff;	//	dB/Hz, peak masking curve	
+	Float_32 peakSeparation;	//	Hz, minimum separation between peaks
+	Float_32 freqDrift;			//	Hz, maximum track freq drift over a frame
+}; 
+
+struct TrackDataCk
+{
+	CkHeader header;
+	Uint_32	numberOfTracks;
+	Int_32	trackOrder;			// enumerated type
+	// track data follows
+};
+
+struct TrackOnDisk
+{
+	Double_64	startTime;		// in milliseconds
+	Float_32	initialPhase;
+	Uint_32		numPeaks;
+	Int_32		label;
+};
+
+struct PeakOnDisk
+{
+	Float_32	magnitude;
+	Float_32	frequency;
+	Float_32	interpolatedFrequency;
+	Float_32	bandwidth;
+	Double_64	ttn;
+};
+
+//	prototypes for import helpers:
+static void importPartials( std::istream & s, PartialList & partials, double bweCutoff );
+static void getPartial( std::istream & s, PartialList & partials, double bweCutoff );	
+static void readChunkHeader( std::istream & s, CkHeader & ck );
+static void readContainer( std::istream & s );
+static void readParamsChunk( std::istream & s );
+static long readTracksChunk( std::istream & s );
+static void readTrackHeader( std::istream & s, TrackOnDisk & t );
+static void readPeakData( std::istream & s, PeakOnDisk & p );
+
+// ---------------------------------------------------------------------------
+//	ImportLemur constructor
+// ---------------------------------------------------------------------------
+//	Imports immediately.
+//	bweCutoff defaults to 1kHz, the default cutoff in Lemur.
+//	Clients should be prepared to catch ImportErrors.
+//
+ImportLemur::ImportLemur( const std::string & fname, double bweCutoff /* = 1000 Hz */)
+{
+	std::fstream fs;
+	try
+	{
+		fs.open( fname.c_str(), std::ios::in | std::ios::binary );
+	}
+	catch( std::exception & ex )
+	{
+		Throw( ImportException, ex.what() );
+	}
+	importPartials( fs, _partials, bweCutoff );
+}
+
+// ---------------------------------------------------------------------------
+//	importPartials
+// ---------------------------------------------------------------------------
+//	Clients should be prepared to catch ImportExceptions.
+//
+//	THIS WON'T WORK IF CHUNKS ARE IN A DIFFERENT ORDER!!!
+//	Fortunately, they never will be, since only the research 
+//	version of Lemur ever wrote these files anyway.
+//
+static void
+importPartials( std::istream & s, PartialList & partials, double bweCutoff )
+{
+	try 
+	{
+		//	the Container chunk must be first, read it:
+		readContainer( s );
+		
+		//	read other chunks:
+		bool foundParams = false, foundTracks = false;
+		while ( ! foundParams || ! foundTracks )
+		{
+			//	read a chunk header, if it isn't the one we want, skip over it.
+			CkHeader h;
+			readChunkHeader( s, h );
+			
+			if ( h.id == AnalysisParamsID )
+			{
+				readParamsChunk( s );
+				foundParams = true;
+			}
+			else if ( h.id == TrackDataID )
+			{
+				if (! foundParams) 	//	 I hope this doesn't happen
+				{
+					Throw( ImportException, 
+							"Mia culpa! I am not smart enough to read the Track data before the Analysis Parameters data." );
+				}							
+				//	read Partials:
+				for ( long counter = readTracksChunk( s ); counter > 0; --counter ) 
+				{
+					getPartial(s, partials, bweCutoff);
+				}
+				foundTracks = true;
+			}
+			else
+			{
+				s.ignore( h.size );
+			}
+		}
+
+	}
+	catch ( Exception & ex ) 
+	{
+		if ( s.eof() )
+		{
+			ex.append("Reached end of file before finding both a Tracks chunk and a Parameters chunk.");
+		}
+		ex.append( "Import failed." );
+		Throw( ImportException, ex.str() );
+	}
+
+}
+
+// ---------------------------------------------------------------------------
+//	readContainer
+// ---------------------------------------------------------------------------
+//
+static void
+readContainer( std::istream & s )
+{
+	ContainerCk ck;		
+	try 
+	{
+		//	read chunk header:
+		readChunkHeader( s, ck.header );
+		if( ck.header.id != ContainerId )
+			Throw( FileIOException, "Found no Container chunk." );
+		
+		//	read FORM type
+		BigEndian::read( s, 1, sizeof(ID), (char *)&ck.formType );		
+	}
+	catch( FileIOException & ex ) 
+	{
+		ex.append( "Failed to read badly-formatted Lemur file (bad Container chunk)." );
+		throw;
+	}
+
+	//	make sure its really a Dr. Lemur file:
+	if ( ck.formType != LEMR_ID ) 
+	{
+		Throw( ImportException, "File is not formatted correctly for Lemur 5 import." );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	getPartial
+// ---------------------------------------------------------------------------
+//	Convert any FileIOExceptions into ImportExceptions, so that clients can 
+//	reasonably expect to catch only ImportExceptions.
+//
+static void
+getPartial( std::istream & s, PartialList & partials, double bweCutoff )
+{
+	try 
+	{
+		//	read the Track header:
+		TrackOnDisk tkHeader;
+		readTrackHeader( s, tkHeader );
+		
+		//	create a Partial:
+		Partial p;
+		p.setLabel( tkHeader.label );
+		
+		//	keep running phase and time for Breakpoint construction:
+		double phase = tkHeader.initialPhase;
+		
+		//	convert time to seconds and offset by a millisecond to 
+		//	allow for implied onset (Lemur analysis data was shifted
+		//	such that the earliest Partial starts at 0).
+		double time = tkHeader.startTime * 0.001;	
+		
+		//	use this to compute phases:
+		double prevTtnSec = 0.;
+		
+		//	loop: read Peak, create Breakpoint, add to Partial:
+		for ( int i = 0; i < tkHeader.numPeaks; ++i ) {
+			//	read Peak:
+			PeakOnDisk pkData;
+			readPeakData( s, pkData );
+			
+			double frequency = pkData.frequency;
+			double amplitude = pkData.magnitude;
+			double bandwidth = std::min( pkData.bandwidth, 1.f );
+			
+			//	fix bandwidth:
+			//	Lemur used a cutoff frequency, below which 
+			//	bandwidth was ignored; Loris does not, so 
+			//	toss out that bogus bandwidth.
+			if ( frequency < bweCutoff ) {
+				amplitude *= std::sqrt(1. - bandwidth);
+				bandwidth = 0.;
+			}
+			//	otherwise, adjust the bandwidth value
+			//	to account for the difference in noise
+			//	scaling between Lemur and Loris; this
+			//	mess doubles the noise modulation index
+			//	without changing the sine modulation index,
+			//	see Oscillator::modulate(). 
+			else {
+				amplitude *= std::sqrt( 1. + (3. * bandwidth) );
+				bandwidth = (4. * bandwidth) / ( 1. + (3. * bandwidth) ); 
+			}
+
+			//	update phase based on _this_ pkData's interpolated freq:
+			phase +=2. * Pi * prevTtnSec * pkData.interpolatedFrequency;
+			phase = std::fmod( phase, 2. * Pi );
+			
+			//	create Breakpoint:	
+			Breakpoint bp( frequency, amplitude, bandwidth, phase );
+			
+			//	insert in Partial:
+			p.insert( time, bp );
+			
+			//	update time:
+			prevTtnSec = pkData.ttn * 0.001;
+			time += prevTtnSec;
+		}
+
+		if ( p.duration() > 0. ) {
+			partials.push_back( p );
+		}
+		/*
+		else {
+			debugger << "import rejecting a Partial of zero duration (" 
+					<< tkHeader.numPeaks << " peaks read)" << endl;
+		}
+		*/
+	}
+	catch( FileIOException & ex ) {
+		ex.append(  "Failed to import a partial from a Lemur file." );
+		throw;
+	}
+	
+}	
+
+// ---------------------------------------------------------------------------
+//	readChunkHeader
+// ---------------------------------------------------------------------------
+//	Read the id and chunk size from the current file position.
+//
+static void
+readChunkHeader( std::istream & s, CkHeader & h )
+{
+	BigEndian::read( s, 1, sizeof(ID), (char *)&h.id );
+	BigEndian::read( s, 1, sizeof(Int_32), (char *)&h.size );
+} 
+
+// ---------------------------------------------------------------------------
+//	readTracksChunk
+// ---------------------------------------------------------------------------
+//	Leave file positioned at end of chunk header data and at the beginning 
+//	of the first track.
+//	Assumes that the stream is correctly positioned and that the chunk 
+//	header has been read.
+//	Returns the number of tracks to read.
+//
+static long 
+readTracksChunk( std::istream & s )
+{
+	TrackDataCk ck;
+	try 
+	{		
+		//	found it, read it one field at a time:
+		BigEndian::read( s, 1, sizeof(Uint_32), (char *)&ck.numberOfTracks );
+		BigEndian::read( s, 1, sizeof(Int_32), (char *)&ck.trackOrder );
+	}
+	catch( FileIOException & ex ) 
+	{
+		ex.append( "Failed to read badly-formatted Lemur file (bad Track Data chunk)." );
+		throw;
+	}
+	
+	return ck.numberOfTracks;
+}
+
+// ---------------------------------------------------------------------------
+//	readParamsChunk
+// ---------------------------------------------------------------------------
+//	Verify that the file has the correct format and is available for reading.
+//	Assumes that the stream is correctly positioned and that the chunk 
+//	header has been read.
+//
+static void
+readParamsChunk( std::istream & s )
+{
+	AnalysisParamsCk ck;
+	try 
+	{
+		BigEndian::read( s, 1, sizeof(Int_32), (char *)&ck.formatNumber );
+		BigEndian::read( s, 1, sizeof(Int_32), (char *)&ck.originalFormatNumber );
+
+		BigEndian::read( s, 1, sizeof(Int_32), (char *)&ck.ftLength );
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&ck.winWidth );
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&ck.winAtten );
+		BigEndian::read( s, 1, sizeof(Int_32), (char *)&ck.hopSize );
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&ck.sampleRate );
+		
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&ck.noiseFloor );
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&ck.peakAmpRange );
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&ck.maskingRolloff );
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&ck.peakSeparation );
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&ck.freqDrift );
+	}
+	catch( FileIOException & ex ) 
+	{
+		ex.append( "Failed to read badly-formatted Lemur file (bad Parameters chunk)." );
+		throw;
+	}
+	
+	if ( ck.formatNumber != FormatNumber ) 
+	{
+		Throw( FileIOException, "File has wrong Lemur format for Lemur 5 import." );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	readTrackHeader
+// ---------------------------------------------------------------------------
+//	Read from current position.
+//
+static void 
+readTrackHeader( std::istream & s, TrackOnDisk & t )
+{
+	try 
+	{
+		BigEndian::read( s, 1, sizeof(Double_64), (char *)&t.startTime );
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&t.initialPhase );
+		BigEndian::read( s, 1, sizeof(Uint_32), (char *)&t.numPeaks );
+		BigEndian::read( s, 1, sizeof(Int_32), (char *)&t.label );
+	}
+	catch( FileIOException & ex ) 
+	{
+		ex.append( "Failed to read track data in Lemur 5 import." );
+		throw;
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	readPeakData
+// ---------------------------------------------------------------------------
+//	Read from current position.
+//
+static void 
+readPeakData( std::istream & s, PeakOnDisk & p )
+{
+	try 
+	{
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&p.magnitude );
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&p.frequency );
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&p.interpolatedFrequency );
+		BigEndian::read( s, 1, sizeof(Float_32), (char *)&p.bandwidth );
+		BigEndian::read( s, 1, sizeof(Double_64), (char *)&p.ttn );
+	}
+	catch( FileIOException & ex ) 
+	{
+		ex.append( "Failed to read peak data in Lemur 5 import." );
+		throw;
+	}
+}
+}	//	end of namespace Loris
diff --git a/src/loris/ImportLemur.h b/src/loris/ImportLemur.h
new file mode 100644
index 0000000..e887e64
--- /dev/null
+++ b/src/loris/ImportLemur.h
@@ -0,0 +1,84 @@
+#ifndef INCLUDE_IMPORTLEMUR_H
+#define INCLUDE_IMPORTLEMUR_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * ImportLemur.h
+ *
+ * Definition of class Loris::ImportLemur for importing Partials stored 
+ * in Lemur 5 alpha files.
+ *
+ * Kelly Fitz, 10 Sept 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "PartialList.h"
+#include "LorisExceptions.h"
+#include <string>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	class ImportLemur
+//
+class ImportLemur
+{
+//	-- instance variables --
+	PartialList _partials;	//	collect Partials here
+
+//	-- public interface --
+public:
+//	construction:
+//	(compiler can generate destructor)
+	ImportLemur( const std::string & fname, double bweCutoff = 1000 );
+
+//	PartialList access:
+	PartialList & partials( void ) { return _partials; }
+	const PartialList & partials( void ) const { return _partials; }
+	
+//	-- unimplemented --
+private:
+	ImportLemur( const ImportLemur & other );
+	ImportLemur  & operator = ( const ImportLemur & rhs );
+	
+};	//	end of class ImportLemur
+
+// ---------------------------------------------------------------------------
+//	class ImportException
+//
+//	Class of exceptions thrown when there is an error importing
+//	Partials.
+//
+class ImportException : public Exception
+{
+public: 
+	ImportException( const std::string & str, const std::string & where = "" ) : 
+		Exception( std::string("Import Error -- ").append( str ), where ) {}		
+};
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_IMPORTLEMUR_H */
diff --git a/src/loris/KaiserWindow.C b/src/loris/KaiserWindow.C
new file mode 100644
index 0000000..c7f3952
--- /dev/null
+++ b/src/loris/KaiserWindow.C
@@ -0,0 +1,247 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * KaiserWindow.C
+ *
+ * Implementation of class Loris::KaiserWindow.
+ *
+ * Kelly Fitz, 14 Dec 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+    #include "config.h"
+#endif
+
+#include "KaiserWindow.h"
+#include "LorisExceptions.h"
+#include <cmath>
+
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+    const double Pi = M_PI;
+#else
+    const double Pi = 3.14159265358979324;
+#endif
+
+using namespace std;
+
+//  begin namespace
+namespace Loris {
+
+//  prototypes for static helpers, defined below
+static double zeroethOrderBessel( double x );
+static double firstOrderBessel( double x );
+
+// ---------------------------------------------------------------------------
+//  buildWindow
+// ---------------------------------------------------------------------------
+//! Build a new Kaiser analysis window having the specified shaping
+//! parameter. See Oppenheim and Schafer:  "Digital Signal Processing" 
+//! (1975), p. 452 for further explanation of the Kaiser window. Also, 
+//! see Kaiser and Schafer, 1980.
+//!
+//! \param      win is the vector that will store the window
+//!             samples. The number of samples computed will be
+//!             equal to the length of this vector. Any previous
+//!             contents will be overwritten.
+//! \param      shape is the Kaiser shaping parameter, controlling
+//!             the sidelobe rejection level.
+//
+void
+KaiserWindow::buildWindow( vector< double > & win, double shape )
+{   
+    //  Pre-compute the shared denominator in the Kaiser equation. 
+    const double oneOverDenom = 1.0 / zeroethOrderBessel( shape );
+  
+    const unsigned int N = win.size() - 1;
+    const double oneOverN = 1.0 / N;
+    
+    for ( unsigned int n = 0; n <= N; ++n )
+    {
+        const double K = (2.0 * n * oneOverN) - 1.0;
+        const double arg = sqrt( 1.0 - (K * K) );
+        
+        win[n] = zeroethOrderBessel( shape * arg ) * oneOverDenom;
+    }
+}
+
+// ---------------------------------------------------------------------------
+//  createDerivativeWindow
+// ---------------------------------------------------------------------------
+//! Build a new time-derivative Kaiser analysis window having the
+//! specified shaping parameter, for computing frequency reassignment.
+//! The closed form for the time derivative can be obtained from the
+//! property of modified Bessel functions that the derivative of the
+//! zeroeth order function is equal to the first order function.
+//!
+//! \param      win is the vector that will store the window
+//!             samples. The number of samples computed will be
+//!             equal to the length of this vector. Any previous
+//!             contents will be overwritten.
+//! \param      shape is the Kaiser shaping parameter, controlling
+//!             the sidelobe rejection level.
+//
+void
+KaiserWindow::buildTimeDerivativeWindow( vector< double > & win, double shape )
+{   
+    //  Pre-compute the common factor that does not depend on n.
+    const unsigned int N = win.size() - 1;
+    const double oneOverN = 1.0 / N;
+    
+    const double commonFac = - 2.0 * shape / (N * zeroethOrderBessel( shape ) );
+  
+    //  w'[0] = w'[N] = 0
+    win[0] = win[N] = 0.0;
+    
+    for ( unsigned int n = 1; n < N; ++n )
+    {
+        const double K = (2.0 * n * oneOverN) - 1.0;
+        const double arg = sqrt( 1.0 - (K * K) );
+        
+        win[n] = commonFac * firstOrderBessel( shape * arg ) * K / arg;
+    }
+}
+
+
+// ---------------------------------------------------------------------------
+//  zeroethOrderBessel
+// ---------------------------------------------------------------------------
+//  Compute the zeroeth order modified Bessel function of the first kind 
+//  at x using the series expansion, used to compute the Kasier window
+//  function.
+//
+static double zeroethOrderBessel( double x )
+{
+    const double eps = 0.000001;
+    
+    //  initialize the series term for m=0 and the result
+    double besselValue = 0;
+    double term = 1;
+    double m = 0;
+    
+    //  accumulate terms as long as they are significant
+    while(term  > eps * besselValue)
+    {
+        besselValue += term;
+        
+        //  update the term
+        ++m;
+        term *= (x*x) / (4*m*m);
+    }
+    
+    return besselValue;
+}
+
+// ---------------------------------------------------------------------------
+//  firstOrderBessel
+// ---------------------------------------------------------------------------
+//  Compute the first order modified Bessel function of the first kind 
+//  at x using the series expansion, used to compute the time derivative
+//  of the Kasier window function for computing frequency reassignment.
+//
+static double firstOrderBessel( double x )
+{
+    const double eps = 0.000001;
+    
+    //  initialize the series term for m=0 and the result
+    double besselValue = 0;
+    double term = .5*x;
+    double m = 0;
+    
+    //  accumulate terms as long as they are significant
+    while(term  > eps * besselValue)
+    {
+        besselValue += term;
+        
+        //  update the term
+        ++m;
+        term *= (x*x) / (4*m*(m+1));
+    }
+    
+    return besselValue;
+}
+
+// ---------------------------------------------------------------------------
+//  computeShape
+// ---------------------------------------------------------------------------
+//  Compute the Kaiser window shaping parameter from the specified attenuation 
+//  of side lobes. This algorithm is given in Kaiser an Schafer,1980 and is 
+//  supposed to give better than 0.36% accuracy (Kaiser and Schafer 1980).
+//
+double
+KaiserWindow::computeShape( double atten )
+{
+    if ( atten < 0. )
+    {
+        Throw( InvalidArgument, 
+        	   "Kaiser window shape must be computed from positive (> 0dB)"
+        	   " sidelobe attenuation. (received attenuation < 0)" );
+	}
+	
+    double alpha;
+    
+    if ( atten > 60.0 )
+    {
+        alpha = 0.12438 * (atten + 6.3);
+    }
+    else if ( atten > 13.26 )
+    {
+        alpha = 0.76609L * ( pow((atten - 13.26), 0.4) ) + 
+                            0.09834L * (atten - 13.26L);
+    }
+    else
+    {
+        //  can't have less than 13dB.
+        alpha = 0.0;
+    }
+    
+    return alpha;
+}
+// ---------------------------------------------------------------------------
+//  computeLength
+// ---------------------------------------------------------------------------
+//  Compute the length (in samples) of the Kaiser window from the desired 
+//  (approximate) main lobe width and the control parameter. Of course, since 
+//  the window must be an integer number of samples in length, your actual 
+//  lobal mileage may vary. This equation appears in Kaiser and Schafer 1980
+//  (on the use of the I0 window class for spectral analysis) as Equation 9.
+//
+//  The main width of the main lobe must be normalized by the sample rate,
+//  that is, it is a fraction of the sample rate.
+//
+unsigned long
+KaiserWindow::computeLength( double width, double alpha )
+{
+    //double alpha = computeShape( atten );
+
+    //  The last 0.5 is cheap rounding.
+    //  But I think I don't need cheap rounding because the equation 
+    //  from Kaiser and Schafer has a +1 that appears to be a cheap
+    //  ceiling function.
+    return long(1.0 + (2. * sqrt((Pi*Pi) + (alpha*alpha)) / (Pi * width)) /* + 0.5 */);
+}
+
+}   //  end of namespace Loris
+
diff --git a/src/loris/KaiserWindow.h b/src/loris/KaiserWindow.h
new file mode 100644
index 0000000..d0ba494
--- /dev/null
+++ b/src/loris/KaiserWindow.h
@@ -0,0 +1,112 @@
+#ifndef INCLUDE_KAISERWINDOW_H
+#define INCLUDE_KAISERWINDOW_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * KaiserWindow.h
+ *
+ * Definition of class Loris::KaiserWindow.
+ *
+ * Kelly Fitz, 14 Dec 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include <vector>
+
+//  begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//  class KaiserWindow
+//
+//! Computes samples of a Kaiser window 
+//! function (see Kaiser and Schafer, 1980) for windowing FFT data.
+//
+class KaiserWindow
+{
+//  -- public interface --
+public:
+
+    //  -- window building --
+    
+    //! Build a new Kaiser analysis window having the specified shaping
+    //! parameter. See Oppenheim and Schafer:  "Digital Signal Processing" 
+    //! (1975), p. 452 for further explanation of the Kaiser window. Also, 
+    //! see Kaiser and Schafer, 1980.
+    //!
+    //! \param      win is the vector that will store the window
+    //!             samples. The number of samples computed will be
+    //!             equal to the length of this vector. Any previous
+    //!             contents will be overwritten.
+    //! \param      shape is the Kaiser shaping parameter, controlling
+    //!             the sidelobe rejection level.
+    static void buildWindow( std::vector< double > & win, double shape );
+    
+    //! Build a new time-derivative Kaiser analysis window having the
+    //! specified shaping parameter, for computing frequency reassignment.
+    //! The closed form for the time derivative can be obtained from the
+    //! property of modified Bessel functions that the derivative of the
+    //! zeroeth order function is equal to the first order function.
+    //!
+    //! \param      win is the vector that will store the window
+    //!             samples. The number of samples computed will be
+    //!             equal to the length of this vector. Any previous
+    //!             contents will be overwritten.
+    //! \param      shape is the Kaiser shaping parameter, controlling
+    //!             the sidelobe rejection level.
+    static void buildTimeDerivativeWindow( std::vector< double > & win, double shape );    
+    
+    
+    //  -- window parameter estimation --
+    
+    //! Compute a shaping parameter that will achieve the specified
+    //! level of sidelobe rejection.
+    //!
+    //! \param      atten is the desired sidelobe attenuation in
+    //!             positive decibels (e.g. 65 dB)
+    //! \returns    the Kaiser shaping paramater
+    static double computeShape( double atten );
+
+    //! Compute the necessary length in samples of a Kaiser window
+    //! having the specified shaping parameter that has the
+    //! desired main lobe width.
+    //!
+    //! \param      width is the desired main lobe width expressed
+    //!             as a fraction of the sample rate.
+    //! \param      alpha is the Kaiser shaping parameter (the
+    //!             main lobe width is influenced primarily by the
+    //!             window length,but also by the shape).
+    //! \returns    the window length in samples
+    static unsigned long computeLength( double width, double alpha );
+
+//  construction is not allowed:
+private:
+    KaiserWindow( void );
+    
+};  // end of class KaiserWindow
+
+}   //  end of namespace Loris
+
+#endif /* ndef INCLUDE_KAISERWINDOW_H */
diff --git a/src/loris/LinearEnvelope.C b/src/loris/LinearEnvelope.C
new file mode 100644
index 0000000..13d59ec
--- /dev/null
+++ b/src/loris/LinearEnvelope.C
@@ -0,0 +1,190 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * LinearEnvelope.C
+ *
+ * Implementation of class LinearEnvelope.
+ *
+ * Kelly Fitz, 23 April 2005
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "LinearEnvelope.h"
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	constructor
+// ---------------------------------------------------------------------------
+//!	Construct a new LinearEnvelope having no 
+//!	breakpoints (and an implicit value of 0 everywhere).		
+//
+LinearEnvelope::LinearEnvelope( void )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	constructor with initial (or constant) value
+// ---------------------------------------------------------------------------
+//!	Construct and return a new LinearEnvelope having a 
+//!	single breakpoint at 0 (and an implicit value everywhere)
+//!	of initialValue.		
+//!	
+//!	\param   initialValue is the value of this LinearEnvelope
+//!            at time 0.	
+//
+LinearEnvelope::LinearEnvelope( double initialValue )
+{
+	insertBreakpoint( 0., initialValue );
+}
+
+// ---------------------------------------------------------------------------
+//	clone
+// ---------------------------------------------------------------------------
+//!	Return an exact copy of this LinearEnvelope
+//!	(polymorphic copy, following the Prototype pattern).
+//
+LinearEnvelope * 
+LinearEnvelope::clone( void ) const
+{
+	return new LinearEnvelope( *this );
+}
+
+// ---------------------------------------------------------------------------
+//	insert
+// ---------------------------------------------------------------------------
+//!	Insert a breakpoint representing the specified (time, value) 
+//!	pair into this LinearEnvelope. If there is already a 
+//!	breakpoint at the specified time, it will be replaced with 
+//!	the new breakpoint.
+//!	
+//!	\param   time is the time at which to insert a new breakpoint
+//!	\param   value is the value of the new breakpoint
+//	
+void
+LinearEnvelope::insert( double time, double value )
+{
+	(*this)[time] = value;
+}
+
+// ---------------------------------------------------------------------------
+//	operator+=
+// ---------------------------------------------------------------------------
+//! Add a constant value to this LinearEnvelope and return a reference
+//! to self.
+//!
+//! \param  offset is the value to add to all points in the envelope
+LinearEnvelope & LinearEnvelope::operator+=( double offset )
+{
+    for ( iterator it = begin(); it != end(); ++it )
+    {
+        it->second += offset;
+    }
+    return *this;
+}
+
+// ---------------------------------------------------------------------------
+//	operator*=
+// ---------------------------------------------------------------------------
+//! Scale this LinearEnvelope by a constant value and return a reference
+//! to self.
+//!
+//! \param  scale is the value by which to multiply to all points in 
+//!         the envelope
+LinearEnvelope & LinearEnvelope::operator*=( double scale )
+{
+    for ( iterator it = begin(); it != end(); ++it )
+    {
+        it->second *= scale;
+    }
+    return *this;
+}
+
+// ---------------------------------------------------------------------------
+//	operator/ (non-member binary operator)
+// ---------------------------------------------------------------------------
+//! Divide constant value by a LinearEnvelope and return a new 
+//! LinearEnvelope. No shortcut implementation for this one, 
+//! don't inline.
+LinearEnvelope operator/( double num, LinearEnvelope env )
+{
+    for ( LinearEnvelope::iterator it = env.begin(); it != env.end(); ++it )
+    {
+        it->second = num / it->second;
+    }
+    
+    return env;
+}
+
+// ---------------------------------------------------------------------------
+//	valueAt
+// ---------------------------------------------------------------------------
+//!	Return the linearly-interpolated value of this LinearEnvelope at 
+//!	the specified time.
+//!	
+//!	\param   t is the time at which to evaluate this LinearEnvelope.
+//
+double
+LinearEnvelope::valueAt( double t ) const
+{
+	//	return zero if no breakpoints have been specified:
+	if ( size() == 0 ) 
+	{
+		return 0.;
+	}
+
+	const_iterator it = lower_bound( t );
+
+	if ( it == begin() ) 
+	{
+		//	t is less than the first breakpoint, extend:
+		return it->second;
+	}
+	else if ( it == end() ) 
+	{
+		//	t is greater than the last breakpoint, extend:
+		// 	(no direct way to access the last element of a map)
+		return (--it)->second;
+	}
+	else 
+	{
+		//	linear interpolation between consecutive breakpoints:
+		double xgreater = it->first;
+		double ygreater = it->second;
+		--it;
+		double xless = it->first;
+		double yless = it->second;
+		
+		double alpha = (t -  xless) / (xgreater - xless);
+		return ( alpha * ygreater ) + ( (1. - alpha) * yless );
+	}
+}
+
+}	//	end of namespace Loris
diff --git a/src/loris/LinearEnvelope.h b/src/loris/LinearEnvelope.h
new file mode 100644
index 0000000..be06f69
--- /dev/null
+++ b/src/loris/LinearEnvelope.h
@@ -0,0 +1,303 @@
+#ifndef INCLUDE_LINEARENVELOPE_H
+#define INCLUDE_LINEARENVELOPE_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * LinearEnvelope.h
+ *
+ * Definition of class LinearEnvelope.
+ *
+ * Kelly Fitz, 23 April 2005
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "Envelope.h"
+#include <map>
+
+//  begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//  class LinearEnvelope
+//
+//! A LinearEnvelope represents a linear segment breakpoint function
+//! with infinite extension at each end (that is, evalutaing the
+//! envelope past either end of the breakpoint function yields the 
+//! value at the nearest end point).
+//!
+//! LinearEnvelope implements the Envelope interface, described
+//! by the abstract class Envelope. 
+//!
+//! LinearEnvelope inherits the types
+//!     \li \c size_type
+//!     \li \c value_type
+//!     \li \c iterator
+//!     \li \c const_iterator
+//!
+//! and the member functions
+//!     \li size_type size( void ) const
+//!     \li bool empty( void ) const
+//!     \li iterator begin( void )
+//!     \li const_iterator begin( void ) const
+//!     \li iterator end( void )
+//!     \li const_iterator end( void ) const
+//!
+//! from std::map< double, double >.
+//
+class LinearEnvelope : public Envelope, private std::map< double, double >
+{
+//  -- public interface --
+public:
+//  -- construction --
+
+    //! Construct a new LinearEnvelope having no 
+    //! breakpoints (and an implicit value of 0 everywhere).        
+    LinearEnvelope( void );
+
+    //! Construct and return a new LinearEnvelope having a 
+    //! single breakpoint at 0 (and an implicit value everywhere)
+    //! of initialValue.        
+    //! 
+    //! \param   initialValue is the value of this LinearEnvelope
+    //!            at time 0.   
+    explicit LinearEnvelope( double initialValue );
+
+    //  compiler-generated copy, assignment, and destruction are OK.
+    
+//  -- Envelope interface --
+
+    //! Return an exact copy of this LinearEnvelope
+    //! (polymorphic copy, following the Prototype pattern).
+    virtual LinearEnvelope * clone( void ) const;
+
+    //! Return the linearly-interpolated value of this LinearEnvelope at 
+    //! the specified time.
+    //! 
+    //! \param  t is the time at which to evaluate this 
+    //!         LinearEnvelope.
+    virtual double valueAt( double t ) const;   
+        
+    
+//  -- envelope composition --
+
+    //! Insert a breakpoint representing the specified (time, value) 
+    //! pair into this LinearEnvelope. If there is already a 
+    //! breakpoint at the specified time, it will be replaced with 
+    //! the new breakpoint.
+    //! 
+    //! \param   time is the time at which to insert a new breakpoint
+    //! \param   value is the value of the new breakpoint
+    void insert( double time, double value );
+    
+    //! Insert a breakpoint representing the specified (time, value) 
+    //! pair into this LinearEnvelope. Same as insert, retained
+    //! for backwards-compatibility.
+    //! 
+    //! \param   time is the time at which to insert a new breakpoint
+    //! \param   value is the value of the new breakpoint
+    void insertBreakpoint( double time, double value ) 
+         { insert( time, value ); }
+         
+         
+    //! Add a constant value to this LinearEnvelope and return a reference
+    //! to self.
+    //!
+    //! \param  offset is the value to add to all points in the envelope
+    LinearEnvelope & operator+=( double offset );
+
+    //! Subtract a constant value from this LinearEnvelope and return a reference
+    //! to self.
+    //!
+    //! \param  offset is the value to subtract from all points in the envelope
+    LinearEnvelope & operator-=( double offset )
+    {
+        return operator+=( -offset );
+    }
+
+    //! Scale this LinearEnvelope by a constant value and return a reference
+    //! to self.
+    //!
+    //! \param  scale is the value by which to multiply to all points in 
+    //!         the envelope
+    LinearEnvelope & operator*=( double scale );
+
+    //! Divide this LinearEnvelope by a constant value and return a reference
+    //! to self.
+    //!
+    //! \param  div is the value by which to divide to all points in 
+    //!         the envelope
+    LinearEnvelope & operator/=( double div )
+    {
+        return operator*=( 1.0 / div );
+    }
+
+//  -- interface inherited from std::map --
+
+    using std::map< double, double >::size;
+    using std::map< double, double >::empty;
+    using std::map< double, double >::clear;
+    using std::map< double, double >::begin;
+    using std::map< double, double >::end;
+    using std::map< double, double >::size_type;
+    using std::map< double, double >::value_type;
+    using std::map< double, double >::iterator;
+    using std::map< double, double >::const_iterator;
+
+};  //  end of class LinearEnvelope
+
+
+//  --  binary operators (inline nonmembers) --
+
+//! Add a constant value to a LinearEnvelope and return a new 
+//! LinearEnvelope.
+inline
+LinearEnvelope operator+( LinearEnvelope env, double offset )
+{
+    env += offset;
+    return env;
+}
+
+//! Add a constant value to a LinearEnvelope and return a new 
+//! LinearEnvelope.
+inline
+LinearEnvelope operator+( double offset, LinearEnvelope env )
+{
+    env += offset;
+    return env;
+}
+
+//! Add two LinearEnvelopes and return a new LinearEnvelope.
+inline
+LinearEnvelope operator+( const LinearEnvelope & e1, const LinearEnvelope & e2 )
+{
+	LinearEnvelope ret;
+	
+	//	For each breakpoint in e1, insert a breakpoint having a value
+	//	equal to the sum of the two envelopes at that time.
+	for ( LinearEnvelope::const_iterator it = e1.begin(); it != e1.end(); ++it )
+	{
+		double t = it->first;
+		double v = it->second;
+			
+		ret.insert( t, v + e2.valueAt( t ) );
+	}
+	
+	//	For each breakpoint in e2, insert a breakpoint having a value
+	//	equal to the sum of the two envelopes at that time.
+	for ( LinearEnvelope::const_iterator it = e2.begin(); it != e2.end(); ++it )
+	{
+		double t = it->first;
+		double v = it->second;
+			
+		ret.insert( t, v + e1.valueAt( t ) );
+	}
+
+    return ret;
+}
+
+//! Subtract a constant value from a LinearEnvelope and return a new 
+//! LinearEnvelope.
+inline
+LinearEnvelope operator-( LinearEnvelope env, double offset )
+{
+    env -= offset;
+    return env;
+}
+
+//! Subtract a LinearEnvelope from a constant value and return a new 
+//! LinearEnvelope.
+inline
+LinearEnvelope operator-( double offset, LinearEnvelope env )
+{
+    env *= -1.0;
+    env += offset;
+    return env;
+}
+
+//! Subtract two LinearEnvelopes and return a new LinearEnvelope.
+inline
+LinearEnvelope operator-( const LinearEnvelope & e1, const LinearEnvelope & e2 )
+{
+	LinearEnvelope ret;
+	
+	//	For each breakpoint in e1, insert a breakpoint having a value
+	//	equal to the difference between the two envelopes at that time.
+	for ( LinearEnvelope::const_iterator it = e1.begin(); it != e1.end(); ++it )
+	{
+		double t = it->first;
+		double v = it->second;
+			
+		ret.insert( t, v - e2.valueAt( t ) );
+	}
+	
+	//	For each breakpoint in e2, insert a breakpoint having a value
+	//	equal to the difference between the two envelopes at that time.
+	for ( LinearEnvelope::const_iterator it = e2.begin(); it != e2.end(); ++it )
+	{
+		double t = it->first;
+		double v = it->second;
+			
+		ret.insert( t, e1.valueAt( t ) - v );
+	}
+
+    return ret;
+}
+
+//! Scale a LinearEnvelope by a constant value and return a new 
+//! LinearEnvelope.
+inline
+LinearEnvelope operator*( LinearEnvelope env, double scale )
+{
+    env *= scale;
+    return env;
+}
+
+//! Scale a LinearEnvelope by a constant value and return a new 
+//! LinearEnvelope.
+inline
+LinearEnvelope operator*( double scale, LinearEnvelope env )
+{
+    env *= scale;
+    return env;
+}
+
+//! Divide a LinearEnvelope by a constant value and return a new 
+//! LinearEnvelope.
+inline
+LinearEnvelope operator/( LinearEnvelope env, double div )
+{
+    env /= div;
+    return env;
+}
+
+//! Divide constant value by a LinearEnvelope and return a new 
+//! LinearEnvelope. No shortcut implementation for this one, 
+//! don't inline.
+LinearEnvelope operator/( double scale, LinearEnvelope env );
+
+
+}   //  end of namespace Loris
+
+#endif /* ndef INCLUDE_LINEARENVELOPE_H */
diff --git a/src/loris/LorisExceptions.C b/src/loris/LorisExceptions.C
new file mode 100644
index 0000000..ccccba4
--- /dev/null
+++ b/src/loris/LorisExceptions.C
@@ -0,0 +1,86 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * LorisExceptions.C
+ *
+ * Implementation of class Exception, a generic exception class.
+ *
+ * This file was formerly called Exception.C, and had a corresponding header
+ * called Exception.h but that filename caused build problems on case-insensitive 
+ * systems that sometimes had system headers called exception.h. So the header
+ * name was changed to LorisExceptions.h, and this source files name was
+ * changed to match. 
+ *
+ * Kelly Fitz, 17 Oct 2006
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "LorisExceptions.h"
+#include <string>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	Exception constructor
+// ---------------------------------------------------------------------------
+//! Construct a new instance with the specified description and, optionally
+//! a string identifying the location at which the exception as thrown. The
+//! Throw( Exception_Class, description_string ) macro generates a location
+//! string automatically using __FILE__ and __LINE__.
+//!
+//! \param  str is a string describing the exceptional condition
+//! \param  where is an option string describing the location in
+//!         the source code from which the exception was thrown
+//!         (generated automatically byt he Throw macro).
+//
+Exception::Exception( const std::string & str, const std::string & where ) :
+	_sbuf( str )
+{
+	_sbuf.append( where );
+	_sbuf.append(" ");
+}
+	
+// ---------------------------------------------------------------------------
+//	append 
+// ---------------------------------------------------------------------------
+//! Append the specified string to this Exception's description,
+//! and return a reference to this Exception.
+//! 
+//! \param  str is text to append to the exception description
+//! \return a reference to this Exception.
+//
+Exception & 
+Exception::append( const std::string & str )
+{
+	_sbuf.append(str);
+	return *this;
+}
+
+}	//	end of namespace Loris
diff --git a/src/loris/LorisExceptions.h b/src/loris/LorisExceptions.h
new file mode 100644
index 0000000..d0537e0
--- /dev/null
+++ b/src/loris/LorisExceptions.h
@@ -0,0 +1,308 @@
+#ifndef INCLUDE_EXCEPTIONS_H
+#define INCLUDE_EXCEPTIONS_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * LorisExceptions.h
+ *
+ * Definition of class Exception, a generic exception class, and 
+ * commonly-used derived exception classes. 
+ *
+ * This file was formerly called Exception.h, but that filename caused build
+ * problems on case-insensitive systems that sometimes had system headers
+ * called exception.h.
+ *
+ * Kelly Fitz, 17 Oct 2006
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#include <stdexcept>
+#include <string>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	class Exception
+//
+//! Exception is a generic exception class for reporting exceptional 
+//! circumstances in Loris. Exception is derived from std:exception, 
+//! and is the base for a hierarchy of derived exception classes
+//! in Loris.
+//!
+//
+class Exception : public std::exception
+{
+//	-- public interface --
+public:
+//	--- lifecycle ---
+
+	//! Construct a new instance with the specified description and, optionally
+	//! a string identifying the location at which the exception as thrown. The
+	//! Throw( Exception_Class, description_string ) macro generates a location
+   //! string automatically using __FILE__ and __LINE__.
+   //!
+   //! \param  str is a string describing the exceptional condition
+   //! \param  where is an option string describing the location in
+   //!         the source code from which the exception was thrown
+   //!         (generated automatically by the Throw macro).
+	Exception( const std::string & str, const std::string & where = "" );
+	 
+	//! Destroy this Exception.
+	virtual ~Exception( void ) throw() 
+	{
+	}
+
+//	--- access/mutation ---
+
+	//! Return a description of this Exception in the form of a
+   //! C-style string (char pointer). Overrides std::exception::what.
+   //!
+   //! \return a C-style string describing the exceptional condition.
+	const char * what( void ) const throw() { return _sbuf.c_str(); }
+	 
+	//! Append the specified string to this Exception's description,
+	//! and return a reference to this Exception.
+	//! 
+	//! \param  str is text to append to the exception description
+	//! \return a reference to this Exception.
+	Exception & append( const std::string & str );
+	 
+	//! Return a read-only refernce to this Exception's 
+	//! description string.
+	//!
+	//! \return a string describing the exceptional condition
+	const std::string & str( void ) const 
+	{ 
+	   return _sbuf; 
+	}
+
+//	-- instance variables --
+protected:
+
+	//! string for storing the exception description
+	std::string _sbuf;
+	
+};	//	end of class Exception
+
+// ---------------------------------------------------------------------------
+//	class AssertionFailure
+//
+//! Class of exceptions thrown when an assertion (usually representing an
+//! invariant condition, and usually detected by the Assert macro) is
+//! violated.
+// 
+class AssertionFailure : public Exception
+{
+public: 
+
+	//! Construct a new instance with the specified description and, optionally
+	//! a string identifying the location at which the exception as thrown. The
+	//! Throw( Exception_Class, description_string ) macro generates a location
+   //! string automatically using __FILE__ and __LINE__.
+   //!
+   //! \param  str is a string describing the exceptional condition
+   //! \param  where is an option string describing the location in
+   //!         the source code from which the exception was thrown
+   //!         (generated automatically by the Throw macro).
+	AssertionFailure( const std::string & str, const std::string & where = "" ) : 
+		Exception( std::string("Assertion failed -- ").append( str ), where ) 
+	{
+	}
+	
+};	//	end of class AssertionFailure
+
+// ---------------------------------------------------------------------------
+//	class IndexOutOfBounds
+//
+//! Class of exceptions thrown when a subscriptable object is accessed
+//! with an index that is out of range.
+//
+class IndexOutOfBounds : public Exception
+{
+public: 
+
+	//! Construct a new instance with the specified description and, optionally
+	//! a string identifying the location at which the exception as thrown. The
+	//! Throw( Exception_Class, description_string ) macro generates a location
+   //! string automatically using __FILE__ and __LINE__.
+   //!
+   //! \param  str is a string describing the exceptional condition
+   //! \param  where is an option string describing the location in
+   //!         the source code from which the exception was thrown
+   //!         (generated automatically by the Throw macro).
+	IndexOutOfBounds( const std::string & str, const std::string & where = "" ) : 
+		Exception( std::string("Index out of bounds -- ").append( str ), where ) {}
+		
+};	//	end of class IndexOutOfBounds
+
+
+// ---------------------------------------------------------------------------
+//	class InvalidObject
+//
+//! Class of exceptions thrown when an object is found to be badly configured
+//! or otherwise invalid.
+//
+class InvalidObject : public Exception
+{
+public: 
+
+	//! Construct a new instance with the specified description and, optionally
+	//! a string identifying the location at which the exception as thrown. The
+	//! Throw( Exception_Class, description_string ) macro generates a location
+   //! string automatically using __FILE__ and __LINE__.
+   //!
+   //! \param  str is a string describing the exceptional condition
+   //! \param  where is an option string describing the location in
+   //!         the source code from which the exception was thrown
+   //!         (generated automatically by the Throw macro).
+	InvalidObject( const std::string & str, const std::string & where = "" ) : 
+		Exception( std::string("Invalid configuration or object -- ").append( str ), where ) 
+	{
+	}
+	
+};	//	end of class InvalidObject
+
+// ---------------------------------------------------------------------------
+//	class InvalidIterator
+//
+//! Class of exceptions thrown when an Iterator is found to be badly configured
+//! or otherwise invalid.
+//
+class InvalidIterator : public InvalidObject
+{
+public: 
+
+	//! Construct a new instance with the specified description and, optionally
+	//! a string identifying the location at which the exception as thrown. The
+	//! Throw( Exception_Class, description_string ) macro generates a location
+   //! string automatically using __FILE__ and __LINE__.
+   //!
+   //! \param  str is a string describing the exceptional condition
+   //! \param  where is an option string describing the location in
+   //!         the source code from which the exception was thrown
+   //!         (generated automatically by the Throw macro).
+	InvalidIterator( const std::string & str, const std::string & where = "" ) : 
+		InvalidObject( std::string("Invalid Iterator -- ").append( str ), where ) 
+	{
+	}
+	
+};	//	end of class InvalidIterator
+
+// ---------------------------------------------------------------------------
+//	class InvalidArgument
+//
+//! Class of exceptions thrown when a function argument is found to be invalid.
+//
+class InvalidArgument : public Exception
+{
+public: 
+
+	//! Construct a new instance with the specified description and, optionally
+	//! a string identifying the location at which the exception as thrown. The
+	//! Throw( Exception_Class, description_string ) macro generates a location
+   //! string automatically using __FILE__ and __LINE__.
+   //!
+   //! \param  str is a string describing the exceptional condition
+   //! \param  where is an option string describing the location in
+   //!         the source code from which the exception was thrown
+   //!         (generated automatically by the Throw macro).
+	InvalidArgument( const std::string & str, const std::string & where = "" ) : 
+		Exception( std::string("Invalid Argument -- ").append( str ), where ) 
+	{
+	}
+	
+};	//	end of class InvalidArgument
+
+// ---------------------------------------------------------------------------
+//	class RuntimeError
+//
+//! Class of exceptions thrown when an unanticipated runtime error is 
+//! encountered.
+//
+class RuntimeError : public Exception
+{
+public: 
+
+	//! Construct a new instance with the specified description and, optionally
+	//! a string identifying the location at which the exception as thrown. The
+	//! Throw( Exception_Class, description_string ) macro generates a location
+   //! string automatically using __FILE__ and __LINE__.
+   //!
+   //! \param  str is a string describing the exceptional condition
+   //! \param  where is an option string describing the location in
+   //!         the source code from which the exception was thrown
+   //!         (generated automatically by the Throw macro).
+	RuntimeError( const std::string & str, const std::string & where = "" ) : 
+		Exception( std::string("Runtime Error -- ").append( str ), where ) 
+	{
+	}
+	
+};	//	end of class RuntimeError
+
+// ---------------------------------------------------------------------------
+//	class FileIOException
+//
+//! Class of exceptions thrown when file input or output fails.
+//
+class FileIOException : public RuntimeError
+{
+public: 
+
+	//! Construct a new instance with the specified description and, optionally
+	//! a string identifying the location at which the exception as thrown. The
+	//! Throw( Exception_Class, description_string ) macro generates a location
+   //! string automatically using __FILE__ and __LINE__.
+   //!
+   //! \param  str is a string describing the exceptional condition
+   //! \param  where is an option string describing the location in
+   //!         the source code from which the exception was thrown
+   //!         (generated automatically by the Throw macro).
+	FileIOException( const std::string & str, const std::string & where = "" ) : 
+		RuntimeError( std::string("File i/o error -- ").append( str ), where ) 
+   {
+   }
+   
+};	//	end of class FileIOException
+
+// ---------------------------------------------------------------------------
+//	macros for throwing exceptions
+//
+//	The compelling reason for using macros instead of inlines for all these
+//	things is that the __FILE__ and __LINE__ macros will be useful.
+//
+#define __STR(x) __VAL(x)
+#define __VAL(x) #x
+#define	Throw( exType, report )												\
+	throw exType( report, " ( " __FILE__ " line: " __STR(__LINE__) " )" )
+
+#define Assert(test)														\
+	do {																	\
+		if (!(test)) Throw( Loris::AssertionFailure, #test );				\
+	} while (false)
+
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_EXCEPTIONS_H */
diff --git a/src/loris/Makefile.am b/src/loris/Makefile.am
new file mode 100644
index 0000000..1dd3986
--- /dev/null
+++ b/src/loris/Makefile.am
@@ -0,0 +1,163 @@
+# Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+# <loris@cerlsoundgroup.org>
+#  
+# This file is free software; as a special exception the author gives
+# unlimited permission to copy and/or distribute it, with or without 
+# modifications, as long as this notice is preserved.
+# 
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# source code for Loris classes
+CPP_SRC = AiffData.C	\
+		AiffData.h \
+		AiffFile.C \
+		AiffFile.h \
+		Analyzer.C \
+		Analyzer.h \
+		AssociateBandwidth.C \
+		AssociateBandwidth.h \
+		BigEndian.C \
+		BigEndian.h \
+		Breakpoint.C \
+		Breakpoint.h \
+		BreakpointEnvelope.h \
+		BreakpointUtils.C \
+		BreakpointUtils.h \
+		Channelizer.C \
+		Channelizer.h \
+		Collator.C \
+		Collator.h \
+		Dilator.C \
+		Dilator.h \
+		Distiller.C \
+		Distiller.h \
+		Envelope.C \
+		Envelope.h \
+		F0Estimate.C \
+		F0Estimate.h \
+		LorisExceptions.C \
+		LorisExceptions.h \
+		Filter.C \
+		Filter.h \
+		FourierTransform.C \
+		FourierTransform.h \
+		FrequencyReference.C \
+		FrequencyReference.h \
+		Fundamental.C \
+		Fundamental.h \
+		Harmonifier.C \
+		Harmonifier.h \
+		ImportLemur.C \
+		ImportLemur.h \
+		KaiserWindow.C \
+		KaiserWindow.h \
+		LinearEnvelope.C \
+		LinearEnvelope.h \
+		Marker.C	\
+		Marker.h	\
+		Morpher.C \
+		Morpher.h \
+		NoiseGenerator.C \
+		NoiseGenerator.h \
+		Notifier.C \
+		Notifier.h \
+		Oscillator.C \
+		Oscillator.h \
+		Partial.C \
+		Partial.h \
+		PartialBuilder.C	\
+		PartialBuilder.h	\
+		PartialList.h \
+		PartialPtrs.h \
+		PartialUtils.C \
+		PartialUtils.h \
+		phasefix.C	\
+		phasefix.h	\
+		ReassignedSpectrum.C \
+		ReassignedSpectrum.h \
+		Resampler.C \
+		Resampler.h \
+		SdifFile.h \
+		SdifFile.C \
+		Sieve.h \
+		Sieve.C \
+		SpcFile.C \
+		SpcFile.h \
+		SpectralPeaks.h \
+		SpectralPeakSelector.C \
+		SpectralPeakSelector.h \
+		SpectralSurface.C \
+		SpectralSurface.h \
+		Synthesizer.C \
+		Synthesizer.h \
+        fftsg.c
+
+
+# source code for the procedural (C) interface
+PI_SRC = loris.h lorisAnalyzer_pi.C lorisBpEnvelope_pi.C \
+ lorisException_pi.C lorisException_pi.h lorisNonObj_pi.C \
+ lorisPartialList_pi.C lorisUtilities_pi.C 
+
+
+# convenience library containing Csound opcodes 
+if HAVE_CSOUND
+CSOUND_LIB = $(top_builddir)/csound/liblorisops.la
+endif
+
+
+lib_LTLIBRARIES = libloris.la
+libloris_la_SOURCES = $(CPP_SRC) $(PI_SRC)
+libloris_la_CPPFLAGS = $(INCLUDE_FFTW) $(default_includes)
+libloris_la_LIBADD = $(LINK_FFTW) $(CSOUND_LIB)
+
+# the library version for Loris 1.8 is 13:0:0
+libloris_la_LDFLAGS = -version-info 13:0:0 $(EXTRA_LD_FLAGS)
+
+# loris.h is generated automatically from loris.h.in
+nodist_include_HEADERS = loris.h
+EXTRA_DIST = loris.h.in
+
+# installed Loris header files
+pkginclude_HEADERS = \
+				AiffFile.h		\
+				Analyzer.h		\
+				BreakpointEnvelope.h	\
+				Breakpoint.h	\
+				BreakpointUtils.h	\
+				Channelizer.h	\
+				Collator.h	\
+				Dilator.h	\
+				Distiller.h	\
+				Envelope.h	\
+				Exception.h	\
+                F0Estimate.h \
+				Filter.h	\
+				FourierTransform.h	\
+				FrequencyReference.h \
+				Fundamental.h \
+				Harmonifier.h	\
+				ImportLemur.h	\
+				KaiserWindow.h	\
+				LinearEnvelope.h \
+				LorisExceptions.h	\
+				Marker.h	\
+				Morpher.h	\
+				NoiseGenerator.h \
+				Notifier.h	\
+				Oscillator.h	\
+				Partial.h	\
+				PartialList.h	\
+				PartialPtrs.h	\
+				PartialUtils.h	\
+				ReassignedSpectrum.h	\
+				Resampler.h \
+				SdifFile.h	\
+				Sieve.h	\
+				SpcFile.h	\
+				SpectralSurface.h	\
+				Synthesizer.h
+
+MAINTAINERCLEANFILES = Makefile.in
+
diff --git a/src/loris/Makefile.in b/src/loris/Makefile.in
new file mode 100644
index 0000000..c66a11d
--- /dev/null
+++ b/src/loris/Makefile.in
@@ -0,0 +1,1168 @@
+# Makefile.in generated by automake 1.11.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation,
+# Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+# Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+# <loris@cerlsoundgroup.org>
+#  
+# This file is free software; as a special exception the author gives
+# unlimited permission to copy and/or distribute it, with or without 
+# modifications, as long as this notice is preserved.
+# 
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src
+DIST_COMMON = README $(pkginclude_HEADERS) $(srcdir)/Makefile.am \
+	$(srcdir)/Makefile.in $(srcdir)/loris.h.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES = loris.h
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includedir)" \
+	"$(DESTDIR)$(pkgincludedir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+libloris_la_DEPENDENCIES = $(am__DEPENDENCIES_1) $(CSOUND_LIB)
+am__objects_1 = libloris_la-AiffData.lo libloris_la-AiffFile.lo \
+	libloris_la-Analyzer.lo libloris_la-AssociateBandwidth.lo \
+	libloris_la-BigEndian.lo libloris_la-Breakpoint.lo \
+	libloris_la-BreakpointUtils.lo libloris_la-Channelizer.lo \
+	libloris_la-Collator.lo libloris_la-Dilator.lo \
+	libloris_la-Distiller.lo libloris_la-Envelope.lo \
+	libloris_la-F0Estimate.lo libloris_la-LorisExceptions.lo \
+	libloris_la-Filter.lo libloris_la-FourierTransform.lo \
+	libloris_la-FrequencyReference.lo libloris_la-Fundamental.lo \
+	libloris_la-Harmonifier.lo libloris_la-ImportLemur.lo \
+	libloris_la-KaiserWindow.lo libloris_la-LinearEnvelope.lo \
+	libloris_la-Marker.lo libloris_la-Morpher.lo \
+	libloris_la-NoiseGenerator.lo libloris_la-Notifier.lo \
+	libloris_la-Oscillator.lo libloris_la-Partial.lo \
+	libloris_la-PartialBuilder.lo libloris_la-PartialUtils.lo \
+	libloris_la-phasefix.lo libloris_la-ReassignedSpectrum.lo \
+	libloris_la-Resampler.lo libloris_la-SdifFile.lo \
+	libloris_la-Sieve.lo libloris_la-SpcFile.lo \
+	libloris_la-SpectralPeakSelector.lo \
+	libloris_la-SpectralSurface.lo libloris_la-Synthesizer.lo \
+	libloris_la-fftsg.lo
+am__objects_2 = libloris_la-lorisAnalyzer_pi.lo \
+	libloris_la-lorisBpEnvelope_pi.lo \
+	libloris_la-lorisException_pi.lo libloris_la-lorisNonObj_pi.lo \
+	libloris_la-lorisPartialList_pi.lo \
+	libloris_la-lorisUtilities_pi.lo
+am_libloris_la_OBJECTS = $(am__objects_1) $(am__objects_2)
+libloris_la_OBJECTS = $(am_libloris_la_OBJECTS)
+libloris_la_LINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+	$(CXXFLAGS) $(libloris_la_LDFLAGS) $(LDFLAGS) -o $@
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/config/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=link $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) \
+	$(LDFLAGS) -o $@
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
+	--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
+	$(LDFLAGS) -o $@
+SOURCES = $(libloris_la_SOURCES)
+DIST_SOURCES = $(libloris_la_SOURCES)
+HEADERS = $(nodist_include_HEADERS) $(pkginclude_HEADERS)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AR = @AR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CSOUND = @CSOUND@
+CSOUND_CONFIG = @CSOUND_CONFIG@
+CSOUND_CXXFLAGS = @CSOUND_CXXFLAGS@
+CSOUND_PREFIX = @CSOUND_PREFIX@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DOXYGEN = @DOXYGEN@
+DSYMUTIL = @DSYMUTIL@
+ECHO = @ECHO@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+F77 = @F77@
+FFLAGS = @FFLAGS@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIBTOOL_DEPS = @LIBTOOL_DEPS@
+LINK_FFTW = @LINK_FFTW@
+LN_S = @LN_S@
+LORIS_MAJOR_VERSION = @LORIS_MAJOR_VERSION@
+LORIS_MINOR_VERSION = @LORIS_MINOR_VERSION@
+LORIS_SUBMINOR_VERSION = @LORIS_SUBMINOR_VERSION@
+LORIS_VERSION_STR = @LORIS_VERSION_STR@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MKDIR_P = @MKDIR_P@
+NMEDIT = @NMEDIT@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PYFLAGS = @PYFLAGS@
+PYTHON = @PYTHON@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_VERSION = @PYTHON_VERSION@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+SWIG = @SWIG@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_aux_dir = @ac_aux_dir@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_F77 = @ac_ct_F77@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+
+# source code for Loris classes
+CPP_SRC = AiffData.C	\
+		AiffData.h \
+		AiffFile.C \
+		AiffFile.h \
+		Analyzer.C \
+		Analyzer.h \
+		AssociateBandwidth.C \
+		AssociateBandwidth.h \
+		BigEndian.C \
+		BigEndian.h \
+		Breakpoint.C \
+		Breakpoint.h \
+		BreakpointEnvelope.h \
+		BreakpointUtils.C \
+		BreakpointUtils.h \
+		Channelizer.C \
+		Channelizer.h \
+		Collator.C \
+		Collator.h \
+		Dilator.C \
+		Dilator.h \
+		Distiller.C \
+		Distiller.h \
+		Envelope.C \
+		Envelope.h \
+		F0Estimate.C \
+		F0Estimate.h \
+		LorisExceptions.C \
+		LorisExceptions.h \
+		Filter.C \
+		Filter.h \
+		FourierTransform.C \
+		FourierTransform.h \
+		FrequencyReference.C \
+		FrequencyReference.h \
+		Fundamental.C \
+		Fundamental.h \
+		Harmonifier.C \
+		Harmonifier.h \
+		ImportLemur.C \
+		ImportLemur.h \
+		KaiserWindow.C \
+		KaiserWindow.h \
+		LinearEnvelope.C \
+		LinearEnvelope.h \
+		Marker.C	\
+		Marker.h	\
+		Morpher.C \
+		Morpher.h \
+		NoiseGenerator.C \
+		NoiseGenerator.h \
+		Notifier.C \
+		Notifier.h \
+		Oscillator.C \
+		Oscillator.h \
+		Partial.C \
+		Partial.h \
+		PartialBuilder.C	\
+		PartialBuilder.h	\
+		PartialList.h \
+		PartialPtrs.h \
+		PartialUtils.C \
+		PartialUtils.h \
+		phasefix.C	\
+		phasefix.h	\
+		ReassignedSpectrum.C \
+		ReassignedSpectrum.h \
+		Resampler.C \
+		Resampler.h \
+		SdifFile.h \
+		SdifFile.C \
+		Sieve.h \
+		Sieve.C \
+		SpcFile.C \
+		SpcFile.h \
+		SpectralPeaks.h \
+		SpectralPeakSelector.C \
+		SpectralPeakSelector.h \
+		SpectralSurface.C \
+		SpectralSurface.h \
+		Synthesizer.C \
+		Synthesizer.h \
+        fftsg.c
+
+
+# source code for the procedural (C) interface
+PI_SRC = loris.h lorisAnalyzer_pi.C lorisBpEnvelope_pi.C \
+ lorisException_pi.C lorisException_pi.h lorisNonObj_pi.C \
+ lorisPartialList_pi.C lorisUtilities_pi.C 
+
+
+# convenience library containing Csound opcodes 
+@HAVE_CSOUND_TRUE@CSOUND_LIB = $(top_builddir)/csound/liblorisops.la
+lib_LTLIBRARIES = libloris.la
+libloris_la_SOURCES = $(CPP_SRC) $(PI_SRC)
+libloris_la_CPPFLAGS = $(INCLUDE_FFTW) $(default_includes)
+libloris_la_LIBADD = $(LINK_FFTW) $(CSOUND_LIB)
+
+# the library version for Loris 1.8 is 13:0:0
+libloris_la_LDFLAGS = -version-info 13:0:0 $(EXTRA_LD_FLAGS)
+
+# loris.h is generated automatically from loris.h.in
+nodist_include_HEADERS = loris.h
+EXTRA_DIST = loris.h.in
+
+# installed Loris header files
+pkginclude_HEADERS = \
+				AiffFile.h		\
+				Analyzer.h		\
+				BreakpointEnvelope.h	\
+				Breakpoint.h	\
+				BreakpointUtils.h	\
+				Channelizer.h	\
+				Collator.h	\
+				Dilator.h	\
+				Distiller.h	\
+				Envelope.h	\
+				Exception.h	\
+                F0Estimate.h \
+				Filter.h	\
+				FourierTransform.h	\
+				FrequencyReference.h \
+				Fundamental.h \
+				Harmonifier.h	\
+				ImportLemur.h	\
+				KaiserWindow.h	\
+				LinearEnvelope.h \
+				LorisExceptions.h	\
+				Marker.h	\
+				Morpher.h	\
+				NoiseGenerator.h \
+				Notifier.h	\
+				Oscillator.h	\
+				Partial.h	\
+				PartialList.h	\
+				PartialPtrs.h	\
+				PartialUtils.h	\
+				ReassignedSpectrum.h	\
+				Resampler.h \
+				SdifFile.h	\
+				Sieve.h	\
+				SpcFile.h	\
+				SpectralSurface.h	\
+				Synthesizer.h
+
+MAINTAINERCLEANFILES = Makefile.in
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .C .c .lo .o .obj
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign src/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+loris.h: $(top_builddir)/config.status $(srcdir)/loris.h.in
+	cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)"
+	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+	list2=; for p in $$list; do \
+	  if test -f $$p; then \
+	    list2="$$list2 $$p"; \
+	  else :; fi; \
+	done; \
+	test -z "$$list2" || { \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+	}
+
+uninstall-libLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+	for p in $$list; do \
+	  $(am__strip_dir) \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+	done
+
+clean-libLTLIBRARIES:
+	-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+	@list='$(lib_LTLIBRARIES)'; for p in $$list; do \
+	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+	  test "$$dir" != "$$p" || dir=.; \
+	  echo "rm -f \"$${dir}/so_locations\""; \
+	  rm -f "$${dir}/so_locations"; \
+	done
+libloris.la: $(libloris_la_OBJECTS) $(libloris_la_DEPENDENCIES) 
+	$(libloris_la_LINK) -rpath $(libdir) $(libloris_la_OBJECTS) $(libloris_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-AiffData.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-AiffFile.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Analyzer.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-AssociateBandwidth.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-BigEndian.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Breakpoint.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-BreakpointUtils.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Channelizer.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Collator.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Dilator.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Distiller.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Envelope.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-F0Estimate.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Filter.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-FourierTransform.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-FrequencyReference.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Fundamental.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Harmonifier.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-ImportLemur.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-KaiserWindow.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-LinearEnvelope.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-LorisExceptions.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Marker.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Morpher.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-NoiseGenerator.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Notifier.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Oscillator.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Partial.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-PartialBuilder.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-PartialUtils.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-ReassignedSpectrum.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Resampler.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-SdifFile.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Sieve.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-SpcFile.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-SpectralPeakSelector.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-SpectralSurface.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-Synthesizer.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-fftsg.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-lorisAnalyzer_pi.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-lorisBpEnvelope_pi.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-lorisException_pi.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-lorisNonObj_pi.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-lorisPartialList_pi.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-lorisUtilities_pi.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libloris_la-phasefix.Plo@am__quote@
+
+.C.o:
+@am__fastdepCXX_TRUE@	$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXXCOMPILE) -c -o $@ $<
+
+.C.obj:
+@am__fastdepCXX_TRUE@	$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.C.lo:
+@am__fastdepCXX_TRUE@	$(LTCXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LTCXXCOMPILE) -c -o $@ $<
+
+libloris_la-AiffData.lo: AiffData.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-AiffData.lo -MD -MP -MF $(DEPDIR)/libloris_la-AiffData.Tpo -c -o libloris_la-AiffData.lo `test -f 'AiffData.C' || echo '$(srcdir)/'`AiffData.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-AiffData.Tpo $(DEPDIR)/libloris_la-AiffData.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='AiffData.C' object='libloris_la-AiffData.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-AiffData.lo `test -f 'AiffData.C' || echo '$(srcdir)/'`AiffData.C
+
+libloris_la-AiffFile.lo: AiffFile.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-AiffFile.lo -MD -MP -MF $(DEPDIR)/libloris_la-AiffFile.Tpo -c -o libloris_la-AiffFile.lo `test -f 'AiffFile.C' || echo '$(srcdir)/'`AiffFile.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-AiffFile.Tpo $(DEPDIR)/libloris_la-AiffFile.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='AiffFile.C' object='libloris_la-AiffFile.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-AiffFile.lo `test -f 'AiffFile.C' || echo '$(srcdir)/'`AiffFile.C
+
+libloris_la-Analyzer.lo: Analyzer.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Analyzer.lo -MD -MP -MF $(DEPDIR)/libloris_la-Analyzer.Tpo -c -o libloris_la-Analyzer.lo `test -f 'Analyzer.C' || echo '$(srcdir)/'`Analyzer.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Analyzer.Tpo $(DEPDIR)/libloris_la-Analyzer.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Analyzer.C' object='libloris_la-Analyzer.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Analyzer.lo `test -f 'Analyzer.C' || echo '$(srcdir)/'`Analyzer.C
+
+libloris_la-AssociateBandwidth.lo: AssociateBandwidth.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-AssociateBandwidth.lo -MD -MP -MF $(DEPDIR)/libloris_la-AssociateBandwidth.Tpo -c -o libloris_la-AssociateBandwidth.lo `test -f 'AssociateBandwidth.C' || echo '$(srcdir)/'`AssociateBandwidth.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-AssociateBandwidth.Tpo $(DEPDIR)/libloris_la-AssociateBandwidth.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='AssociateBandwidth.C' object='libloris_la-AssociateBandwidth.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-AssociateBandwidth.lo `test -f 'AssociateBandwidth.C' || echo '$(srcdir)/'`AssociateBandwidth.C
+
+libloris_la-BigEndian.lo: BigEndian.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-BigEndian.lo -MD -MP -MF $(DEPDIR)/libloris_la-BigEndian.Tpo -c -o libloris_la-BigEndian.lo `test -f 'BigEndian.C' || echo '$(srcdir)/'`BigEndian.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-BigEndian.Tpo $(DEPDIR)/libloris_la-BigEndian.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='BigEndian.C' object='libloris_la-BigEndian.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-BigEndian.lo `test -f 'BigEndian.C' || echo '$(srcdir)/'`BigEndian.C
+
+libloris_la-Breakpoint.lo: Breakpoint.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Breakpoint.lo -MD -MP -MF $(DEPDIR)/libloris_la-Breakpoint.Tpo -c -o libloris_la-Breakpoint.lo `test -f 'Breakpoint.C' || echo '$(srcdir)/'`Breakpoint.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Breakpoint.Tpo $(DEPDIR)/libloris_la-Breakpoint.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Breakpoint.C' object='libloris_la-Breakpoint.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Breakpoint.lo `test -f 'Breakpoint.C' || echo '$(srcdir)/'`Breakpoint.C
+
+libloris_la-BreakpointUtils.lo: BreakpointUtils.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-BreakpointUtils.lo -MD -MP -MF $(DEPDIR)/libloris_la-BreakpointUtils.Tpo -c -o libloris_la-BreakpointUtils.lo `test -f 'BreakpointUtils.C' || echo '$(srcdir)/'`BreakpointUtils.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-BreakpointUtils.Tpo $(DEPDIR)/libloris_la-BreakpointUtils.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='BreakpointUtils.C' object='libloris_la-BreakpointUtils.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-BreakpointUtils.lo `test -f 'BreakpointUtils.C' || echo '$(srcdir)/'`BreakpointUtils.C
+
+libloris_la-Channelizer.lo: Channelizer.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Channelizer.lo -MD -MP -MF $(DEPDIR)/libloris_la-Channelizer.Tpo -c -o libloris_la-Channelizer.lo `test -f 'Channelizer.C' || echo '$(srcdir)/'`Channelizer.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Channelizer.Tpo $(DEPDIR)/libloris_la-Channelizer.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Channelizer.C' object='libloris_la-Channelizer.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Channelizer.lo `test -f 'Channelizer.C' || echo '$(srcdir)/'`Channelizer.C
+
+libloris_la-Collator.lo: Collator.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Collator.lo -MD -MP -MF $(DEPDIR)/libloris_la-Collator.Tpo -c -o libloris_la-Collator.lo `test -f 'Collator.C' || echo '$(srcdir)/'`Collator.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Collator.Tpo $(DEPDIR)/libloris_la-Collator.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Collator.C' object='libloris_la-Collator.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Collator.lo `test -f 'Collator.C' || echo '$(srcdir)/'`Collator.C
+
+libloris_la-Dilator.lo: Dilator.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Dilator.lo -MD -MP -MF $(DEPDIR)/libloris_la-Dilator.Tpo -c -o libloris_la-Dilator.lo `test -f 'Dilator.C' || echo '$(srcdir)/'`Dilator.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Dilator.Tpo $(DEPDIR)/libloris_la-Dilator.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Dilator.C' object='libloris_la-Dilator.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Dilator.lo `test -f 'Dilator.C' || echo '$(srcdir)/'`Dilator.C
+
+libloris_la-Distiller.lo: Distiller.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Distiller.lo -MD -MP -MF $(DEPDIR)/libloris_la-Distiller.Tpo -c -o libloris_la-Distiller.lo `test -f 'Distiller.C' || echo '$(srcdir)/'`Distiller.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Distiller.Tpo $(DEPDIR)/libloris_la-Distiller.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Distiller.C' object='libloris_la-Distiller.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Distiller.lo `test -f 'Distiller.C' || echo '$(srcdir)/'`Distiller.C
+
+libloris_la-Envelope.lo: Envelope.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Envelope.lo -MD -MP -MF $(DEPDIR)/libloris_la-Envelope.Tpo -c -o libloris_la-Envelope.lo `test -f 'Envelope.C' || echo '$(srcdir)/'`Envelope.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Envelope.Tpo $(DEPDIR)/libloris_la-Envelope.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Envelope.C' object='libloris_la-Envelope.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Envelope.lo `test -f 'Envelope.C' || echo '$(srcdir)/'`Envelope.C
+
+libloris_la-F0Estimate.lo: F0Estimate.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-F0Estimate.lo -MD -MP -MF $(DEPDIR)/libloris_la-F0Estimate.Tpo -c -o libloris_la-F0Estimate.lo `test -f 'F0Estimate.C' || echo '$(srcdir)/'`F0Estimate.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-F0Estimate.Tpo $(DEPDIR)/libloris_la-F0Estimate.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='F0Estimate.C' object='libloris_la-F0Estimate.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-F0Estimate.lo `test -f 'F0Estimate.C' || echo '$(srcdir)/'`F0Estimate.C
+
+libloris_la-LorisExceptions.lo: LorisExceptions.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-LorisExceptions.lo -MD -MP -MF $(DEPDIR)/libloris_la-LorisExceptions.Tpo -c -o libloris_la-LorisExceptions.lo `test -f 'LorisExceptions.C' || echo '$(srcdir)/'`LorisExceptions.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-LorisExceptions.Tpo $(DEPDIR)/libloris_la-LorisExceptions.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='LorisExceptions.C' object='libloris_la-LorisExceptions.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-LorisExceptions.lo `test -f 'LorisExceptions.C' || echo '$(srcdir)/'`LorisExceptions.C
+
+libloris_la-Filter.lo: Filter.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Filter.lo -MD -MP -MF $(DEPDIR)/libloris_la-Filter.Tpo -c -o libloris_la-Filter.lo `test -f 'Filter.C' || echo '$(srcdir)/'`Filter.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Filter.Tpo $(DEPDIR)/libloris_la-Filter.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Filter.C' object='libloris_la-Filter.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Filter.lo `test -f 'Filter.C' || echo '$(srcdir)/'`Filter.C
+
+libloris_la-FourierTransform.lo: FourierTransform.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-FourierTransform.lo -MD -MP -MF $(DEPDIR)/libloris_la-FourierTransform.Tpo -c -o libloris_la-FourierTransform.lo `test -f 'FourierTransform.C' || echo '$(srcdir)/'`FourierTransform.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-FourierTransform.Tpo $(DEPDIR)/libloris_la-FourierTransform.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='FourierTransform.C' object='libloris_la-FourierTransform.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-FourierTransform.lo `test -f 'FourierTransform.C' || echo '$(srcdir)/'`FourierTransform.C
+
+libloris_la-FrequencyReference.lo: FrequencyReference.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-FrequencyReference.lo -MD -MP -MF $(DEPDIR)/libloris_la-FrequencyReference.Tpo -c -o libloris_la-FrequencyReference.lo `test -f 'FrequencyReference.C' || echo '$(srcdir)/'`FrequencyReference.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-FrequencyReference.Tpo $(DEPDIR)/libloris_la-FrequencyReference.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='FrequencyReference.C' object='libloris_la-FrequencyReference.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-FrequencyReference.lo `test -f 'FrequencyReference.C' || echo '$(srcdir)/'`FrequencyReference.C
+
+libloris_la-Fundamental.lo: Fundamental.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Fundamental.lo -MD -MP -MF $(DEPDIR)/libloris_la-Fundamental.Tpo -c -o libloris_la-Fundamental.lo `test -f 'Fundamental.C' || echo '$(srcdir)/'`Fundamental.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Fundamental.Tpo $(DEPDIR)/libloris_la-Fundamental.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Fundamental.C' object='libloris_la-Fundamental.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Fundamental.lo `test -f 'Fundamental.C' || echo '$(srcdir)/'`Fundamental.C
+
+libloris_la-Harmonifier.lo: Harmonifier.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Harmonifier.lo -MD -MP -MF $(DEPDIR)/libloris_la-Harmonifier.Tpo -c -o libloris_la-Harmonifier.lo `test -f 'Harmonifier.C' || echo '$(srcdir)/'`Harmonifier.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Harmonifier.Tpo $(DEPDIR)/libloris_la-Harmonifier.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Harmonifier.C' object='libloris_la-Harmonifier.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Harmonifier.lo `test -f 'Harmonifier.C' || echo '$(srcdir)/'`Harmonifier.C
+
+libloris_la-ImportLemur.lo: ImportLemur.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-ImportLemur.lo -MD -MP -MF $(DEPDIR)/libloris_la-ImportLemur.Tpo -c -o libloris_la-ImportLemur.lo `test -f 'ImportLemur.C' || echo '$(srcdir)/'`ImportLemur.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-ImportLemur.Tpo $(DEPDIR)/libloris_la-ImportLemur.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='ImportLemur.C' object='libloris_la-ImportLemur.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-ImportLemur.lo `test -f 'ImportLemur.C' || echo '$(srcdir)/'`ImportLemur.C
+
+libloris_la-KaiserWindow.lo: KaiserWindow.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-KaiserWindow.lo -MD -MP -MF $(DEPDIR)/libloris_la-KaiserWindow.Tpo -c -o libloris_la-KaiserWindow.lo `test -f 'KaiserWindow.C' || echo '$(srcdir)/'`KaiserWindow.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-KaiserWindow.Tpo $(DEPDIR)/libloris_la-KaiserWindow.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='KaiserWindow.C' object='libloris_la-KaiserWindow.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-KaiserWindow.lo `test -f 'KaiserWindow.C' || echo '$(srcdir)/'`KaiserWindow.C
+
+libloris_la-LinearEnvelope.lo: LinearEnvelope.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-LinearEnvelope.lo -MD -MP -MF $(DEPDIR)/libloris_la-LinearEnvelope.Tpo -c -o libloris_la-LinearEnvelope.lo `test -f 'LinearEnvelope.C' || echo '$(srcdir)/'`LinearEnvelope.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-LinearEnvelope.Tpo $(DEPDIR)/libloris_la-LinearEnvelope.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='LinearEnvelope.C' object='libloris_la-LinearEnvelope.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-LinearEnvelope.lo `test -f 'LinearEnvelope.C' || echo '$(srcdir)/'`LinearEnvelope.C
+
+libloris_la-Marker.lo: Marker.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Marker.lo -MD -MP -MF $(DEPDIR)/libloris_la-Marker.Tpo -c -o libloris_la-Marker.lo `test -f 'Marker.C' || echo '$(srcdir)/'`Marker.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Marker.Tpo $(DEPDIR)/libloris_la-Marker.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Marker.C' object='libloris_la-Marker.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Marker.lo `test -f 'Marker.C' || echo '$(srcdir)/'`Marker.C
+
+libloris_la-Morpher.lo: Morpher.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Morpher.lo -MD -MP -MF $(DEPDIR)/libloris_la-Morpher.Tpo -c -o libloris_la-Morpher.lo `test -f 'Morpher.C' || echo '$(srcdir)/'`Morpher.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Morpher.Tpo $(DEPDIR)/libloris_la-Morpher.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Morpher.C' object='libloris_la-Morpher.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Morpher.lo `test -f 'Morpher.C' || echo '$(srcdir)/'`Morpher.C
+
+libloris_la-NoiseGenerator.lo: NoiseGenerator.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-NoiseGenerator.lo -MD -MP -MF $(DEPDIR)/libloris_la-NoiseGenerator.Tpo -c -o libloris_la-NoiseGenerator.lo `test -f 'NoiseGenerator.C' || echo '$(srcdir)/'`NoiseGenerator.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-NoiseGenerator.Tpo $(DEPDIR)/libloris_la-NoiseGenerator.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='NoiseGenerator.C' object='libloris_la-NoiseGenerator.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-NoiseGenerator.lo `test -f 'NoiseGenerator.C' || echo '$(srcdir)/'`NoiseGenerator.C
+
+libloris_la-Notifier.lo: Notifier.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Notifier.lo -MD -MP -MF $(DEPDIR)/libloris_la-Notifier.Tpo -c -o libloris_la-Notifier.lo `test -f 'Notifier.C' || echo '$(srcdir)/'`Notifier.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Notifier.Tpo $(DEPDIR)/libloris_la-Notifier.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Notifier.C' object='libloris_la-Notifier.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Notifier.lo `test -f 'Notifier.C' || echo '$(srcdir)/'`Notifier.C
+
+libloris_la-Oscillator.lo: Oscillator.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Oscillator.lo -MD -MP -MF $(DEPDIR)/libloris_la-Oscillator.Tpo -c -o libloris_la-Oscillator.lo `test -f 'Oscillator.C' || echo '$(srcdir)/'`Oscillator.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Oscillator.Tpo $(DEPDIR)/libloris_la-Oscillator.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Oscillator.C' object='libloris_la-Oscillator.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Oscillator.lo `test -f 'Oscillator.C' || echo '$(srcdir)/'`Oscillator.C
+
+libloris_la-Partial.lo: Partial.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Partial.lo -MD -MP -MF $(DEPDIR)/libloris_la-Partial.Tpo -c -o libloris_la-Partial.lo `test -f 'Partial.C' || echo '$(srcdir)/'`Partial.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Partial.Tpo $(DEPDIR)/libloris_la-Partial.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Partial.C' object='libloris_la-Partial.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Partial.lo `test -f 'Partial.C' || echo '$(srcdir)/'`Partial.C
+
+libloris_la-PartialBuilder.lo: PartialBuilder.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-PartialBuilder.lo -MD -MP -MF $(DEPDIR)/libloris_la-PartialBuilder.Tpo -c -o libloris_la-PartialBuilder.lo `test -f 'PartialBuilder.C' || echo '$(srcdir)/'`PartialBuilder.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-PartialBuilder.Tpo $(DEPDIR)/libloris_la-PartialBuilder.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='PartialBuilder.C' object='libloris_la-PartialBuilder.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-PartialBuilder.lo `test -f 'PartialBuilder.C' || echo '$(srcdir)/'`PartialBuilder.C
+
+libloris_la-PartialUtils.lo: PartialUtils.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-PartialUtils.lo -MD -MP -MF $(DEPDIR)/libloris_la-PartialUtils.Tpo -c -o libloris_la-PartialUtils.lo `test -f 'PartialUtils.C' || echo '$(srcdir)/'`PartialUtils.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-PartialUtils.Tpo $(DEPDIR)/libloris_la-PartialUtils.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='PartialUtils.C' object='libloris_la-PartialUtils.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-PartialUtils.lo `test -f 'PartialUtils.C' || echo '$(srcdir)/'`PartialUtils.C
+
+libloris_la-phasefix.lo: phasefix.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-phasefix.lo -MD -MP -MF $(DEPDIR)/libloris_la-phasefix.Tpo -c -o libloris_la-phasefix.lo `test -f 'phasefix.C' || echo '$(srcdir)/'`phasefix.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-phasefix.Tpo $(DEPDIR)/libloris_la-phasefix.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='phasefix.C' object='libloris_la-phasefix.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-phasefix.lo `test -f 'phasefix.C' || echo '$(srcdir)/'`phasefix.C
+
+libloris_la-ReassignedSpectrum.lo: ReassignedSpectrum.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-ReassignedSpectrum.lo -MD -MP -MF $(DEPDIR)/libloris_la-ReassignedSpectrum.Tpo -c -o libloris_la-ReassignedSpectrum.lo `test -f 'ReassignedSpectrum.C' || echo '$(srcdir)/'`ReassignedSpectrum.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-ReassignedSpectrum.Tpo $(DEPDIR)/libloris_la-ReassignedSpectrum.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='ReassignedSpectrum.C' object='libloris_la-ReassignedSpectrum.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-ReassignedSpectrum.lo `test -f 'ReassignedSpectrum.C' || echo '$(srcdir)/'`ReassignedSpectrum.C
+
+libloris_la-Resampler.lo: Resampler.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Resampler.lo -MD -MP -MF $(DEPDIR)/libloris_la-Resampler.Tpo -c -o libloris_la-Resampler.lo `test -f 'Resampler.C' || echo '$(srcdir)/'`Resampler.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Resampler.Tpo $(DEPDIR)/libloris_la-Resampler.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Resampler.C' object='libloris_la-Resampler.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Resampler.lo `test -f 'Resampler.C' || echo '$(srcdir)/'`Resampler.C
+
+libloris_la-SdifFile.lo: SdifFile.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-SdifFile.lo -MD -MP -MF $(DEPDIR)/libloris_la-SdifFile.Tpo -c -o libloris_la-SdifFile.lo `test -f 'SdifFile.C' || echo '$(srcdir)/'`SdifFile.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-SdifFile.Tpo $(DEPDIR)/libloris_la-SdifFile.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='SdifFile.C' object='libloris_la-SdifFile.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-SdifFile.lo `test -f 'SdifFile.C' || echo '$(srcdir)/'`SdifFile.C
+
+libloris_la-Sieve.lo: Sieve.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Sieve.lo -MD -MP -MF $(DEPDIR)/libloris_la-Sieve.Tpo -c -o libloris_la-Sieve.lo `test -f 'Sieve.C' || echo '$(srcdir)/'`Sieve.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Sieve.Tpo $(DEPDIR)/libloris_la-Sieve.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Sieve.C' object='libloris_la-Sieve.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Sieve.lo `test -f 'Sieve.C' || echo '$(srcdir)/'`Sieve.C
+
+libloris_la-SpcFile.lo: SpcFile.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-SpcFile.lo -MD -MP -MF $(DEPDIR)/libloris_la-SpcFile.Tpo -c -o libloris_la-SpcFile.lo `test -f 'SpcFile.C' || echo '$(srcdir)/'`SpcFile.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-SpcFile.Tpo $(DEPDIR)/libloris_la-SpcFile.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='SpcFile.C' object='libloris_la-SpcFile.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-SpcFile.lo `test -f 'SpcFile.C' || echo '$(srcdir)/'`SpcFile.C
+
+libloris_la-SpectralPeakSelector.lo: SpectralPeakSelector.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-SpectralPeakSelector.lo -MD -MP -MF $(DEPDIR)/libloris_la-SpectralPeakSelector.Tpo -c -o libloris_la-SpectralPeakSelector.lo `test -f 'SpectralPeakSelector.C' || echo '$(srcdir)/'`SpectralPeakSelector.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-SpectralPeakSelector.Tpo $(DEPDIR)/libloris_la-SpectralPeakSelector.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='SpectralPeakSelector.C' object='libloris_la-SpectralPeakSelector.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-SpectralPeakSelector.lo `test -f 'SpectralPeakSelector.C' || echo '$(srcdir)/'`SpectralPeakSelector.C
+
+libloris_la-SpectralSurface.lo: SpectralSurface.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-SpectralSurface.lo -MD -MP -MF $(DEPDIR)/libloris_la-SpectralSurface.Tpo -c -o libloris_la-SpectralSurface.lo `test -f 'SpectralSurface.C' || echo '$(srcdir)/'`SpectralSurface.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-SpectralSurface.Tpo $(DEPDIR)/libloris_la-SpectralSurface.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='SpectralSurface.C' object='libloris_la-SpectralSurface.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-SpectralSurface.lo `test -f 'SpectralSurface.C' || echo '$(srcdir)/'`SpectralSurface.C
+
+libloris_la-Synthesizer.lo: Synthesizer.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-Synthesizer.lo -MD -MP -MF $(DEPDIR)/libloris_la-Synthesizer.Tpo -c -o libloris_la-Synthesizer.lo `test -f 'Synthesizer.C' || echo '$(srcdir)/'`Synthesizer.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-Synthesizer.Tpo $(DEPDIR)/libloris_la-Synthesizer.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='Synthesizer.C' object='libloris_la-Synthesizer.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-Synthesizer.lo `test -f 'Synthesizer.C' || echo '$(srcdir)/'`Synthesizer.C
+
+libloris_la-lorisAnalyzer_pi.lo: lorisAnalyzer_pi.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-lorisAnalyzer_pi.lo -MD -MP -MF $(DEPDIR)/libloris_la-lorisAnalyzer_pi.Tpo -c -o libloris_la-lorisAnalyzer_pi.lo `test -f 'lorisAnalyzer_pi.C' || echo '$(srcdir)/'`lorisAnalyzer_pi.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-lorisAnalyzer_pi.Tpo $(DEPDIR)/libloris_la-lorisAnalyzer_pi.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='lorisAnalyzer_pi.C' object='libloris_la-lorisAnalyzer_pi.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-lorisAnalyzer_pi.lo `test -f 'lorisAnalyzer_pi.C' || echo '$(srcdir)/'`lorisAnalyzer_pi.C
+
+libloris_la-lorisBpEnvelope_pi.lo: lorisBpEnvelope_pi.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-lorisBpEnvelope_pi.lo -MD -MP -MF $(DEPDIR)/libloris_la-lorisBpEnvelope_pi.Tpo -c -o libloris_la-lorisBpEnvelope_pi.lo `test -f 'lorisBpEnvelope_pi.C' || echo '$(srcdir)/'`lorisBpEnvelope_pi.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-lorisBpEnvelope_pi.Tpo $(DEPDIR)/libloris_la-lorisBpEnvelope_pi.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='lorisBpEnvelope_pi.C' object='libloris_la-lorisBpEnvelope_pi.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-lorisBpEnvelope_pi.lo `test -f 'lorisBpEnvelope_pi.C' || echo '$(srcdir)/'`lorisBpEnvelope_pi.C
+
+libloris_la-lorisException_pi.lo: lorisException_pi.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-lorisException_pi.lo -MD -MP -MF $(DEPDIR)/libloris_la-lorisException_pi.Tpo -c -o libloris_la-lorisException_pi.lo `test -f 'lorisException_pi.C' || echo '$(srcdir)/'`lorisException_pi.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-lorisException_pi.Tpo $(DEPDIR)/libloris_la-lorisException_pi.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='lorisException_pi.C' object='libloris_la-lorisException_pi.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-lorisException_pi.lo `test -f 'lorisException_pi.C' || echo '$(srcdir)/'`lorisException_pi.C
+
+libloris_la-lorisNonObj_pi.lo: lorisNonObj_pi.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-lorisNonObj_pi.lo -MD -MP -MF $(DEPDIR)/libloris_la-lorisNonObj_pi.Tpo -c -o libloris_la-lorisNonObj_pi.lo `test -f 'lorisNonObj_pi.C' || echo '$(srcdir)/'`lorisNonObj_pi.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-lorisNonObj_pi.Tpo $(DEPDIR)/libloris_la-lorisNonObj_pi.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='lorisNonObj_pi.C' object='libloris_la-lorisNonObj_pi.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-lorisNonObj_pi.lo `test -f 'lorisNonObj_pi.C' || echo '$(srcdir)/'`lorisNonObj_pi.C
+
+libloris_la-lorisPartialList_pi.lo: lorisPartialList_pi.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-lorisPartialList_pi.lo -MD -MP -MF $(DEPDIR)/libloris_la-lorisPartialList_pi.Tpo -c -o libloris_la-lorisPartialList_pi.lo `test -f 'lorisPartialList_pi.C' || echo '$(srcdir)/'`lorisPartialList_pi.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-lorisPartialList_pi.Tpo $(DEPDIR)/libloris_la-lorisPartialList_pi.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='lorisPartialList_pi.C' object='libloris_la-lorisPartialList_pi.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-lorisPartialList_pi.lo `test -f 'lorisPartialList_pi.C' || echo '$(srcdir)/'`lorisPartialList_pi.C
+
+libloris_la-lorisUtilities_pi.lo: lorisUtilities_pi.C
+@am__fastdepCXX_TRUE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT libloris_la-lorisUtilities_pi.lo -MD -MP -MF $(DEPDIR)/libloris_la-lorisUtilities_pi.Tpo -c -o libloris_la-lorisUtilities_pi.lo `test -f 'lorisUtilities_pi.C' || echo '$(srcdir)/'`lorisUtilities_pi.C
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-lorisUtilities_pi.Tpo $(DEPDIR)/libloris_la-lorisUtilities_pi.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='lorisUtilities_pi.C' object='libloris_la-lorisUtilities_pi.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(LIBTOOL)  --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o libloris_la-lorisUtilities_pi.lo `test -f 'lorisUtilities_pi.C' || echo '$(srcdir)/'`lorisUtilities_pi.C
+
+.c.o:
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LTCOMPILE) -c -o $@ $<
+
+libloris_la-fftsg.lo: fftsg.c
+@am__fastdepCC_TRUE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libloris_la-fftsg.lo -MD -MP -MF $(DEPDIR)/libloris_la-fftsg.Tpo -c -o libloris_la-fftsg.lo `test -f 'fftsg.c' || echo '$(srcdir)/'`fftsg.c
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/libloris_la-fftsg.Tpo $(DEPDIR)/libloris_la-fftsg.Plo
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='fftsg.c' object='libloris_la-fftsg.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libloris_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libloris_la-fftsg.lo `test -f 'fftsg.c' || echo '$(srcdir)/'`fftsg.c
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+install-nodist_includeHEADERS: $(nodist_include_HEADERS)
+	@$(NORMAL_INSTALL)
+	test -z "$(includedir)" || $(MKDIR_P) "$(DESTDIR)$(includedir)"
+	@list='$(nodist_include_HEADERS)'; test -n "$(includedir)" || list=; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(includedir)'"; \
+	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(includedir)" || exit $$?; \
+	done
+
+uninstall-nodist_includeHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(nodist_include_HEADERS)'; test -n "$(includedir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	test -n "$$files" || exit 0; \
+	echo " ( cd '$(DESTDIR)$(includedir)' && rm -f" $$files ")"; \
+	cd "$(DESTDIR)$(includedir)" && rm -f $$files
+install-pkgincludeHEADERS: $(pkginclude_HEADERS)
+	@$(NORMAL_INSTALL)
+	test -z "$(pkgincludedir)" || $(MKDIR_P) "$(DESTDIR)$(pkgincludedir)"
+	@list='$(pkginclude_HEADERS)'; test -n "$(pkgincludedir)" || list=; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(pkgincludedir)'"; \
+	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(pkgincludedir)" || exit $$?; \
+	done
+
+uninstall-pkgincludeHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(pkginclude_HEADERS)'; test -n "$(pkgincludedir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	test -n "$$files" || exit 0; \
+	echo " ( cd '$(DESTDIR)$(pkgincludedir)' && rm -f" $$files ")"; \
+	cd "$(DESTDIR)$(pkgincludedir)" && rm -f $$files
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	set x; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES) $(HEADERS)
+installdirs:
+	for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includedir)" "$(DESTDIR)$(pkgincludedir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+	-test -z "$(MAINTAINERCLEANFILES)" || rm -f $(MAINTAINERCLEANFILES)
+clean: clean-am
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-nodist_includeHEADERS \
+	install-pkgincludeHEADERS
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-libLTLIBRARIES uninstall-nodist_includeHEADERS \
+	uninstall-pkgincludeHEADERS
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libLTLIBRARIES clean-libtool ctags distclean \
+	distclean-compile distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am install-dvi \
+	install-dvi-am install-exec install-exec-am install-html \
+	install-html-am install-info install-info-am \
+	install-libLTLIBRARIES install-man \
+	install-nodist_includeHEADERS install-pdf install-pdf-am \
+	install-pkgincludeHEADERS install-ps install-ps-am \
+	install-strip installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
+	pdf pdf-am ps ps-am tags uninstall uninstall-am \
+	uninstall-libLTLIBRARIES uninstall-nodist_includeHEADERS \
+	uninstall-pkgincludeHEADERS
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/src/loris/Marker.C b/src/loris/Marker.C
new file mode 100644
index 0000000..83ed3e7
--- /dev/null
+++ b/src/loris/Marker.C
@@ -0,0 +1,176 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Marker.cc
+ *
+ * Definition of members for Marker and MarkerContainer representing labeled
+ * time points or temporal features in imported and exported data. Used by 
+ * file I/O classes AiffFile, SdifFile, and SpcFile.
+ *
+ * Kelly Fitz, 8 Jan 2003 
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "Marker.h"
+
+//	begin namespace
+namespace Loris {
+
+// -- construction --
+
+// ---------------------------------------------------------------------------
+//	Marker - default constructor
+// ---------------------------------------------------------------------------
+//	Default constructor - initialize a Marker at time zero with no label.
+//
+Marker::Marker( void ) :
+	m_time( 0. ),
+	m_name("Untitled Marker")
+{
+}
+	 
+// ---------------------------------------------------------------------------
+//	Marker - constructor from time and name
+// ---------------------------------------------------------------------------
+//	Initialize a Marker with the specified time (in seconds) and name.
+//
+Marker::Marker( double t, const std::string & s ) :
+	m_time( t ),
+	m_name( s )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	Marker - copy constructor
+// ---------------------------------------------------------------------------
+//	Initialize a Marker that is an exact copy of another Marker, that is,
+//	having the same time and name.
+//
+Marker::Marker( const Marker & other ) :
+	m_time( other.m_time ),
+	m_name( other.m_name )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	assignment operator (operator =)
+// ---------------------------------------------------------------------------
+//	Make this Marker an exact copy, having the same time and name, 
+//	as the Marker rhs.
+//
+Marker & 
+Marker::operator=( const Marker & rhs )
+{
+	if ( this != &rhs )
+	{
+		//	the only imaginable exception that could be generated
+		//	would be an out-of-memory exception at the time of this
+		//	string assignment, reserve memory first, so that if this
+		//	does except, the Marker is unchanged:
+		m_name.reserve( rhs.m_name.size() );
+		m_name = rhs.m_name;
+		m_time = rhs.m_time;		
+
+	}
+	return *this;
+}
+
+// -- comparison --
+
+// ---------------------------------------------------------------------------
+//	less-than operator (operator <)
+// ---------------------------------------------------------------------------
+//	Return true if this Marker must appear earlier than rhs in a sorted
+//	collection of Markers, and false otherwise. (Markers are sorted by time.)
+//
+bool
+Marker::operator< ( const Marker & rhs ) const
+{
+	return m_time < rhs.m_time;
+}	 
+
+// -- access --
+
+// ---------------------------------------------------------------------------
+//	name
+// ---------------------------------------------------------------------------
+//	Return a reference to the name string for this Marker.
+//
+std::string & 
+Marker::name( void )
+{
+	return m_name;
+}
+
+// ---------------------------------------------------------------------------
+//	name (const)
+// ---------------------------------------------------------------------------
+//	Return a const reference to the name string for this Marker.
+//
+const std::string & 
+Marker::name( void ) const
+{
+	return m_name;
+}
+	 
+// ---------------------------------------------------------------------------
+//	time
+// ---------------------------------------------------------------------------
+//	Return the time (in seconds) associated with this Marker.
+//
+double 
+Marker::time( void ) const
+{
+	return m_time;
+}
+
+// -- mutation --
+
+// ---------------------------------------------------------------------------
+//	setName
+// ---------------------------------------------------------------------------
+//	Set the name of the Marker.
+//
+void 
+Marker::setName( const std::string & s )
+{
+	m_name = s;
+}
+	 
+// ---------------------------------------------------------------------------
+//	setName
+// ---------------------------------------------------------------------------
+//	Set the time (in seconds) associated with this Marker.
+//
+void 
+Marker::setTime( double t )
+{
+	m_time = t;
+}
+
+}	//	end of namespace Loris
diff --git a/src/loris/Marker.h b/src/loris/Marker.h
new file mode 100644
index 0000000..6c51a23
--- /dev/null
+++ b/src/loris/Marker.h
@@ -0,0 +1,178 @@
+#ifndef INCLUDE_MARKER_H
+#define INCLUDE_MARKER_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Marker.h
+ *
+ * Definition of classes Marker and MarkerContainer representing labeled
+ * time points or temporal features in imported and exported data. Used by 
+ * file I/O classes AiffFile, SdifFile, and SpcFile.
+ *
+ * Kelly Fitz, 8 Jan 2003 
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include <functional>
+#include <string>
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	class Marker
+//
+//!	Class Marker represents a labeled time point in a set of Partials
+//!	or a vector of samples. Collections of Markers (see the MarkerContainer
+//!	definition below) are held by the File I/O classes in Loris (AiffFile,
+//!	SdifFile, and SpcFile) to identify temporal features in imported
+//!	and exported data.
+//
+class Marker
+{
+//	-- public interface --
+public:
+//	-- construction --
+
+	//!	Default constructor - initialize a Marker at time zero with no label.
+	Marker( void );
+	 
+	//!	Initialize a Marker with the specified time (in seconds) and name.
+	//! 
+	//! \param  t is the time associated with the new Marker
+	//! \param  s is the name associated with the new Marker
+	Marker( double t, const std::string & s );
+	 
+	//!	Initialize a Marker that is an exact copy of another Marker, that is,
+	//!	having the same time and name.
+	//!
+	//! \param  other is the Marker to copy from
+	Marker( const Marker & other );
+	
+	//!	Make this Marker an exact copy, having the same time and name, 
+	//!	as the Marker rhs.
+	//!
+	//! \param  rhs is the Marker to assign from
+    //! \return reference to self
+	Marker & operator=( const Marker & rhs );
+	 
+//	-- comparison --
+
+	//!	Return true if this Marker must appear earlier than rhs in a sorted
+	//!	collection of Markers, and false otherwise. 
+	//! (Markers are sorted by time.)
+	//!
+	//! \param  rhs is the Marker to compare with this Marker
+	//! \return true if this Marker's time is earlier than that of
+	//!         rhs, otherwise false 
+	bool operator< ( const Marker & rhs ) const;
+	 
+//	-- access --
+    
+	//!	Return a reference to the name string
+	//!	for this Marker.
+	std::string & name( void );
+
+	//!	Return a const reference to the name string
+	//!	for this Marker.
+	const std::string & name( void ) const;
+	 
+	//!	Return the time (in seconds) associated with this Marker.
+	double time( void ) const;
+
+	 
+//	-- mutation --
+	//!	Set the name of the Marker.
+	void setName( const std::string & s );
+	 
+	//! 	Set the time (in seconds) associated with this Marker.
+	void setTime( double t );
+
+//	-- comparitors --
+
+	//!	Comparitor (binary) functor returning true if its first Marker
+	//!	argument should appear before the second in a range sorted
+	//!	by Marker name.
+	struct compareNameLess : 
+		public std::binary_function< const Marker, const Marker, bool >
+	{
+		//! Function call operator, return true if the first Marker
+		//!	argument should appear before the second in a range sorted
+		//!	by Marker name.
+		bool operator()( const Marker & lhs, const Marker & rhs ) const 
+			{ return lhs.name() < rhs.name(); }
+	};
+	
+	//! old name for compareNameLess, legacy support
+	//! \deprecated Use compareNameLess instead.
+	typedef compareNameLess sortByName; 
+	
+	
+	//!	Comparitor (binary) functor returning true if its first Marker
+	//!	argument should appear before the second in a range sorted
+	//!	by Marker time.
+	struct compareTimeLess : 
+		public std::binary_function< const Marker, const Marker, bool >
+	{
+		//! Function call operator, return true if the first Marker
+		//!	argument should appear before the second in a range sorted
+		//!	by Marker time.
+		bool operator()( const Marker & lhs, const Marker & rhs ) const 
+			{ return lhs.time() < rhs.time(); }
+	};
+	
+	//! old name for compareTimeLess, legacy support
+	//! \deprecated Use compareTimeLess instead
+	typedef compareTimeLess sortByTime; 
+	
+    //! Predicate functor returning true if the name of a Marker
+    //! equal to the specified string, and false otherwise.
+    class isNameEqual : public std::unary_function< const Marker, bool >
+    {
+    public:
+        //! Initialize a new instance with the specified name.
+    	isNameEqual( const std::string & s ) : name(s) {}
+    	
+    	//! Function call operator: evaluate a Marker.
+    	bool operator()( const Marker & m ) const 
+    		{ return m.name() == name; }
+    		
+    private:	
+    	std::string name;	//!	the name to compare against
+    };
+
+private:
+
+//	-- implementation --
+
+	double m_time;			//! the time in seconds associated with the Marker
+	std::string m_name;		//! the name of the Marker
+			
+};	//	end of class Marker
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_MARKER_H */
diff --git a/src/loris/Morpher.C b/src/loris/Morpher.C
new file mode 100644
index 0000000..963ea25
--- /dev/null
+++ b/src/loris/Morpher.C
@@ -0,0 +1,1597 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Morpher.C
+ *
+ * Implementation of class Morpher.
+ *
+ * Kelly Fitz, 15 Oct 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+    #include "config.h"
+#endif
+
+#include "Morpher.h"
+#include "Breakpoint.h"
+#include "Envelope.h"
+#include "LorisExceptions.h"
+#include "Notifier.h"
+#include "Partial.h"
+#include "PartialList.h"
+#include "PartialUtils.h"
+
+#include "phasefix.h" 
+
+#include <algorithm>
+#include <memory>
+#include <cmath>
+#include <vector>
+
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+    const double Pi = M_PI;
+#else
+    const double Pi = 3.14159265358979324;
+#endif
+
+//    begin namespace
+namespace Loris {
+
+
+const double Morpher::DefaultFixThreshold = -90; // dB, very low by default
+
+// shaping parameter, see interpolateAmplitude:
+const double Morpher::DefaultAmpShape = 1E-5;    
+
+const double Morpher::DefaultBreakpointGap = 1E-4; // minimum time (sec) between Breakpoints in 
+                                                   // morphed Partials
+
+// helper declarations
+static inline bool partial_is_nonnull( const Partial & p );
+
+
+
+// -- construction --
+
+// ---------------------------------------------------------------------------
+//    Morpher constructor (single morph function)
+// ---------------------------------------------------------------------------
+//    Construct a new Morpher using the same morphing envelope for 
+//    frequency, amplitude, and bandwidth (noisiness).
+//
+Morpher::Morpher( const Envelope & f ) :
+    _freqFunction( f.clone() ),
+    _ampFunction( f.clone() ),
+    _bwFunction( f.clone() ),
+    _freqFixThresholdDb( DefaultFixThreshold ),
+    _logMorphShape( DefaultAmpShape ),
+    _minBreakpointGapSec( DefaultBreakpointGap ),
+    _doLogAmpMorphing( true ),
+    _doLogFreqMorphing( false )
+{
+}
+
+// ---------------------------------------------------------------------------
+//    Morpher constructor (distinct morph functions)
+// ---------------------------------------------------------------------------
+//    Construct a new Morpher using the specified morphing envelopes for
+//    frequency, amplitude, and bandwidth (noisiness).
+//
+Morpher::Morpher( const Envelope & ff, const Envelope & af, const Envelope & bwf ) :
+    _freqFunction( ff.clone() ),
+    _ampFunction( af.clone() ),
+    _bwFunction( bwf.clone() ),
+    _freqFixThresholdDb( DefaultFixThreshold ),
+    _logMorphShape( DefaultAmpShape ),
+    _minBreakpointGapSec( DefaultBreakpointGap ),
+    _doLogAmpMorphing( true ),
+    _doLogFreqMorphing( false )
+{
+}
+
+// ---------------------------------------------------------------------------
+//    Morpher copy constructor 
+// ---------------------------------------------------------------------------
+//!    Construct a new Morpher that is a duplicate of rhs.
+//!
+//! \param  rhs is the Morpher to duplicate
+Morpher::Morpher( const Morpher & rhs ) :
+    _freqFunction( rhs._freqFunction->clone() ),
+    _ampFunction( rhs._ampFunction->clone() ),
+    _bwFunction( rhs._bwFunction->clone() ),
+    _srcRefPartial( rhs._srcRefPartial ),
+    _tgtRefPartial( rhs._tgtRefPartial ),
+    _freqFixThresholdDb( rhs._freqFixThresholdDb ),
+    _logMorphShape( rhs._logMorphShape ),
+    _minBreakpointGapSec( rhs._minBreakpointGapSec ),
+    _doLogAmpMorphing( rhs._doLogAmpMorphing ),
+    _doLogFreqMorphing( rhs._doLogFreqMorphing )
+{
+}
+
+// ---------------------------------------------------------------------------
+//    Morpher destructor
+// ---------------------------------------------------------------------------
+//    Destroy this Morpher.
+//
+Morpher::~Morpher( void )
+{
+}
+
+// ---------------------------------------------------------------------------
+//    Morpher assignment operator
+// ---------------------------------------------------------------------------
+//! Make this Morpher a duplicate of rhs.
+//!
+//! \param  rhs is the Morpher to duplicate
+Morpher & 
+Morpher::operator= ( const Morpher & rhs )
+{
+    if ( &rhs != this )
+    {
+        _freqFunction.reset( rhs._freqFunction->clone() );
+        _ampFunction.reset( rhs._ampFunction->clone() );
+        _bwFunction.reset( rhs._bwFunction->clone() );
+        
+        _srcRefPartial = rhs._srcRefPartial;
+        _tgtRefPartial = rhs._tgtRefPartial;
+        
+        _freqFixThresholdDb = rhs._freqFixThresholdDb;
+        _logMorphShape = rhs._logMorphShape;
+        _minBreakpointGapSec = rhs._minBreakpointGapSec;
+        
+        _doLogAmpMorphing = rhs._doLogAmpMorphing;
+        _doLogFreqMorphing = rhs._doLogFreqMorphing;
+        
+    }
+    return *this;
+}
+
+
+
+// -- Partial morphing --
+
+// ---------------------------------------------------------------------------
+//    morphPartials
+// ---------------------------------------------------------------------------
+//! Morph a pair of Partials to yield a new morphed Partial. 
+//! Dummy Partials (having no Breakpoints) don't contribute to the
+//! morph, except to cause their opposite to fade out. 
+//! Either (or neither) the source or target Partial may be a dummy 
+//! Partial (no Breakpoints), but not both. The morphed
+//! Partial has Breakpoints at times corresponding to every Breakpoint 
+//! in both source Partials, omitting Breakpoints that would be
+//!   closer than the minBreakpointGap to their predecessor. 
+//! The new morphed Partial is assigned the specified label and returned.
+//!
+//! \param  src is the Partial corresponding to a morph function
+//!         value of 0, evaluated at the specified time.
+//! \param  tgt is the Partial corresponding to a morph function
+//!         value of 1, evaluated at the specified time.
+//! \param  assignLabel is the label assigned to the morphed Partial
+//! \return the morphed Partial
+//
+Partial
+Morpher::morphPartials( Partial src, Partial tgt, int assignLabel )
+{  
+    if ( (src.numBreakpoints() == 0) && (tgt.numBreakpoints() == 0) )
+    {
+        Throw( InvalidArgument, "Cannot morph two empty Partials," );
+    }    
+    
+    Partial::const_iterator src_iter = src.begin();
+    Partial::const_iterator tgt_iter = tgt.begin();
+    
+    // find the earliest time that a Breakpoint
+    // could be added to the morph:
+    double dontAddBefore = 0;
+    if ( 0 < src.numBreakpoints() )
+    {
+        dontAddBefore = std::min( dontAddBefore, src_iter.time() );
+    }
+    if ( 0 < tgt.numBreakpoints() )
+    {
+        dontAddBefore = std::min( dontAddBefore, tgt_iter.time() );
+    }
+
+    
+    //  make a new Partial:
+    Partial newp;
+    newp.setLabel( assignLabel );
+    
+
+    //  Merge Breakpoints from the two Partials,
+    //  loop until there are no more Breakpoints to
+    //  consider in either Partial.
+    while ( src_iter != src.end() || tgt_iter != tgt.end() )
+    {
+        if ( ( tgt_iter == tgt.end() ) ||
+             ( src_iter != src.end() && src_iter.time() < tgt_iter.time() ) )
+        {
+            //  Ran out of tgt Breakpoints, or 
+            //  src Breakpoint is earlier, add it.
+            //
+            //  Don't insert Breakpoints arbitrarily close together, 
+            //  only insert a new Breakpoint if it is later than
+            //  the end of the new Partial by more than the gap time.
+            if ( dontAddBefore <= src_iter.time() )
+            {
+                appendMorphedSrc( src_iter.breakpoint(), tgt, src_iter.time(), newp );
+            }
+
+            ++src_iter;
+        }
+        else 
+        {
+            //  Ran out of src Breakpoints, or
+            //  tgt Breakpoint is earlier add it.
+            //
+            //  Don't insert Breakpoints arbitrarily close together, 
+            //  only insert a new Breakpoint if it is later than
+            //  the end of the new Partial by more than the gap time.
+            if ( dontAddBefore <= tgt_iter.time() )
+            {
+                appendMorphedTgt( tgt_iter.breakpoint(), src, tgt_iter.time(), newp );
+            }
+
+            ++tgt_iter;
+        }  
+        
+        if ( 0 != newp.numBreakpoints() )
+        {
+            // update the earliest time the next Breakpoint
+            // could be added to the morph:
+            dontAddBefore = newp.endTime() + _minBreakpointGapSec;
+        }          
+    }
+
+	//	Recompute the phases to match the sources when the frequency 
+	//	morphing function is 0 or 1.
+    fixMorphedPhases( newp );
+    
+    return newp;
+}
+
+
+// ---------------------------------------------------------------------------
+//    helper - GetMorphState
+// ---------------------------------------------------------------------------
+
+typedef enum { SRC = 0, TGT, INTERP } MorphState;
+
+static inline MorphState GetMorphState( double fweight )
+{
+    if ( fweight <= 0 ) 
+    {
+        return SRC;
+    }
+    else if ( fweight >= 1 ) 
+    {
+        return TGT;
+    }
+    else 
+    {
+        return INTERP;
+    }
+}
+
+// ---------------------------------------------------------------------------
+//    fixMorphedPhases (helper)
+// ---------------------------------------------------------------------------
+//  Recompute phases for a morphed Partial, so that the synthesized phases 
+//  match the source phases as closesly as possible at times when the 
+//  frequency morphing function is equal to 0 or 1. 
+
+void 
+Morpher::fixMorphedPhases( Partial & newp ) const
+{
+    if ( 0 != newp.numBreakpoints() )
+    {
+        //  set the initial morph state according to the value of the
+        //  frequency function at the time of the first Breakpoint in 
+        //  the morphed partial
+        Partial::iterator bppos = newp.begin();
+        Partial::iterator lastPosCorrect = bppos;
+        MorphState curstate = GetMorphState( _freqFunction->valueAt( bppos.time() ) );
+        
+        //  consider each Breakpoint, look for a change in the
+        //  morph state at the time of each Breakpoint
+        while( ++bppos != newp.end() )
+        {
+            MorphState nxtstate = GetMorphState( _freqFunction->valueAt( bppos.time() ) );   
+            if ( nxtstate != curstate )
+            {
+                //  switch!
+                if ( INTERP != curstate )
+                {
+                    // switch to INTERP
+                    fixPhaseForward( lastPosCorrect, bppos );
+                }
+                else
+                {
+                    //  switch to SRC or TGT                
+                    if ( newp.begin() == lastPosCorrect  )
+                    {   
+                        //  first transition
+                        fixPhaseBackward( lastPosCorrect, bppos );
+                    }
+                    else
+                    {
+                        //   not first transition
+                        fixPhaseBetween( lastPosCorrect, bppos );
+                    }                
+                }
+                lastPosCorrect = bppos;            
+                    
+                curstate = nxtstate;
+
+            }            
+        }
+        
+        // fix the remaining phases
+        fixPhaseForward( lastPosCorrect, --bppos );
+    }
+}
+
+
+// ---------------------------------------------------------------------------
+//    crossfade
+// ---------------------------------------------------------------------------
+//    Crossfade Partials with no correspondences.
+//
+//    Unlabeled Partials (having label 0) are considered to 
+//    have no correspondences, so they are just faded out, and not 
+//    actually morphed. This is the same as morphing each with an 
+//    empty dummy Partial (having no Breakpoints). 
+//
+//    The Partials in the first range are treated as components of the 
+//    source sound, corresponding to a morph function value of 0, and  
+//    those in the second are treated as components of the target sound, 
+//    corresponding to a morph function value of 1.
+//
+//    The crossfaded Partials are stored in the Morpher's PartialList.
+//
+void 
+Morpher::crossfade( PartialList::const_iterator beginSrc, 
+                    PartialList::const_iterator endSrc,
+                    PartialList::const_iterator beginTgt, 
+                    PartialList::const_iterator endTgt,
+                    Partial::label_type label /* default 0 */ )
+{
+    Partial nullPartial;
+    debugger << "crossfading unlabeled (labeled 0) Partials" << endl;
+    
+    long debugCounter;
+
+    //    crossfade Partials corresponding to a morph weight of 0:
+    PartialList::const_iterator it;
+    debugCounter = 0;
+    for ( it = beginSrc; it != endSrc; ++it )
+    {
+        if ( it->label() == label && 0 != it->numBreakpoints() )
+        {            
+            Partial newp;
+            newp.setLabel( label );
+            double dontAddBefore = it->startTime();
+
+            for ( Partial::const_iterator bpPos = it->begin(); 
+                  bpPos != it->end(); 
+                  ++bpPos )
+            {        
+                //  Don't insert Breakpoints arbitrarily close together, 
+                //  only insert a new Breakpoint if it is later than
+                //  the end of the new Partial by more than the gap time.
+                if ( dontAddBefore <= bpPos.time() )
+                {
+                    newp.insert( bpPos.time(), 
+                                 fadeSrcBreakpoint( bpPos.breakpoint(), bpPos.time() ) );
+                    dontAddBefore = bpPos.time() + _minBreakpointGapSec;
+                }
+            }
+            
+            if ( newp.numBreakpoints() > 0 )
+            {
+                ++debugCounter;
+                _partials.push_back( newp );
+            }
+        }
+    }
+    debugger << "kept " << debugCounter << " from sound 1" << endl;
+
+    //    crossfade Partials corresponding to a morph weight of 1:
+    debugCounter = 0;
+    for ( it = beginTgt; it != endTgt; ++it )
+    {
+        if ( it->label() == label && 0 != it->numBreakpoints() )
+        {
+            Partial newp;
+            newp.setLabel( label );
+            double dontAddBefore = it->startTime();
+                            
+            for ( Partial::const_iterator bpPos = it->begin(); 
+                  bpPos != it->end(); 
+                  ++bpPos )
+            {
+                //  Don't insert Breakpoints arbitrarily close together, 
+                //  only insert a new Breakpoint if it is later than
+                //  the end of the new Partial by more than the gap time.
+                if ( dontAddBefore <= bpPos.time() )
+                {
+                    newp.insert( bpPos.time(),
+                                 fadeTgtBreakpoint( bpPos.breakpoint(), bpPos.time() ) );           
+                    dontAddBefore = bpPos.time() + _minBreakpointGapSec;
+                }
+            }
+            
+            if ( newp.numBreakpoints() > 0 )
+            {
+                ++debugCounter;
+                _partials.push_back( newp );
+            }
+        }
+    }
+    debugger << "kept " << debugCounter << " from sound 2" << endl;
+}
+
+// ---------------------------------------------------------------------------
+//    morph
+// ---------------------------------------------------------------------------
+//    Morph two sounds (collections of Partials labeled to indicate
+//    correspondences) into a single labeled collection of Partials.
+//    Unlabeled Partials (having label 0) are crossfaded. The morphed
+//    and crossfaded Partials are stored in the Morpher's PartialList.
+//
+//    The Partials in the first range are treated as components of the 
+//    source sound, corresponding to a morph function value of 0, and  
+//    those in the second are treated as components of the target sound, 
+//    corresponding to a morph function value of 1.
+//
+//    Throws InvalidArgument if either the source or target
+//    sequence is not distilled (contains more than one Partial having
+//    the same non-zero label).
+//
+//    Ugh! This ought to be a template function!
+// Ugh! But then crossfade needs to be a template function.
+// Maybe need to do something different with crossfade first.
+//
+void 
+Morpher::morph( PartialList::const_iterator beginSrc, 
+                PartialList::const_iterator endSrc,
+                PartialList::const_iterator beginTgt, 
+                PartialList::const_iterator endTgt )
+{
+    //    build a PartialCorrespondence, a map of labels
+    //    to pairs of pointers to Partials, by making every
+    //    Partial in the source the first element of the
+    //    pair at the corresponding label, and every Partial
+    //    in the target the second element of the pair at
+    //    the corresponding label. Pointers not assigned to
+    //    point to a Partial in the source or target are 
+    //    initialized to 0 in the correspondence map.
+    PartialCorrespondence correspondence;
+    
+    //    add source Partials to the correspondence map:
+    for ( PartialList::const_iterator it = beginSrc; it != endSrc; ++it ) 
+    {
+        //    don't add the crossfade label to the set:
+        if ( it->label() != 0 )
+        {
+            MorphingPair & match = correspondence[ it->label() ];
+            if ( match.src.numBreakpoints() != 0 )
+            {
+                Throw( InvalidArgument, "Source Partials must be distilled before morphing." );
+            }
+            match.src = *it;
+        }
+    }
+    
+    //    add target Partials to the correspondence map:
+    for ( PartialList::const_iterator it = beginTgt; it != endTgt; ++it ) 
+    {
+        //    don't add the crossfade label to the set:
+        if ( it->label() != 0 )
+        {
+            MorphingPair & match = correspondence[ it->label() ];
+            if ( match.tgt.numBreakpoints() != 0 )
+            {
+                Throw( InvalidArgument, "Target Partials must be distilled before morphing." );
+            }
+            match.tgt = *it;
+        }
+    }
+    
+    //    morph corresponding labeled Partials:
+    morph_aux( correspondence );
+    
+    //    crossfade the remaining unlabeled Partials:
+    crossfade( beginSrc, endSrc, beginTgt, endTgt );
+}
+
+// ---------------------------------------------------------------------------
+//    morphBreakpoints
+// ---------------------------------------------------------------------------
+//!    Compute morphed parameter values at the specified time, using
+//!    the source and target Breakpoints (assumed to correspond exactly
+//!    to the specified time).
+//!
+//!    \param  srcBkpt is the Breakpoint corresponding to a morph function
+//!            value of 0.
+//!    \param  tgtBkpt is the Breakpoint corresponding to a morph function
+//!            value of 1.
+//!    \param  time is the time corresponding to srcBkpt (used
+//!            to evaluate the morphing functions and tgtPartial).
+//!    \return the morphed Breakpoint
+//
+Breakpoint
+Morpher::morphBreakpoints( Breakpoint srcBkpt, Breakpoint tgtBkpt, 
+                           double time  ) const
+{
+   double fweight = _freqFunction->valueAt( time );
+   double aweight = _ampFunction->valueAt( time );
+   double bweight = _bwFunction->valueAt( time );
+
+   // compute interpolated Breakpoint parameters:
+   return interpolateParameters( srcBkpt, tgtBkpt, fweight, 
+                                 aweight, bweight );
+}
+
+// ---------------------------------------------------------------------------
+//    morphSrcBreakpoint
+// ---------------------------------------------------------------------------
+//!    Compute morphed parameter values at the specified time, using
+//!    the source Breakpoint (assumed to correspond exactly to the
+//!    specified time) and the target Partial (whose parameters are
+//!    examined at the specified time).
+//!
+//!    \pre    the target Partial may not be a dummy Partial (no Breakpoints).
+//!
+//!    \param  srcBkpt is the Breakpoint corresponding to a morph function
+//!            value of 0.
+//!    \param  tgtPartial is the Partial corresponding to a morph function
+//!            value of 1, evaluated at the specified time.
+//!    \param  time is the time corresponding to srcBkpt (used
+//!            to evaluate the morphing functions and tgtPartial).
+//!    \return the morphed Breakpoint
+//
+Breakpoint
+Morpher::morphSrcBreakpoint( const Breakpoint & srcBkpt, const Partial & tgtPartial, 
+                             double time  ) const
+{
+    if ( 0 == tgtPartial.numBreakpoints() )
+    {
+        Throw( InvalidArgument, "morphSrcBreakpoint cannot morph with empty Partial" );
+    }
+    
+    Breakpoint tgtBkpt = tgtPartial.parametersAt( time );
+    
+    return morphBreakpoints( srcBkpt, tgtBkpt, time );
+}
+
+// ---------------------------------------------------------------------------
+//    morphTgtBreakpoint
+// ---------------------------------------------------------------------------
+//!    Compute morphed parameter values at the specified time, using
+//!    the target Breakpoint (assumed to correspond exactly to the
+//!    specified time) and the source Partial (whose parameters are
+//!    examined at the specified time).
+//!
+//!    \pre    the source Partial may not be a dummy Partial (no Breakpoints).
+//!
+//!    \param  tgtBkpt is the Breakpoint corresponding to a morph function
+//!            value of 1.
+//!    \param  srcPartial is the Partial corresponding to a morph function
+//!            value of 0, evaluated at the specified time.
+//!    \param  time is the time corresponding to srcBkpt (used
+//!            to evaluate the morphing functions and srcPartial).
+//!    \return the morphed Breakpoint
+//
+Breakpoint
+Morpher::morphTgtBreakpoint( const Breakpoint & tgtBkpt, const Partial & srcPartial, 
+                             double time  ) const
+{
+    if ( 0 == srcPartial.numBreakpoints() )
+    {
+        Throw( InvalidArgument, "morphTgtBreakpoint cannot morph with empty Partial" );
+    }
+    
+    Breakpoint srcBkpt = srcPartial.parametersAt( time );
+   
+    return morphBreakpoints( srcBkpt, tgtBkpt, time );
+}
+
+// ---------------------------------------------------------------------------
+//    fadeSrcBreakpoint
+// ---------------------------------------------------------------------------
+//! Compute morphed parameter values at the specified time, using
+//! the source Breakpoint, assumed to correspond exactly to the
+//! specified time, and assuming that there is no corresponding 
+//! target Partial, so the source Breakpoint should be simply faded.
+//!
+//! \param  bp is the Breakpoint corresponding to a morph function
+//!         value of 0.
+//! \param  time is the time corresponding to bp (used
+//!         to evaluate the morphing functions).
+//! \return the faded Breakpoint
+//
+Breakpoint
+Morpher::fadeSrcBreakpoint( Breakpoint bp, double time ) const
+{
+    double alpha = _ampFunction->valueAt( time );
+    bp.setAmplitude( interpolateAmplitude( bp.amplitude(), 0, 
+                                           alpha ) );
+    return bp;
+}
+
+// ---------------------------------------------------------------------------
+//    fadeTgtBreakpoint
+// ---------------------------------------------------------------------------
+//! Compute morphed parameter values at the specified time, using
+//! the target Breakpoint, assumed to correspond exactly to the
+//! specified time, and assuming that there is not corresponding 
+//! source Partial, so the target Breakpoint should be simply faded.
+//!
+//! \param  bp is the Breakpoint corresponding to a morph function
+//!         value of 1.
+//! \param  time is the time corresponding to bp (used
+//!         to evaluate the morphing functions).
+//! \return the faded Breakpoint
+//
+Breakpoint
+Morpher::fadeTgtBreakpoint( Breakpoint bp, double time ) const
+{
+    double alpha = _ampFunction->valueAt( time );
+    bp.setAmplitude( interpolateAmplitude( 0, bp.amplitude(), 
+                                           alpha ) );
+    return bp;
+}
+
+// -- morphing function access/mutation --
+
+// ---------------------------------------------------------------------------
+//    setFrequencyFunction
+// ---------------------------------------------------------------------------
+//    Assign a new frequency morphing envelope to this Morpher.
+//
+void
+Morpher::setFrequencyFunction( const Envelope & f )
+{
+    _freqFunction.reset( f.clone() );
+}
+
+// ---------------------------------------------------------------------------
+//    setAmplitudeFunction
+// ---------------------------------------------------------------------------
+//    Assign a new amplitude morphing envelope to this Morpher.
+//
+void
+Morpher::setAmplitudeFunction( const Envelope & f )
+{
+    _ampFunction.reset( f.clone() );
+}
+
+// ---------------------------------------------------------------------------
+//    setBandwidthFunction
+// ---------------------------------------------------------------------------
+//    Assign a new bandwidth morphing envelope to this Morpher.
+//
+void
+Morpher::setBandwidthFunction( const Envelope & f )
+{
+    _bwFunction.reset( f.clone() );
+}
+
+// ---------------------------------------------------------------------------
+//    frequencyFunction
+// ---------------------------------------------------------------------------
+//    Return a reference to this Morpher's frequency morphing envelope.
+//
+const Envelope &
+Morpher::frequencyFunction( void ) const 
+{
+    return * _freqFunction;
+}
+
+// ---------------------------------------------------------------------------
+//    amplitudeFunction
+// ---------------------------------------------------------------------------
+//    Return a reference to this Morpher's amplitude morphing envelope.
+//
+const Envelope &
+Morpher::amplitudeFunction( void ) const 
+{
+    return * _ampFunction;
+}
+
+// ---------------------------------------------------------------------------
+//    bandwidthFunction
+// ---------------------------------------------------------------------------
+//    Return a reference to this Morpher's bandwidth morphing envelope.
+//
+const Envelope &
+Morpher::bandwidthFunction( void ) const 
+{
+    return * _bwFunction;
+}
+
+
+// -- reference Partial label access/mutation --
+
+// ---------------------------------------------------------------------------
+//    sourceReferencePartial
+// ---------------------------------------------------------------------------
+//! Return the Partial to be used as a reference
+//! Partial for the source sequence in a morph of two Partial
+//! sequences. The reference partial is used to compute 
+//! frequencies for very low-amplitude Partials whose frequency
+//! estimates are not considered reliable. The reference Partial
+//! is considered to have good frequency estimates throughout.
+//! A default (empty) Partial indicates that no reference Partial
+//! should be used for the source sequence.
+//
+const Partial &
+Morpher::sourceReferencePartial( void ) const
+{
+    return _srcRefPartial;
+}
+
+// ---------------------------------------------------------------------------
+//    sourceReferencePartial
+// ---------------------------------------------------------------------------
+//! Return the Partial to be used as a reference
+//! Partial for the source sequence in a morph of two Partial
+//! sequences. The reference partial is used to compute 
+//! frequencies for very low-amplitude Partials whose frequency
+//! estimates are not considered reliable. The reference Partial
+//! is considered to have good frequency estimates throughout.
+//! A default (empty) Partial indicates that no reference Partial
+//! should be used for the source sequence.
+//
+Partial &
+Morpher::sourceReferencePartial( void )
+{
+    return _srcRefPartial;
+}
+
+// ---------------------------------------------------------------------------
+//    targetReferenceLabel
+// ---------------------------------------------------------------------------
+//! Return the Partial to be used as a reference
+//! Partial for the target sequence in a morph of two Partial
+//! sequences. The reference partial is used to compute 
+//! frequencies for very low-amplitude Partials whose frequency
+//! estimates are not considered reliable. The reference Partial
+//! is considered to have good frequency estimates throughout.
+//! A default (empty) Partial indicates that no reference Partial
+//! should be used for the target sequence.
+//
+const Partial &
+Morpher::targetReferencePartial( void ) const
+{
+    return _tgtRefPartial;
+}
+    
+// ---------------------------------------------------------------------------
+//    targetReferenceLabel
+// ---------------------------------------------------------------------------
+//! Return the Partial to be used as a reference
+//! Partial for the target sequence in a morph of two Partial
+//! sequences. The reference partial is used to compute 
+//! frequencies for very low-amplitude Partials whose frequency
+//! estimates are not considered reliable. The reference Partial
+//! is considered to have good frequency estimates throughout.
+//! A default (empty) Partial indicates that no reference Partial
+//! should be used for the target sequence.
+//
+Partial &
+Morpher::targetReferencePartial( void ) 
+{
+    return _tgtRefPartial;
+}
+    
+// ---------------------------------------------------------------------------
+//    setSourceReferencePartial
+// ---------------------------------------------------------------------------
+//! Specify the Partial to be used as a reference
+//! Partial for the source sequence in a morph of two Partial
+//! sequences. The reference partial is used to compute 
+//! frequencies for very low-amplitude Partials whose frequency
+//! estimates are not considered reliable. The reference Partial
+//! is considered to have good frequency estimates throughout.
+//! The specified Partial must be labeled with its harmonic number.
+//! A default (empty) Partial indicates that no reference 
+//! Partial should be used for the source sequence.
+//
+void 
+Morpher::setSourceReferencePartial( const Partial & p )
+{
+    if ( p.label() == 0 )
+    {
+        Throw( InvalidArgument, 
+               "the morphing source reference Partial must be "
+               "labeled with its harmonic number" );
+    }
+    _srcRefPartial = p;
+}
+
+// ---------------------------------------------------------------------------
+//    setSourceReferencePartial
+// ---------------------------------------------------------------------------
+//! Specify the Partial to be used as a reference
+//! Partial for the source sequence in a morph of two Partial
+//! sequences. The reference partial is used to compute 
+//! frequencies for very low-amplitude Partials whose frequency
+//! estimates are not considered reliable. The reference Partial
+//! is considered to have good frequency estimates throughout.
+//! A default (empty) Partial indicates that no reference 
+//! Partial should be used for the source sequence.
+//!
+//! \param  partials a sequence of Partials to search
+//!         for the reference Partial
+//! \param  refLabel the label of the Partial in partials
+//!         that should be selected as the reference
+//
+void 
+Morpher::setSourceReferencePartial( const PartialList & partials, 
+                                    Partial::label_type refLabel )
+{
+    if ( refLabel != 0 )
+    {
+        PartialList::const_iterator pos = 
+            std::find_if( partials.begin(), partials.end(), 
+                          PartialUtils::isLabelEqual( refLabel ) );
+        if ( pos == partials.end() )
+        {
+            Throw( InvalidArgument, "no Partial has the specified reference label" );
+        }
+        _srcRefPartial = *pos;
+    }
+    else
+    {
+        _srcRefPartial = Partial();
+    }
+}
+
+// ---------------------------------------------------------------------------
+//    setTargetReferencePartial
+// ---------------------------------------------------------------------------
+//! Specify the Partial to be used as a reference
+//! Partial for the target sequence in a morph of two Partial
+//! sequences. The reference partial is used to compute 
+//! frequencies for very low-amplitude Partials whose frequency
+//! estimates are not considered reliable. The reference Partial
+//! is considered to have good frequency estimates throughout.
+//! The specified Partial must be labeled with its harmonic number.
+//! A default (empty) Partial indicates that no reference 
+//! Partial should be used for the target sequence.
+//
+void 
+Morpher::setTargetReferencePartial( const Partial & p )
+{
+    if ( p.label() == 0 )
+    {
+        Throw( InvalidArgument, 
+               "the morphing target reference Partial must be "
+               "labeled with its harmonic number" );
+    }
+    _tgtRefPartial = p;
+}
+
+// ---------------------------------------------------------------------------
+//    setTargetReferencePartial
+// ---------------------------------------------------------------------------
+//! Specify the Partial to be used as a reference
+//! Partial for the target sequence in a morph of two Partial
+//! sequences. The reference partial is used to compute 
+//! frequencies for very low-amplitude Partials whose frequency
+//! estimates are not considered reliable. The reference Partial
+//! is considered to have good frequency estimates throughout.
+//! A default (empty) Partial indicates that no reference 
+//! Partial should be used for the target sequence.
+//!
+//! \param  partials a sequence of Partials to search
+//!         for the reference Partial
+//! \param  refLabel the label of the Partial in partials
+//!         that should be selected as the reference
+//
+void 
+Morpher::setTargetReferencePartial( const PartialList & partials, 
+                                    Partial::label_type refLabel )
+{
+    if ( refLabel != 0 )
+    {
+        PartialList::const_iterator pos = 
+            std::find_if( partials.begin(), partials.end(), 
+                          PartialUtils::isLabelEqual( refLabel ) );
+        if ( pos == partials.end() )
+        {
+            Throw( InvalidArgument, "no Partial has the specified reference label" );
+        }
+        _tgtRefPartial = *pos;
+    }
+    else
+    {
+        _tgtRefPartial = Partial();
+    }
+}
+
+
+// ---------------------------------------------------------------------------
+//    amplitudeShape
+// ---------------------------------------------------------------------------
+//    Return the shaping parameter for the amplitude moprhing
+//    function (only used in new log-amplitude morphing).
+//    This shaping parameter controls the 
+//    slope of the amplitude morphing function,
+//    for values greater than 1, this function
+//    gets nearly linear (like the old amplitude
+//    morphing function), for values much less 
+//    than 1 (e.g. 1E-5) the slope is gently
+//    curved and sounds pretty "linear", for 
+//    very small values (e.g. 1E-12) the curve
+//    is very steep and sounds un-natural because
+//    of the huge jump from zero amplitude to
+//    very small amplitude.
+double Morpher::amplitudeShape( void ) const
+{
+    return _logMorphShape;
+}
+
+// ---------------------------------------------------------------------------
+//    setAmplitudeShape
+// ---------------------------------------------------------------------------
+//    Set the shaping parameter for the amplitude moprhing
+//    function. This shaping parameter controls the 
+//    slope of the amplitude morphing function,
+//    for values greater than 1, this function
+//    gets nearly linear (like the old amplitude
+//    morphing function), for values much less 
+//    than 1 (e.g. 1E-5) the slope is gently
+//    curved and sounds pretty "linear", for 
+//    very small values (e.g. 1E-12) the curve
+//    is very steep and sounds un-natural because
+//    of the huge jump from zero amplitude to
+//    very small amplitude.
+//
+//    x is the new shaping parameter, it must be positive.
+void Morpher::setAmplitudeShape( double x )
+{
+    if ( x <= 0. )
+    {
+        Throw( InvalidArgument, "the amplitude morph shaping parameter must be positive");
+    }
+    _logMorphShape = x;
+}
+
+// ---------------------------------------------------------------------------
+//    minBreakpointGap
+// ---------------------------------------------------------------------------
+//    Return the minimum time gap (secs) between two Breakpoints
+//    in the morphed Partials. Morphing two
+//    Partials can generate a third Partial having
+//    Breakpoints arbitrarily close together in time,
+//    and this makes morphs huge. Raising this 
+//    threshold limits the Breakpoint density in
+//    the morphed Partials. Default is 1/10 ms.
+double Morpher::minBreakpointGap( void ) const
+{
+    return _minBreakpointGapSec;
+}
+
+// ---------------------------------------------------------------------------
+//    setMinBreakpointGap
+// ---------------------------------------------------------------------------
+//    Set the minimum time gap (secs) between two Breakpoints
+//    in the morphed Partials. Morphing two
+//    Partials can generate a third Partial having
+//    Breakpoints arbitrarily close together in time,
+//    and this makes morphs huge. Raising this 
+//    threshold limits the Breakpoint density in
+//    the morphed Partials. Default is 1/10 ms.
+//
+//    x is the new minimum gap in seconds, it must be positive
+//    
+void Morpher::setMinBreakpointGap( double x )
+{
+    if ( x <= 0. )
+    {
+        Throw( InvalidArgument, "the minimum Breakpoint gap must be positive");
+    }
+    _minBreakpointGapSec = x;
+}
+
+// -- PartialList access --
+
+// ---------------------------------------------------------------------------
+//    partials
+// ---------------------------------------------------------------------------
+//    Return a reference to this Morpher's list of morphed Partials.
+//
+PartialList & 
+Morpher::partials( void )
+{ 
+    return _partials; 
+}
+
+// ---------------------------------------------------------------------------
+//    partials
+// ---------------------------------------------------------------------------
+//    Return a const reference to this Morpher's list of morphed Partials.
+//
+const PartialList & 
+Morpher::partials( void ) const 
+{ 
+    return _partials; 
+}
+
+// -- helpers: morphed parameter computation --
+
+// ---------------------------------------------------------------------------
+//    morph_aux
+// ---------------------------------------------------------------------------
+//    Helper function that performs the morph between corresponding pairs
+//    of Partials identified in a PartialCorrespondence. Called by the
+//    morph() implementation accepting two sequences of Partials.
+//
+//    PartialCorrespondence represents a map from non-zero Partial 
+//    labels to pairs of Partials (MorphingPair) that should be morphed 
+//    into a single Partial that is assigned that label. 
+//
+void Morpher::morph_aux( PartialCorrespondence & correspondence  )
+{
+    PartialCorrespondence::const_iterator it;
+    for ( it = correspondence.begin(); it != correspondence.end(); ++it )
+    {
+        Partial::label_type label = it->first;
+        MorphingPair match = it->second;
+        Partial & src = match.src;
+        Partial & tgt = match.tgt;
+       
+        //  sanity check:
+        //  one of those Partials must have some Breakpoints
+        Assert( src.numBreakpoints() != 0 || tgt.numBreakpoints() != 0 );
+
+        debugger << "morphing " << ( ( 0 < src.numBreakpoints() )?( 1 ):( 0 ) )
+                   << " and " << ( ( 0 < tgt.numBreakpoints() )?( 1 ):( 0 ) )
+                   << " partials with label " <<    label << endl;
+                   
+        //  &^)     HEY LOOKIE HERE!!!!!!!!!!!!!                   
+        
+        //  ensure that Partials begin and end at zero
+        //  amplitude to solve the problem of Nulls 
+        //  getting left out of morphed Partials leading to
+        //  erroneous non-zero amplitude segments:
+        if ( src.numBreakpoints() != 0 )
+        {
+            if ( src.first().amplitude() != 0.0 && src.startTime() > _minBreakpointGapSec )
+            {
+                double t = src.startTime() - _minBreakpointGapSec;
+                Breakpoint null = src.parametersAt( t );
+                src.insert( t, null );
+            }
+            if ( src.last().amplitude() != 0.0 )
+            {
+                double t = src.endTime() + _minBreakpointGapSec;
+                Breakpoint null = src.parametersAt( t );
+                src.insert( t, null );
+            }
+        }
+        
+        if ( tgt.numBreakpoints() != 0 )
+        {            
+            if ( tgt.first().amplitude() != 0.0 && tgt.startTime() > _minBreakpointGapSec )
+            {
+                double t = tgt.startTime() - _minBreakpointGapSec;
+                Breakpoint null = tgt.parametersAt( t );
+                tgt.insert( t, null );
+            }
+            if ( tgt.last().amplitude() != 0.0 )
+            {
+                double t = tgt.endTime() + _minBreakpointGapSec;
+                Breakpoint null = tgt.parametersAt( t );
+                tgt.insert( t, null );
+            }
+        }
+        //  &^)     HEY LOOKIE HERE!!!!!!!!!!!!!                   
+        //  the question is: after sticking nulls on the ends,
+        //  should be strip nulls OFF the ends of the morphed
+        //  partial? If so, how many? (ans to second is one, 
+        //  cannot have both nulls appear at end of morphed,
+        //  because of min gap). If we unconditionally add
+        //  nulls to ends (regardless of starting and ending
+        //  amps), then we can (I think) be sure that taking
+        //  off one null from each end leaves the Partial in 
+        //  an unmolested state.... maybe. No, its possible that
+        //  the morphing function would skip over both artificial
+        //  nulls, so we cannot be sure. Hmmmmm....
+        //  For now, just leave the nulls on the ends,
+        //  the are relatively harmless.
+        //
+        //  Actually, a (klugey) solution is to remember the times 
+        //  of those artificial nulls, and then see if the
+        //  Partial begins or ends at one of those times.
+        //  No, cannot guarantee that one Partial doesn't
+        //  have a null at the time we put an artificial null
+        //  in the other one. Hmmmmm.....
+
+               
+        //  perform the morph between the two Partials, 
+        //  save the result if it has any Breakpoints
+        //  (it may not depending on the morphing functions):                          
+        Partial newp = morphPartials( src, tgt, label );
+        if ( partial_is_nonnull( newp ) )
+        {
+            _partials.push_back( newp );
+        }
+    }
+}
+
+
+// ---------------------------------------------------------------------------
+//    adjustFrequency
+// ---------------------------------------------------------------------------
+//  Adjust frequency of low-amplitude Breakpoints to be harmonics of the
+//  reference Partial, if one has been specified.
+//
+//  Leave the phase alone, because I don't know what we can do with it.
+//
+static void adjustFrequency( Breakpoint & bp, const Partial & ref, 
+                             Partial::label_type harmonicNum,
+                             double thresholdDb,
+                             double time )
+{
+    if ( ref.numBreakpoints() != 0 )
+    {
+        //    compute absolute magnitude thresholds:
+        static const double FadeRangeDB = 10;
+        const double BeginFade = std::pow( 10., 0.05 * (thresholdDb+FadeRangeDB) );
+                
+        if ( bp.amplitude() < BeginFade )
+        {
+            const double Threshold = std::pow( 10., 0.05 * thresholdDb );
+            const double OneOverFadeSpan = 1. / ( BeginFade - Threshold );
+
+            double fscale = (double)harmonicNum / ref.label();
+
+            double alpha = std::min( ( BeginFade - bp.amplitude() ) * OneOverFadeSpan, 1. );
+            double fRef = ref.frequencyAt( time );
+            bp.setFrequency( ( alpha * ( fRef * fscale ) ) + 
+                             ( (1 - alpha) * bp.frequency() ) );
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+//    partial_is_nonnull
+// ---------------------------------------------------------------------------
+//  Helper function to examine a morphed Partial and determine whether 
+//  it has any non-null Breakpoints. If not, there's no point in saving it.
+//
+static inline bool partial_is_nonnull( const Partial & p )
+{
+    for ( Partial::const_iterator it = p.begin(); it != p.end(); ++it )
+    {
+        if ( it.breakpoint().amplitude() != 0.0 )
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+// ---------------------------------------------------------------------------
+//  Helper function for performing log-domain interpolation
+//  (originally was for amplitude only). 
+//
+//  alpha == 0 returns x, alpha == 1 returns y
+//
+//  It is essential to add in a small offset, so that 
+//  occasional zero amplitudes do not introduce artifacts
+//  (if amp is zero, then even if alpha is very small
+//  the effect is to multiply by zero, because 0^x = 0, 
+//  or note that log(0) is -infinity).
+//
+//  This shaping parameter affects the shape of the morph
+//  curve only when it is of the same order of magnitude as
+//  one of the sources (x or y) and the other is much larger.
+//
+//  When shape is very small, the curve representing the
+//  morphed amplitude is very steep, such that there is a 
+//  huge difference between zero amplitude and very small
+//  amplitude, and this causes audible artifacts. So instead
+//  use a larger value that shapes the curve more nicely. 
+//  Just have to subtract this value from the morphed 
+//  amplitude to avoid raising the noise floor a whole lot.
+//
+static inline double 
+interpolateLog( double x, double y, double alpha, double shape )
+{
+    using std::pow;
+
+    double s = x + shape;
+    double t = y + shape;
+    
+    double v = ( s * pow( t / s, alpha ) ) - shape;
+    
+    return v;
+}
+
+// ---------------------------------------------------------------------------
+//  Helper function for performing linear interpolation
+//  (used to be the only kind we supported).
+//
+//  alpha == 0 returns x, alpha == 1 returns y
+//
+static inline double 
+interpolateLinear( double x, double y, double alpha )
+{
+    double v = (x * (1-alpha)) + (y * alpha);
+    
+    return v;
+}
+
+
+// ---------------------------------------------------------------------------
+//  Helper function for computing individual morphed amplitude values.
+//
+inline double 
+Morpher::interpolateAmplitude( double srcAmp, double tgtAmp, double alpha ) const
+{    
+    double morphedAmp = 0;  
+
+    if ( _doLogAmpMorphing )
+    {
+        //  if both are small, just return 0
+        //  HEY, is this really what we want?
+        static const double Epsilon = 1E-12;
+        if ( ( srcAmp > Epsilon ) || ( tgtAmp > Epsilon ) )
+        {
+            morphedAmp = interpolateLog( srcAmp, tgtAmp, alpha, _logMorphShape );
+        }
+    }
+    else
+    {
+        morphedAmp = interpolateLinear( srcAmp, tgtAmp, alpha );
+    }
+
+    //  Partial amplitudes should never be negative
+    double res = std::max( 0.0, morphedAmp );                
+
+    return res;
+}
+
+// ---------------------------------------------------------------------------
+//  Helper function for computing individual morphed bandwidth values.
+//
+inline double 
+Morpher::interpolateBandwidth( double srcBw, double tgtBw, double alpha ) const
+{    
+    double morphedBw = 0;
+        
+    if ( _doLogAmpMorphing )
+    {
+        //  if both are small, just return 0
+        //  HEY, is this really what we want?
+        static const double Epsilon = 1E-12;
+        if ( ( srcBw > Epsilon ) || ( tgtBw > Epsilon ) )
+        {
+            morphedBw = interpolateLog( srcBw, tgtBw, alpha, _logMorphShape );
+        }
+    }
+    else
+    {
+        morphedBw = interpolateLinear( srcBw, tgtBw, alpha );
+    }
+
+    //  Partial bandwidths should never be negative
+    double res = std::max( 0.0, morphedBw );                
+    
+
+    return res;
+}
+
+// ---------------------------------------------------------------------------
+//  Helper function for computing individual morphed frequency values.
+//
+inline double 
+Morpher::interpolateFrequency( double srcFreq, double tgtFreq, double alpha ) const
+{   
+    double morphedFreq = 1;
+        
+    if ( _doLogFreqMorphing )
+    {       
+        //  guard against the extremely unlikely possibility that
+        //  one of the frequencies is zero
+        double shape = 0;
+        if ( 0 == srcFreq || 0 == tgtFreq  )
+        {
+            shape = Morpher::DefaultAmpShape;
+        }
+        morphedFreq = interpolateLog( srcFreq, tgtFreq, alpha, shape );
+    }
+    else
+    {
+        morphedFreq = interpolateLinear( srcFreq, tgtFreq, alpha );
+    }
+    
+    return morphedFreq;
+}
+
+// ---------------------------------------------------------------------------
+//  Helper function for computing individual morphed phase values.
+//
+inline double 
+Morpher::interpolatePhase( double srcphase, double tgtphase, double alpha ) const
+{    
+    // Interpolate raw absolute phase values. If the interpolated
+    // phase matters at all (near the morphing function boudaries 0
+    // and 1) then that will give a good target phase value, and the
+    // frequency will be adjusted to match the phase. Otherwise,
+    // the phase will just be recomputed to match the interpolated
+    // frequency.
+    //
+    // Wrap the computed phase onto an appropriate range.
+    // wrap the phases so that they are as similar as possible,
+    // so that phase interpolation is shift-invariant.
+    while ( ( srcphase - tgtphase ) > Pi )
+    {
+      srcphase -= 2 * Pi;
+    }
+    while ( ( tgtphase - srcphase ) > Pi )
+    {
+      srcphase += 2 * Pi;
+    }
+
+    double morphedPhase = interpolateLinear( srcphase, tgtphase, alpha );
+
+    return std::fmod( morphedPhase, 2 * Pi );
+}
+
+// ---------------------------------------------------------------------------
+//    Helper function for interpolating Breakpoint parameters
+//
+inline Breakpoint 
+Morpher::interpolateParameters( const Breakpoint & srcBkpt, const Breakpoint & tgtBkpt,
+                                double fweight, double aweight, double bweight ) const
+{
+    Breakpoint morphed;
+
+    // interpolate frequencies:
+    morphed.setFrequency(
+        interpolateFrequency( srcBkpt.frequency(), tgtBkpt.frequency(),
+                              fweight ) );
+
+    // interpolate LOG amplitudes:
+    morphed.setAmplitude( 
+        interpolateAmplitude( srcBkpt.amplitude(), tgtBkpt.amplitude(), 
+                              aweight ) );
+
+    // interpolate bandwidth: 
+    morphed.setBandwidth(  
+        interpolateBandwidth( srcBkpt.bandwidth(), tgtBkpt.bandwidth(), 
+                              bweight ) );
+
+    // interpolate phase:
+    morphed.setPhase( 
+        interpolatePhase( srcBkpt.phase(), tgtBkpt.phase(), fweight ) );
+
+    return morphed;
+}
+
+// ---------------------------------------------------------------------------
+//    appendMorphedSrc
+// ---------------------------------------------------------------------------
+//! Compute morphed parameter values at the specified time, using
+//! the source Breakpoint (assumed to correspond exactly to the
+//! specified time) and the target Partial (whose parameters are
+//! examined at the specified time). Append the morphed Breakpoint
+//! to newp only if the source should contribute to the morph at
+//! the specified time.
+//!
+//! If the target Partial is a dummy Partial (no Breakpoints), fade the
+//! source instead of morphing.
+//!
+//! \param  srcBkpt is the Breakpoint corresponding to a morph function
+//!         value of 0.
+//! \param  tgtPartial is the Partial corresponding to a morph function
+//!         value of 1, evaluated at the specified time.
+//! \param  time is the time corresponding to srcBkpt (used
+//!         to evaluate the morphing functions and tgtPartial).
+//! \param  newp is the morphed Partial under construction, the morphed
+//!         Breakpoint is added to this Partial.
+//
+void
+Morpher::appendMorphedSrc( Breakpoint srcBkpt, const Partial & tgtPartial, 
+                           double time, Partial & newp  )
+{
+    double fweight = _freqFunction->valueAt( time );
+    double aweight = _ampFunction->valueAt( time );
+    double bweight = _bwFunction->valueAt( time );
+    
+    //  Need to insert a null (0 amplitude) Breakpoint
+    //  if src and tgt are 0 amplitude but the morphed
+    //  Partial is not. In rare cases, it is possible
+    //  to miss a needed null if we don't check for it 
+    //  explicitly. 
+    bool needNull = ( newp.numBreakpoints() != 0 ) &&
+                    ( newp.last().amplitude() != 0 ) &&
+                    ( srcBkpt.amplitude() == 0) &&
+                    ( tgtPartial.numBreakpoints() != 0 ) &&
+                    ( tgtPartial.amplitudeAt( time ) == 0 );
+
+    //  Don't insert Breakpoints at src times if all 
+    //  morph functions equal 1 (or > MaxMorphParam),
+    //  and a null is not needed.
+    const double MaxMorphParam = .9;
+    if ( fweight < MaxMorphParam ||
+         aweight < MaxMorphParam ||
+         bweight < MaxMorphParam ||
+         needNull )
+    {
+        
+        // adjust source Breakpoint frequencies according to the reference
+        // Partial (if a reference has been specified):
+        adjustFrequency( srcBkpt, _srcRefPartial, newp.label(), _freqFixThresholdDb, time );
+            
+        if ( 0 == tgtPartial.numBreakpoints() )
+        {
+            //  no corresponding target Partial exists:
+            if ( 0 == _tgtRefPartial.numBreakpoints() )
+            {
+                //  no reference Partial specified for tgt,
+                //  fade src instead:
+                newp.insert( time, fadeSrcBreakpoint( srcBkpt, time ) );
+            }
+            else
+            {
+                //  reference Partial has been provided for tgt,
+                //  use it to construct a fake Breakpoint to morph
+                //  with the src:
+                Breakpoint tgtBkpt = _tgtRefPartial.parametersAt( time );
+                double fscale = (double) newp.label() / _tgtRefPartial.label();
+                tgtBkpt.setFrequency( fscale * tgtBkpt.frequency() );
+                tgtBkpt.setPhase( fscale * tgtBkpt.phase() );
+                tgtBkpt.setAmplitude( 0 );
+                tgtBkpt.setBandwidth( 0 );
+                
+                // compute interpolated Breakpoint parameters:
+                newp.insert( time, interpolateParameters( srcBkpt, tgtBkpt, fweight, 
+                                                          aweight, bweight ) );
+            }
+        }    
+        else
+        {
+            Breakpoint tgtBkpt = tgtPartial.parametersAt( time );
+            
+            // adjust target Breakpoint frequencies according to the reference
+            // Partial (if a reference has been specified):
+            adjustFrequency( tgtBkpt, _tgtRefPartial, newp.label(), _freqFixThresholdDb, time );
+            
+            // compute interpolated Breakpoint parameters:
+            Breakpoint morphed = interpolateParameters( srcBkpt, tgtBkpt, fweight, 
+                                                        aweight, bweight );
+            newp.insert( time, morphed );
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+//    appendMorphedTgt
+// ---------------------------------------------------------------------------
+//! Compute morphed parameter values at the specified time, using
+//! the target Breakpoint (assumed to correspond exactly to the
+//! specified time) and the source Partial (whose parameters are
+//! examined at the specified time). Append the morphed Breakpoint
+//! to newp only if the target should contribute to the morph at
+//! the specified time.
+//!
+//! If the source Partial is a dummy Partial (no Breakpoints), fade the
+//! target instead of morphing.
+//!
+//! \param  tgtBkpt is the Breakpoint corresponding to a morph function
+//!         value of 1.
+//! \param  srcPartial is the Partial corresponding to a morph function
+//!         value of 0, evaluated at the specified time.
+//! \param  time is the time corresponding to srcBkpt (used
+//!         to evaluate the morphing functions and srcPartial).
+//! \param  newp is the morphed Partial under construction, the morphed
+//!         Breakpoint is added to this Partial.
+//
+void
+Morpher::appendMorphedTgt( Breakpoint tgtBkpt, const Partial & srcPartial, 
+                           double time, Partial & newp  )
+{    
+    double fweight = _freqFunction->valueAt( time );
+    double aweight = _ampFunction->valueAt( time );
+    double bweight = _bwFunction->valueAt( time );
+    
+    //  Need to insert a null (0 amplitude) Breakpoint
+    //  if src and tgt are 0 amplitude but the morphed
+    //  Partial is not. In rare cases, it is possible
+    //  to miss a needed null if we don't check for it 
+    //  explicitly. 
+    bool needNull = ( newp.numBreakpoints() != 0 ) &&
+                    ( newp.last().amplitude() != 0 ) &&
+                    ( tgtBkpt.amplitude() == 0) &&
+                    ( srcPartial.numBreakpoints() != 0 ) &&
+                    ( srcPartial.amplitudeAt( time ) == 0 );
+
+    //  Don't insert Breakpoints at src times if all 
+    //  morph functions equal 0 (or < MinMorphParam),
+    //  and a null is not needed.
+    const double MinMorphParam = .1;
+    if ( fweight > MinMorphParam ||
+         aweight > MinMorphParam ||
+         bweight > MinMorphParam ||
+         needNull )
+    {
+        
+        // adjust target Breakpoint frequencies according to the reference
+        // Partial (if a reference has been specified):
+        adjustFrequency( tgtBkpt, _tgtRefPartial, newp.label(), _freqFixThresholdDb, time );
+
+        if ( 0 == srcPartial.numBreakpoints() )
+        {
+            //  no corresponding source Partial exists:
+            if ( 0 == _srcRefPartial.numBreakpoints() )
+            {
+                //  no reference Partial specified for src,
+                //  fade tgt instead:
+                newp.insert( time, fadeTgtBreakpoint( tgtBkpt, time ) );
+            }
+            else
+            {
+                //  reference Partial has been provided for src,
+                //  use it to construct a fake Breakpoint to morph
+                //  with the tgt:
+                Breakpoint srcBkpt = _srcRefPartial.parametersAt( time );
+                double fscale = (double) newp.label() / _srcRefPartial.label();
+                srcBkpt.setFrequency( fscale * srcBkpt.frequency() );
+                srcBkpt.setPhase( fscale * srcBkpt.phase() );
+                srcBkpt.setAmplitude( 0 );
+                srcBkpt.setBandwidth( 0 );
+
+                // compute interpolated Breakpoint parameters:
+                newp.insert( time, interpolateParameters( srcBkpt, tgtBkpt, fweight, 
+                                                          aweight, bweight ) );
+            }
+        }
+        else
+        {
+            Breakpoint srcBkpt = srcPartial.parametersAt( time );
+
+            // adjust source Breakpoint frequencies according to the reference
+            // Partial (if a reference has been specified):
+            adjustFrequency( srcBkpt, _srcRefPartial, newp.label(), _freqFixThresholdDb, time );
+
+            // compute interpolated Breakpoint parameters:           
+            Breakpoint morphed = interpolateParameters( srcBkpt, tgtBkpt, fweight, 
+                                                        aweight, bweight );
+            newp.insert( time, morphed );
+        }
+    }
+}
+
+}    //    end of namespace Loris
diff --git a/src/loris/Morpher.h b/src/loris/Morpher.h
new file mode 100644
index 0000000..a291cac
--- /dev/null
+++ b/src/loris/Morpher.h
@@ -0,0 +1,590 @@
+#ifndef INCLUDE_MORPHER_H
+#define INCLUDE_MORPHER_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Morpher.h
+ *
+ * Definition of class Morpher.
+ *
+ * Kelly Fitz, 15 Oct 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#include "PartialList.h"
+#include "Partial.h"
+
+#include <memory>   // for auto_ptr
+
+//  begin namespace
+namespace Loris {
+
+class Envelope;
+
+// ---------------------------------------------------------------------------
+//  Class Morpher
+//
+//! Class Morpher performs sound morphing and Partial parameter
+//! envelope interpolation according to a trio of frequency, amplitude,
+//! and bandwidth morphing functions, described by Envelopes.
+//! Sound morphing is achieved by interpolating the time-varying 
+//! frequencies, amplitudes, and bandwidths of corresponding partials 
+//! obtained from reassigned bandwidth-enhanced analysis of the source 
+//! and target sounds. Partial correspondences may be established by 
+//! labeling, using instances of the Channelizer and Distiller classes.
+//!
+//! The Morpher collects morphed Partials in a PartialList, that is
+//! accessible to clients.
+//!
+//! For more information about sound morphing using 
+//! the Reassigned Bandwidth-Enhanced Additive Sound 
+//! Model, refer to the Loris website: 
+//! www.cerlsoundgroup.org/Loris/.
+//! 
+//! Morpher is a leaf class, do not subclass.
+//
+class Morpher
+{
+//  -- instance variables --
+
+    std::auto_ptr< Envelope > _freqFunction;  //!   frequency morphing function
+    std::auto_ptr< Envelope > _ampFunction;   //!   amplitude morphing function
+    std::auto_ptr< Envelope > _bwFunction;    //!   bandwidth morphing function
+    
+    PartialList _partials;                    //!   collect Partials here
+    
+    Partial _srcRefPartial;         //! reference Partials
+    Partial _tgtRefPartial;         //! for source and target sounds when 
+                                    //! morphing sequences of labeled Partials,
+                                    //! default (empty Partial) implies no 
+                                    //! reference Partial is used
+
+    double _freqFixThresholdDb;     //! amplitude threshold below which Partial
+                                    //! frequencies are corrected according to
+                                    //! a reference Partial, if specified.
+    
+    double _logMorphShape;          //! shaping parameter that controls the 
+                                    //! shape of the logarithmic morphing function,
+                                    //! mostly when one of the source values
+                                    //! is equal to zero. 
+                                    //! Only relevant when _doLogAmpMorphing is true.
+                                    //!
+                                    //! Don't use this for anything, just leave it 
+                                    //! at the default.
+                                                            
+    double _minBreakpointGapSec;    //! the minimum time gap between two Breakpoints
+                                    //! in the morphed Partials. Morphing two
+                                    //! Partials can generate a third Partial having
+                                    //! Breakpoints arbitrarily close together in time,
+                                    //! and this makes morphs huge. Raising this 
+                                    //! threshold limits the Breakpoint density in
+                                    //! the morphed Partials. 
+                                    //! Default is 1/10 ms.
+                                    
+                                    
+    bool _doLogAmpMorphing;         //! if true (default), amplitudes and bandwidths 
+                                    //! are morphed in the log domain, if false they 
+                                    //! are morphed in the linear domain.
+                                    
+    bool _doLogFreqMorphing;        //! if true, frequencies are morphed in the log 
+                                    //! domain, if false (default) they  are morphed  
+                                    //! in the linear domain.
+    
+    
+//  -- public interface --
+public:
+//  -- construction --
+
+    //! Construct a new Morpher using the same morphing envelope for 
+    //! frequency, amplitude, and bandwidth (noisiness).
+    //! 
+    //! \param  f is the Envelope to clone for all three morphing 
+    //!            functions.
+    Morpher( const Envelope & f );
+
+    //! Construct a new Morpher using the specified morphing envelopes for
+    //! frequency, amplitude, and bandwidth (noisiness).
+    //!
+    //! \param  ff is the Envelope to clone for the frequency morphing function
+    //! \param  af is the Envelope to clone for the amplitude morphing function
+    //! \param  bwf is the Envelope to clone for the bandwidth morphing function    
+    Morpher( const Envelope & ff, const Envelope & af, const Envelope & bwf );
+
+    //! Construct a new Morpher that is a duplicate of rhs.
+    //!
+    //! \param  rhs is the Morpher to duplicate
+    Morpher( const Morpher & rhs );
+    
+    //! Destroy this Morpher.
+    ~Morpher( void );
+    
+   //! Make this Morpher a duplicate of rhs.
+    //!
+    //! \param  rhs is the Morpher to duplicate
+    Morpher & operator= ( const Morpher & rhs );
+
+//  -- morphed parameter computation --
+
+//  -- Partial morphing --
+
+    //! Morph a pair of Partials to yield a new morphed Partial. 
+    //! Dummy Partials (having no Breakpoints) don't contribute to the
+    //! morph, except to cause their opposite to fade out. 
+    //! Either (or neither) the source or target Partial may be a dummy 
+    //! Partial (no Breakpoints), but not both. The morphed
+    //! Partial has Breakpoints at times corresponding to every Breakpoint 
+    //! in both source Partials, omitting Breakpoints that would be
+    //!   closer than the minBreakpointGap to their predecessor. 
+    //! The new morphed Partial is assigned the specified label and returned.
+    //!
+    //! \param  src is the Partial corresponding to a morph function
+    //!         value of 0, evaluated at the specified time.
+    //! \param  tgt is the Partial corresponding to a morph function
+    //!         value of 1, evaluated at the specified time.
+    //! \param  assignLabel is the label assigned to the morphed Partial
+    //! \return the morphed Partial
+    Partial morphPartials( Partial src, Partial tgt, int assignLabel );
+    
+    //! Bad legacy name for morphPartials.
+    //! \deprecated Use morphPartials instead.
+    Partial morphPartial( Partial src, Partial tgt, int assignLabel )
+        { return morphPartials( src, tgt, assignLabel ); }
+
+    //! Morph two sounds (collections of Partials labeled to indicate
+    //! correspondences) into a single labeled collection of Partials.
+    //! Unlabeled Partials (having label 0) are crossfaded. The morphed
+    //! and crossfaded Partials are stored in the Morpher's PartialList.
+    //!
+    //! The Partials in the first range are treated as components of the 
+    //! source sound, corresponding to a morph function value of 0, and  
+    //! those in the second are treated as components of the target sound, 
+    //! corresponding to a morph function value of 1.
+    //!
+    //! \sa     crossfade, morphPartials
+    //!
+    //! \param  beginSrc is the beginning of the sequence of Partials
+    //!         corresponding to a morph function value of 0.
+    //! \param  endSrc is (one past) the end of the sequence of Partials
+    //!         corresponding to a morph function value of 0.
+    //! \param  beginTgt is the beginning of the sequence of Partials
+    //!         corresponding to a morph function value of 1.
+    //! \param  endTgt is (one past) the end of the sequence of Partials
+    //!         corresponding to a morph function value of 1.
+    void morph( PartialList::const_iterator beginSrc, 
+                PartialList::const_iterator endSrc,
+                PartialList::const_iterator beginTgt, 
+                PartialList::const_iterator endTgt );
+
+    //! Crossfade Partials with no correspondences.
+    //!
+    //! Unlabeled Partials (having the specified label) are considered to 
+    //! have no correspondences, so they are just faded out, and not 
+    //! actually morphed. Consistent with the morphing behavior, 
+    //! crossfaded Partials are thinned, if necssary, so that no
+    //! two Breakpoints are closer in time than the minBreakpointGap.
+    //!
+    //! The Partials in the first range are treated as components of the 
+    //! source sound, corresponding to a morph function value of 0, and  
+    //! those in the second are treated as components of the target sound, 
+    //! corresponding to a morph function value of 1.
+    //!
+    //! The crossfaded Partials are stored in the Morpher's PartialList.
+    //!
+    //! \param  beginSrc is the beginning of the sequence of Partials
+    //!         corresponding to a morph function value of 0.
+    //! \param  endSrc is (one past) the end of the sequence of Partials
+    //!         corresponding to a morph function value of 0.
+    //! \param  beginTgt is the beginning of the sequence of Partials
+    //!         corresponding to a morph function value of 1.
+    //! \param  endTgt is (one past) the end of the sequence of Partials
+    //!         corresponding to a morph function value of 1.
+    //! \param  label is the label to associate with unlabeled
+    //!         Partials (default is 0).
+    void crossfade( PartialList::const_iterator beginSrc, 
+                    PartialList::const_iterator endSrc,
+                    PartialList::const_iterator beginTgt, 
+                    PartialList::const_iterator endTgt,
+                    Partial::label_type label = 0 );
+
+
+    //! Compute morphed parameter values at the specified time, using
+    //! the source and target Breakpoints (assumed to correspond exactly
+    //! to the specified time).
+    //!
+    //! \param  srcBkpt is the Breakpoint corresponding to a morph function
+    //!         value of 0.
+    //! \param  tgtBkpt is the Breakpoint corresponding to a morph function
+    //!         value of 1.
+    //! \param  time is the time corresponding to srcBkpt (used
+    //!         to evaluate the morphing functions and tgtPartial).
+    //! \return the morphed Breakpoint
+    //
+    Breakpoint
+    morphBreakpoints( Breakpoint srcBkpt, Breakpoint tgtBkpt, 
+                      double time  ) const;
+                               
+    //! Compute morphed parameter values at the specified time, using
+    //! the source Breakpoint (assumed to correspond exactly to the
+    //! specified time) and the target Partial (whose parameters are
+    //! examined at the specified time).
+    //!
+    //! DEPRECATED do not use.
+    //!
+    //! \pre    the target Partial may not be a dummy Partial (no Breakpoints).
+    //!
+    //! \param  bp is the Breakpoint corresponding to a morph function
+    //!         value of 0.
+    //! \param  tgtPartial is the Partial corresponding to a morph function
+    //!         value of 1, evaluated at the specified time.
+    //! \param  time is the time corresponding to srcBkpt (used
+    //!         to evaluate the morphing functions and tgtPartial).
+    //! \return the morphed Breakpoint
+    Breakpoint 
+    morphSrcBreakpoint( const Breakpoint & bp, const Partial & tgtPartial, 
+                        double time ) const;
+
+    //! Compute morphed parameter values at the specified time, using
+    //! the target Breakpoint (assumed to correspond exactly to the
+    //! specified time) and the source Partial (whose parameters are
+    //! examined at the specified time).
+    //!
+    //! DEPRECATED do not use.
+    //!
+    //! \pre    the source Partial may not be a dummy Partial (no Breakpoints).
+    //!
+    //! \param  bp is the Breakpoint corresponding to a morph function
+    //!         value of 1.
+    //! \param  srcPartial is the Partial corresponding to a morph function
+    //!         value of 0, evaluated at the specified time.
+    //! \param  time is the time corresponding to srcBkpt (used
+    //!         to evaluate the morphing functions and tgtPartial).
+    //! \return the morphed Breakpoint
+    Breakpoint 
+    morphTgtBreakpoint( const Breakpoint & bp, const Partial & srcPartial, 
+                        double time ) const;
+
+    //! Compute morphed parameter values at the specified time, using
+    //! the source Breakpoint, assumed to correspond exactly to the
+    //! specified time, and assuming that there is no corresponding 
+    //! target Partial, so the source Breakpoint should be simply faded.
+    //!
+    //! \param  bp is the Breakpoint corresponding to a morph function
+    //!         value of 0.
+    //! \param  time is the time corresponding to bp (used
+    //!         to evaluate the morphing functions).
+    //! \return the faded Breakpoint
+    Breakpoint fadeSrcBreakpoint( Breakpoint bp, double time ) const;
+
+    //! Compute morphed parameter values at the specified time, using
+    //! the target Breakpoint, assumed to correspond exactly to the
+    //! specified time, and assuming that there is not corresponding 
+    //! source Partial, so the target Breakpoint should be simply faded.
+    //!
+    //! \param  bp is the Breakpoint corresponding to a morph function
+    //!         value of 1.
+    //! \param  time is the time corresponding to bp (used
+    //!         to evaluate the morphing functions).
+    //! \return the faded Breakpoint
+    Breakpoint fadeTgtBreakpoint( Breakpoint bp, double time ) const;
+    
+//  -- morphing function access/mutation --
+
+    //! Assign a new frequency morphing envelope to this Morpher.
+    void setFrequencyFunction( const Envelope & f );
+    
+    //! Assign a new amplitude morphing envelope to this Morpher.
+    void setAmplitudeFunction( const Envelope & f );
+    
+    //! Assign a new bandwidth morphing envelope to this Morpher.
+    void setBandwidthFunction( const Envelope & f );
+
+    //! Return a reference to this Morpher's frequency morphing envelope.
+    const Envelope & frequencyFunction( void ) const;
+    
+    //! Return a reference to this Morpher's amplitude morphing envelope.
+    const Envelope & amplitudeFunction( void ) const;
+    
+    //! Return a reference to this Morpher's bandwidth morphing envelope.
+    const Envelope & bandwidthFunction( void ) const;
+    
+    //! Return the shaping parameter for the amplitude moprhing
+    //! function (only used in log-amplitude morphing).
+	//!                                                           
+    //! DEPRECATED
+    double amplitudeShape( void ) const;
+    
+    //! Set the shaping parameter for the amplitude moprhing
+    //! function (only used in log-amplitude morphing).
+	//! Only relevant when _doLogAmpMorphing is true.
+	//! Don't use this for anything, just leave it 
+	//! at the default.
+	//!                                                           
+    //! DEPRECATED
+    void setAmplitudeShape( double x );
+    
+    //!	Enable (or disable) log-domain amplitude and bandwidth morphing.
+    //! Default is true.
+    void enableLogAmpMorphing( bool enable = true ) { _doLogAmpMorphing = enable; }
+    
+    //!	Enable (or disable) log-domain frequency morphing.
+    //! Default is false.
+    void enableLogFreqMorphing( bool enable = true )  { _doLogFreqMorphing = enable; }
+    
+    
+    //! Return the minimum time gap (secs) between two Breakpoints
+    //! in the morphed Partials. Morphing two
+    //! Partials can generate a third Partial having
+    //! Breakpoints arbitrarily close together in time,
+    //! and this makes morphs huge. Raising this 
+    //! threshold limits the Breakpoint density in
+    //! the morphed Partials. Default is 1/10 ms.
+    double minBreakpointGap( void ) const;
+
+    //! Set the minimum time gap (secs) between two Breakpoints
+    //! in the morphed Partials. Morphing two
+    //! Partials can generate a third Partial having
+    //! Breakpoints arbitrarily close together in time,
+    //! and this makes morphs huge. Raising this 
+    //! threshold limits the Breakpoint density in
+    //! the morphed Partials. Default is 1/10 ms.
+    //!
+    //! \param  x is the new minimum gap in seconds, it must be 
+    //!         positive
+    //! \throw  InvalidArgument if the specified gap is not positive
+    void setMinBreakpointGap( double x );
+
+
+//  -- reference Partial label access/mutation --
+    
+    //! Return the Partial to be used as a reference
+    //! Partial for the source sequence in a morph of two Partial
+    //! sequences. The reference partial is used to compute 
+    //! frequencies for very low-amplitude Partials whose frequency
+    //! estimates are not considered reliable. The reference Partial
+    //! is considered to have good frequency estimates throughout.
+    //! A default (empty) Partial indicates that no reference Partial
+    //! should be used for the source sequence.
+    const Partial & sourceReferencePartial( void ) const;
+    
+    //! Return the Partial to be used as a reference
+    //! Partial for the source sequence in a morph of two Partial
+    //! sequences. The reference partial is used to compute 
+    //! frequencies for very low-amplitude Partials whose frequency
+    //! estimates are not considered reliable. The reference Partial
+    //! is considered to have good frequency estimates throughout.
+    //! A default (empty) Partial indicates that no reference Partial
+    //! should be used for the source sequence.
+    Partial & sourceReferencePartial( void );
+    
+    //! Return the Partial to be used as a reference
+    //! Partial for the target sequence in a morph of two Partial
+    //! sequences. The reference partial is used to compute 
+    //! frequencies for very low-amplitude Partials whose frequency
+    //! estimates are not considered reliable. The reference Partial
+    //! is considered to have good frequency estimates throughout.
+    //! A default (empty) Partial indicates that no reference Partial
+    //! should be used for the target sequence.
+    const Partial & targetReferencePartial( void ) const;
+
+    //! Return the Partial to be used as a reference
+    //! Partial for the target sequence in a morph of two Partial
+    //! sequences. The reference partial is used to compute 
+    //! frequencies for very low-amplitude Partials whose frequency
+    //! estimates are not considered reliable. The reference Partial
+    //! is considered to have good frequency estimates throughout.
+    //! A default (empty) Partial indicates that no reference Partial
+    //! should be used for the target sequence.
+    Partial & targetReferencePartial( void );
+    
+    //! Specify the Partial to be used as a reference
+    //! Partial for the source sequence in a morph of two Partial
+    //! sequences. The reference partial is used to compute 
+    //! frequencies for very low-amplitude Partials whose frequency
+    //! estimates are not considered reliable. The reference Partial
+    //! is considered to have good frequency estimates throughout.
+    //! The specified Partial must be labeled with its harmonic number.
+    //! A default (empty) Partial indicates that no reference 
+    //! Partial should be used for the source sequence.
+    void setSourceReferencePartial( const Partial & p = Partial() );
+    
+    //! Specify the Partial to be used as a reference
+    //! Partial for the source sequence in a morph of two Partial
+    //! sequences. The reference partial is used to compute 
+    //! frequencies for very low-amplitude Partials whose frequency
+    //! estimates are not considered reliable. The reference Partial
+    //! is considered to have good frequency estimates throughout.
+    //! A default (empty) Partial indicates that no reference 
+    //! Partial should be used for the source sequence.
+    //!
+    //! \param  partials a sequence of Partials to search
+    //!         for the reference Partial
+    //! \param  refLabel the label of the Partial in partials
+    //!         that should be selected as the reference
+    void setSourceReferencePartial( const PartialList & partials, 
+                                    Partial::label_type refLabel );
+    
+    //! Specify the Partial to be used as a reference
+    //! Partial for the target sequence in a morph of two Partial
+    //! sequences. The reference partial is used to compute 
+    //! frequencies for very low-amplitude Partials whose frequency
+    //! estimates are not considered reliable. The reference Partial
+    //! is considered to have good frequency estimates throughout.
+    //! The specified Partial must be labeled with its harmonic number.
+    //! A default (empty) Partial indicates that no reference 
+    //! Partial should be used for the target sequence.
+    void setTargetReferencePartial( const Partial & p = Partial() );
+
+    //! Specify the Partial to be used as a reference
+    //! Partial for the target sequence in a morph of two Partial
+    //! sequences. The reference partial is used to compute 
+    //! frequencies for very low-amplitude Partials whose frequency
+    //! estimates are not considered reliable. The reference Partial
+    //! is considered to have good frequency estimates throughout.
+    //! A default (empty) Partial indicates that no reference 
+    //! Partial should be used for the target sequence.
+    //!
+    //! \param  partials a sequence of Partials to search
+    //!         for the reference Partial
+    //! \param  refLabel the label of the Partial in partials
+    //!         that should be selected as the reference
+    void setTargetReferencePartial( const PartialList & partials, 
+                                    Partial::label_type refLabel );
+    
+//  -- PartialList access --
+
+    //! Return a reference to this Morpher's list of morphed Partials.
+    PartialList & partials( void ); 
+
+    //! Return a const reference to this Morpher's list of morphed Partials.
+    const PartialList & partials( void ) const; 
+
+//  -- global morphing defaults and constants --
+
+    //! Amplitude threshold (dB) below which 
+    //! Partial frequencies are corrected using
+    //! the reference Partial frequency envelope
+    //! (if specified).
+    static const double DefaultFixThreshold;
+
+    //! Default amplitude shaping parameter, used in
+    //! interpolateLogAmplitudes to perform logarithmic 
+    //! amplitude morphs. 
+    //!
+    //! Compile Loris with LINEAR_AMP_MORPHS defined for
+    //! legacy-style linear amplitude morphs by default.
+    //!
+    //! Change from default using setAmplitudeShape.
+    static const double DefaultAmpShape;    
+
+    //! Default minimum time (sec) between Breakpoints in 
+    //! morphed Partials. 
+    //! Change from default using setMinBreakpointGap.
+    static const double DefaultBreakpointGap;
+
+private:
+    
+//  -- helper --
+
+    //  PartialCorrespondence represents a map from non-zero Partial 
+    //  labels to pairs of pointers to Partials that should be morphed 
+    //  into a single Partial that is assigned that label. 
+    //  MorphingPair is a pair of pointers to Partials that are
+    //  initialized to zero, and it is the element type for the
+    //  PartialCorrespondence map.
+    struct MorphingPair
+    {
+        Partial src;
+        Partial tgt;    
+    };
+    typedef std::map< Partial::label_type, MorphingPair > PartialCorrespondence;
+    
+    //! Helper function that performs the morph between corresponding pairs
+    //! of Partials identified in a PartialCorrespondence. Called by the
+    //! morph() implementation accepting two sequences of Partials.
+    void morph_aux( PartialCorrespondence & correspondence );
+    
+    //! Compute morphed parameter values at the specified time, using
+    //! the source Breakpoint (assumed to correspond exactly to the
+    //! specified time) and the target Partial (whose parameters are
+    //! examined at the specified time). Append the morphed Breakpoint
+    //! to newp only if the target should contribute to the morph at
+    //! the specified time.
+    //!
+    //! \pre    the target Partial may not be a dummy Partial (no Breakpoints).
+    //!
+    //! \param  srcBkpt is the Breakpoint corresponding to a morph function
+    //!         value of 0.
+    //! \param  tgtPartial is the Partial corresponding to a morph function
+    //!         value of 1, evaluated at the specified time.
+    //! \param  time is the time corresponding to srcBkpt (used
+    //!         to evaluate the morphing functions and tgtPartial).
+    //! \param  newp is the morphed Partial under construction, the morphed
+    //!         Breakpoint is added to this Partial.
+    //
+    void appendMorphedSrc( Breakpoint srcBkpt, const Partial & tgtPartial, 
+                           double time, Partial & newp  );
+                           
+    //! Compute morphed parameter values at the specified time, using
+    //! the target Breakpoint (assumed to correspond exactly to the
+    //! specified time) and the source Partial (whose parameters are
+    //! examined at the specified time). Append the morphed Breakpoint
+    //! to newp only if the target should contribute to the morph at
+    //! the specified time.
+    //!
+    //! \pre    the source Partial may not be a dummy Partial (no Breakpoints).
+    //!
+    //! \param  tgtBkpt is the Breakpoint corresponding to a morph function
+    //!         value of 1.
+    //! \param  srcPartial is the Partial corresponding to a morph function
+    //!         value of 0, evaluated at the specified time.
+    //! \param  time is the time corresponding to srcBkpt (used
+    //!         to evaluate the morphing functions and srcPartial).
+    //! \param  newp is the morphed Partial under construction, the morphed
+    //!         Breakpoint is added to this Partial.
+    //
+    void appendMorphedTgt( Breakpoint tgtBkpt, const Partial & srcPartial, 
+                           double time, Partial & newp  );
+                           
+                           
+	//!	Parameterinterpolation helpers.
+	Breakpoint 
+	interpolateParameters( const Breakpoint & srcBkpt, const Breakpoint & tgtBkpt,
+                           double fweight, double aweight, double bweight ) const;
+
+	double interpolateAmplitude( double srcAmp, double tgtAmp, double alpha ) const;
+	double interpolateBandwidth( double srcBw, double tgtBw, double alpha ) const;
+	double interpolateFrequency( double srcFreq, double tgtFreq, double alpha ) const;
+	double interpolatePhase( double srcphase, double tgtphase, double alpha ) const;
+	
+
+	//	Recompute phases for a morphed Partial, so that the synthesized phases 
+	//	match the source phases as closesly as possible at times when the 
+	//	frequency morphing function is equal to 0 or 1. 
+	void fixMorphedPhases( Partial & newp ) const;                           
+
+};  //  end of class Morpher
+
+}   //  end of namespace Loris
+
+#endif /* ndef INCLUDE_MORPHER_H */
diff --git a/src/loris/NoiseGenerator.C b/src/loris/NoiseGenerator.C
new file mode 100644
index 0000000..c1c7c0e
--- /dev/null
+++ b/src/loris/NoiseGenerator.C
@@ -0,0 +1,186 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * NoiseGenerator.C
+ *
+ * Implementation of a class representing a gaussian noise generator, filtered and 
+ * used as a modulator in bandwidth-enhanced synthesis.
+ *
+ * Kelly Fitz, 5 June 2003
+ * revised 11 October 2009
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "NoiseGenerator.h"
+#include <cmath>
+#include <numeric>
+
+
+//	begin namespace
+namespace Loris {
+
+// --- construction ---
+
+// ---------------------------------------------------------------------------
+//	(default) constructor
+// ---------------------------------------------------------------------------
+//!	Create a new noise generator with the (optionally) specified
+//! seed (default is 1.0).
+//!
+//!	\param initSeed is the initial seed for the random number generator
+//
+NoiseGenerator::NoiseGenerator( double initSeed ) :
+	m_useed( initSeed ),
+	m_gset( 0 ),
+	m_iset( false )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	seed
+// ---------------------------------------------------------------------------
+//!	Re-seed the random number generator.
+//!
+//!	\param newSeed is the new seed for the random number generator
+//
+void 
+NoiseGenerator::seed( double newSeed )
+{
+	m_useed = newSeed;
+}
+
+// --- random number generation ---
+
+// ---------------------------------------------------------------------------
+//	uniform random number generator
+// ---------------------------------------------------------------------------
+//	Taken from "Random Number Generators: Good Ones Are Hard To Find," 
+//	Stephen Park and Keith Miller, Communications of the ACM, October 1988,
+//	vol. 31, Number 10.
+//
+//	This version will work as long as floating point values are represented
+//	with at least a 46 bit mantissa. The IEEE standard 64 bit floating point
+//	format has a 53 bit mantissa.
+//
+//	The correctness of the implementation can be checked by confirming that
+// 	after 10000 iterations, the seed, initialized to 1, is 1043618065.
+//	I have confirmed this. 
+//
+//	I have also confirmed that it still works (is correct after 10000 
+//	iterations) when I replace the divides with multiplies by oneOverM.
+//
+//	Returns a uniformly distributed random double on the range [0., 1.).
+//
+//	-kel 7 Nov 1997.
+//
+//	trunc() is a problem. It's not in cmath, officially, though
+//	Metrowerks has it in there. SGI has it in math.h which is
+//	(erroneously!) included in g++ cmath, but trunc is not imported
+//	into std. For these two compilers, could just import std. But
+//	trnc doesn't seem to exist anywhere in Linux g++, so use std::modf().
+//	DON'T use integer conversion, because long int ins't as long 
+//	as double's mantissa!
+//
+static inline double trunc( double x ) { double y; std::modf(x, &y); return y; }
+
+inline double
+NoiseGenerator::uniform( void )
+{
+	static const double a = 16807.L;
+	static const double m = 2147483647.L;	// == LONG_MAX
+	static const double oneOverM = 1.L / m;
+
+	double temp = a * m_useed;
+	m_useed = temp - m * trunc( temp * oneOverM );
+	return m_useed * oneOverM;
+}
+
+// ---------------------------------------------------------------------------
+//	gaussian_normal
+// ---------------------------------------------------------------------------
+//	Approximate the normal distribution using the Box-Muller transformation.
+//	This is a better approximation and faster algorithm than the 12 u.v. sum.
+//
+//	This is slightly different than the thing I got off the web, I (have to)
+//	assume (for now) that I knew what I was doing when I altered it.
+//
+inline double 
+NoiseGenerator::gaussian_normal( void )
+{
+	//static int m_iset = 0;	//	boolean really, now member variables
+	//static double m_gset;
+
+	double r = 1., fac, v1, v2;
+	
+	if ( ! m_iset )
+	{
+		v1 = 2. * uniform() - 1.;
+		v2 = 2. * uniform() - 1.;
+		r = v1*v1 + v2*v2;
+		while( r >= 1. )
+		{
+			// v1 = 2. * uniform() - 1.;
+			v1 = v2;
+			v2 = 2. * uniform() - 1.;
+			r = v1*v1 + v2*v2;
+		}
+
+		fac = std::sqrt( -2. * std::log(r) / r );
+		m_gset = v1 * fac;
+		m_iset = true;
+		return v2 * fac;
+	}
+	else
+	{
+		m_iset = false;
+		return m_gset;
+	}
+}
+
+// --- sample generation ---
+
+// ---------------------------------------------------------------------------
+//	sample
+// ---------------------------------------------------------------------------
+//!	Generate and return a new sample of Gaussian noise having zero
+//! mean and unity standard deviation. Approximate the normal distribution 
+//!	using the Box-Muller transformation applied to a uniform random number 
+//!	generator taken from "Random Number Generators: Good Ones Are Hard To Find," 
+//!	Stephen Park and Keith Miller, Communications of the ACM, October 1988,
+//! vol. 31, Number 10.
+//
+double 
+NoiseGenerator::sample( void )
+{
+	double sample = gaussian_normal();
+	return sample;
+}
+
+
+}	//	end of namespace Loris
diff --git a/src/loris/NoiseGenerator.h b/src/loris/NoiseGenerator.h
new file mode 100644
index 0000000..95ddccd
--- /dev/null
+++ b/src/loris/NoiseGenerator.h
@@ -0,0 +1,99 @@
+#ifndef NOISEGENERATOR_H
+#define NOISEGENERATOR_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * NoiseGenerator.h
+ *
+ * Definition of a class representing a gaussian noise generator, filtered and 
+ * used as a modulator in bandwidth-enhanced synthesis.
+ *
+ * Kelly Fitz, 5 June 2003
+ * revised 11 October 2009
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	class NoiseGenerator
+//
+class NoiseGenerator
+{
+//	--- interface ---
+
+public:
+
+	//!	Create a new noise generator with the (optionally) specified
+	//! seed (default is 1.0).
+	//!
+	//!	\param initSeed is the initial seed for the random number generator
+	explicit NoiseGenerator( double initSeed = 1.0 );
+
+
+	//	copy and assign are free
+	
+	
+	//!	Re-seed the random number generator.
+	//!
+	//!	\param newSeed is the new seed for the random number generator
+	void seed( double newSeed );
+	
+	//	sample
+	//
+	//!	Generate and return a new sample of Gaussian noise having zero
+	//! mean and unity standard deviation. Approximate the normal distribution 
+	//!	using the Box-Muller transformation applied to a uniform random number 
+	//!	generator taken from "Random Number Generators: Good Ones Are Hard To Find," 
+	//!	Stephen Park and Keith Miller, Communications of the ACM, October 1988,
+	//! vol. 31, Number 10.
+	double sample( void );
+	
+	//! Function call operator, same as calling sample().
+	//!	
+	//!	\sa sample
+	double operator() ( void ) 	{ return sample(); }
+	
+
+//	--- implementation ---
+private:
+
+	//	random number generation helpers
+	inline double uniform( void );
+	inline double gaussian_normal( void );
+
+
+	// random number generator state variables
+	double m_useed;
+	double m_gset;
+	bool m_iset;
+	
+};
+
+
+}	//	end of namespace Loris
+
+#endif	/* ndef NOISEGENERATOR_H */
diff --git a/src/loris/Notifier.C b/src/loris/Notifier.C
new file mode 100644
index 0000000..8c05a0d
--- /dev/null
+++ b/src/loris/Notifier.C
@@ -0,0 +1,207 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Notifier.C
+ *
+ * Definitions of the ostreams used for notification throughout the Loris 
+ * library (notifier and debugger), and the c-linkable functions for assigning
+ * notification handlers (of type NotificationHandler, see Notifier.h)
+ * to each.
+ * 
+ * These ostreams use a streambuf derivative, NotifierBuf, to buffer characters
+ * in a std::string, and post them (via a handler) when a newline is received.
+ * NotifierBuf is defined and implemented below.
+ *
+ * Kelly Fitz, 28 Feb 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "Notifier.h"
+#include <string>
+#include <cstdio>
+
+#if defined(__GNUC__)
+	//	other compilers have this problem?
+	typedef int int_type;
+#endif
+
+using namespace std;
+
+//	begin namespace
+namespace Loris {
+
+
+// ---------------------------------------------------------------------------
+//	defaultNotifierhandler
+// ---------------------------------------------------------------------------
+//	By default, notifications go to stdout (no need to bring in iostreams 
+//	for this. 
+//
+//	Is printf different from fprint to stdout? On the mac, using CW5, and
+//	linking into a Python module (main() written in c), only printf works.
+//
+static void defaultNotifierhandler( const char * s )
+{
+	//cout << s << endl;
+	//fprintf( stdout, "%s\n", s );
+	printf( "%s\n", s );
+}
+
+// ---------------------------------------------------------------------------
+//	class NotifierBuf
+//
+//	streambuf derivative that buffers output in a std::string 
+//	and posts it to a handler (_post) when a newline is received. 
+//
+class NotifierBuf : public streambuf
+{
+//	-- public interface --
+public:
+//	construction:
+	NotifierBuf( const std::string & s = "" ) : 
+		_str(s), _post( defaultNotifierhandler ) 
+		//	confirm construction:
+		// { printf( "created a NotifierBuf.\n" ); }
+		{} 
+		
+//	virtual destructor so NotifierBuf can be subclassed:
+//	(use compiler generated, streambuf has virtual destructor)
+	//virtual ~NotifierBuf( void );	
+	
+//	handler manipulation:
+	NotificationHandler setHandler( NotificationHandler h ) throw()
+	{
+		NotificationHandler prev = _post;
+		_post = h;
+		return prev;
+	}
+	
+protected:
+	//	called every time a character is written:
+	virtual int_type overflow( int_type c ) 
+	{
+		if ( c == '\n' ) {
+			_post( _str.c_str() );
+			_str = "";
+		}
+		else if ( c != EOF ) {
+			char ch(c);
+			_str += ch;
+			//_str += static_cast<char>(c); ???
+		}
+		return c;
+	}
+	
+private:
+	//	buffer characters in a string:
+	std::string _str;
+	
+	//	handler:
+	NotificationHandler _post;
+	
+};	//	end of class NotifierBuf
+
+// ---------------------------------------------------------------------------
+//	stream instances
+// ---------------------------------------------------------------------------
+//	ostreams used throughout Loris for notification.
+//
+//	Instead of making these globals by declaring them at file scope, 
+//	make them static to these initializer functions, to make sure (?)
+//	that their constructors get called.
+//
+static NotifierBuf & notifierBuffer(void)
+{
+	static NotifierBuf buf;
+	return buf;
+}
+
+std::ostream & getNotifierStream(void)
+{
+	static ostream os(&notifierBuffer());
+	return os;
+}
+
+
+#if defined( Debug_Loris )
+	static NotifierBuf & debuggerBuffer(void)
+	{
+		static NotifierBuf buf;
+		return buf;
+	}
+#else
+	//	to do nothing at all, need a dummy streambuf:
+	struct Dummybuf : public streambuf
+	{
+	};
+	static Dummybuf & debuggerBuffer( void )
+	{
+		static Dummybuf buf;
+		return buf;
+	}
+#endif
+
+std::ostream & getDebuggerStream(void)
+{
+	static ostream os(&debuggerBuffer());
+	return os;
+}
+
+// ---------------------------------------------------------------------------
+//	setNotifierHandler
+// ---------------------------------------------------------------------------
+//	Specify a new handler for notifications.
+//	Does not throw.
+//
+extern "C" NotificationHandler 
+setNotifierHandler( NotificationHandler fn )
+{
+	return notifierBuffer().setHandler( fn );
+}
+
+// ---------------------------------------------------------------------------
+//	setDebuggerHandler
+// ---------------------------------------------------------------------------
+//	Specify a new handler for debugging notifications, only effective when
+//	Debug_Loris is defined, otherwise debugger does nothing.
+//	Does not throw.
+//
+extern "C" NotificationHandler 
+setDebuggerHandler( NotificationHandler fn )
+{
+#if defined( Debug_Loris )
+	return debuggerBuffer().setHandler( fn );
+#else
+	fn = fn;
+	return NULL;
+#endif
+}
+
+}	//	end of namespace Loris
+
diff --git a/src/loris/Notifier.h b/src/loris/Notifier.h
new file mode 100644
index 0000000..c0269f2
--- /dev/null
+++ b/src/loris/Notifier.h
@@ -0,0 +1,126 @@
+#ifndef INCLUDE_NOTIFIER_H
+#define INCLUDE_NOTIFIER_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Notifier.h
+ *
+ *	A pair of dedicated streams, notifier and debugger, are used for
+ *	notification throughout the Loris class library. These streams are used
+ *	like cout or cerr, but they buffer their contents until a newline is
+ *	receieved. Then they post their entire contents to a notification
+ *	handler. The default handler just prints to stderr, but other handlers
+ *	may be dynamically specified using setNotifierHandler() and
+ *	setDebuggerHandler().
+ *	
+ *	debugger is enabled only when compiled with the preprocessor macro
+ *	Debug_Loris defined. It cannot be enabled using setDebuggerHandler() if
+ *	Debug_Loris is undefined.When Debug_Loris is not defined, characters
+ *	streamed onto debugger are never posted nor are they otherwise
+ *	accessible.
+ *	
+ *	Notifier.h may be included in c files. The stream declarations are
+ *	omitted, but the notification handler routines are accessible.
+ *	
+ *
+ * Kelly Fitz, 28 Feb 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+
+/*
+ *	stream declaration, C++ only:
+ */
+#ifdef __cplusplus
+
+#include <iostream>
+
+//	begin namespace
+namespace Loris {
+
+std::ostream & getNotifierStream(void);
+std::ostream & getDebuggerStream(void);
+
+//	declare streams:
+static std::ostream & notifier = getNotifierStream();
+/*	This stream is used throughout Loris (and may be used by clients)
+	to provide user feedback. Characters streamed onto notifier are
+	buffered until a newline is received, and then the entire contents
+	of the stream are flushed to the current notification handler (stderr,
+	by default).
+ */
+
+static std::ostream & debugger = getDebuggerStream();
+/*	This stream is used throughout Loris (and may be used by clients)
+	to provide debugging information. Characters streamed onto debugger are
+	buffered until a newline is received, and then the entire contents
+	of the stream are flushed to the current debugger handler (stderr,
+	by default).
+	
+	debugger is enabled only when compiled with the preprocessor macro
+	Debug_Loris defined. It cannot be enabled using setDebuggerHandler()
+	if Debug_Loris is undefined. When Debug_Loris is not defined,
+	characters streamed onto debugger are never posted nor are they
+	otherwise accessible.
+ */
+ 
+//	for convenience, import endl and ends from std into Loris:
+using std::endl;
+using std::ends;
+
+}	//	end of namespace Loris
+
+#endif	/* def __cplusplus */
+
+/*
+ *	handler assignment, c linkable:
+ */
+
+#ifdef __cplusplus
+//  begin namespace
+namespace Loris {
+extern "C" {
+#endif	//	def __cplusplus
+
+//	These functions do not throw exceptions.
+typedef void(*NotificationHandler)(const char * s);
+NotificationHandler setNotifierHandler( NotificationHandler fn );
+/*	Specify a new handling procedure for posting user feedback, and return
+	the current handler. 
+ */
+ 
+NotificationHandler setDebuggerHandler( NotificationHandler fn );
+/*	Specify a new handling procedure for posting debugging information, and return
+	the current handler. This has no effect unless compiled with the Debug_Loris
+	preprocessor macro defined.
+ */
+ 
+#ifdef __cplusplus
+}	//	end extern "C"
+}	//	end of namespace Loris
+#endif	// def __cplusplus
+
+
+#endif /* ndef INCLUDE_NOTIFIER_H */
diff --git a/src/loris/Oscillator.C b/src/loris/Oscillator.C
new file mode 100644
index 0000000..1ffc5c5
--- /dev/null
+++ b/src/loris/Oscillator.C
@@ -0,0 +1,305 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Oscillator.C
+ *
+ * Implementation of class Loris::Oscillator, a Bandwidth-Enhanced Oscillator.
+ *
+ * Kelly Fitz, 31 Aug 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+ 
+#if HAVE_CONFIG_H
+    #include "config.h"
+#endif
+
+#include "Oscillator.h"
+
+#include "Filter.h"
+#include "Partial.h"
+#include "Notifier.h"
+
+#include <cmath>
+#include <vector>
+
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+    const double Pi = M_PI;
+#else
+    const double Pi = 3.14159265358979324;
+#endif
+const double TwoPi = 2*Pi;
+
+//  begin namespace
+namespace Loris {
+
+
+// ---------------------------------------------------------------------------
+//  Oscillator construction
+// ---------------------------------------------------------------------------
+//  Initialize stochastic modulators and state variables.
+//
+Oscillator::Oscillator( void ) :
+    m_modulator( 1.0 /* seed */ ),
+    m_filter( prototype_filter() ),
+    m_instfrequency( 0 ),
+    m_instamplitude( 0 ),
+    m_instbandwidth( 0 ),
+    m_determphase( 0 )
+{
+}
+
+// ---------------------------------------------------------------------------
+//  resetEnvelopes
+// ---------------------------------------------------------------------------
+//  Reset the instantaneous envelope parameters 
+//  (frequency, amplitude, bandwidth, and phase).
+//  The sample rate is needed to convert the 
+//  Breakpoint frequency (Hz) to radians per sample.
+//
+void 
+Oscillator::resetEnvelopes( const Breakpoint & bp, double srate )
+{
+    //  Remember that the oscillator only knows about 
+    //  radian frequency! Convert!
+    m_instfrequency = bp.frequency() * TwoPi / srate;
+    m_instamplitude = bp.amplitude();
+    m_instbandwidth = bp.bandwidth();
+    m_determphase = bp.phase();
+    
+    //  clamp bandwidth:
+    if ( m_instbandwidth > 1. )
+    {
+        debugger << "clamping bandwidth at 1." << endl;
+        m_instbandwidth = 1.;
+    }
+    else if ( m_instbandwidth < 0. )
+    { 
+        debugger << "clamping bandwidth at 0." << endl;
+        m_instbandwidth = 0.;
+    }
+
+    //  don't alias:
+    if ( m_instfrequency > Pi )
+    { 
+        debugger << "fading out aliasing Partial" << endl;
+        m_instamplitude = 0.;
+    }
+    
+    //  Reset the fitler state too.
+    m_filter.clear();
+    
+}
+
+// ---------------------------------------------------------------------------
+//  m2pi
+// ---------------------------------------------------------------------------
+//  O'Donnell's phase wrapping function.
+//
+static inline double m2pi( double x )
+{
+    using namespace std; // floor should be in std
+    #define ROUND(x) (floor(.5 + (x)))
+    return x + ( TwoPi * ROUND(-x/TwoPi) );
+}
+
+// ---------------------------------------------------------------------------
+//  setPhase
+// ---------------------------------------------------------------------------
+//  Reset the phase of the Oscillator to the specified
+//  value, and clear the accumulated phase modulation. (?)
+//  Or not.
+//  This is done when the amplitude of a Partial goes to 
+//  zero, so that onsets are preserved in distilled
+//  and collated Partials.
+//
+void 
+Oscillator::setPhase( double ph )
+{
+    m_determphase = m2pi(ph);
+}
+
+// ---------------------------------------------------------------------------
+//  oscillate
+// ---------------------------------------------------------------------------
+//  Accumulate bandwidth-enhanced sinusoidal samples modulating the 
+//  oscillator state from its current values of radian frequency,
+//  amplitude, and bandwidth to the specified target values, into
+//  the specified half-open range of doubles.
+//
+//  The caller must ensure that the range is valid. Target parameters
+//  are bounds-checked. 
+//
+void
+Oscillator::oscillate( double * begin, double * end,
+                       const Breakpoint & bp, double srate )
+{
+    double targetFreq = bp.frequency() * TwoPi / srate;     //  radians per sample
+    double targetAmp = bp.amplitude(); 
+    double targetBw = bp.bandwidth();
+    
+    //  clamp bandwidth:
+    if ( targetBw > 1. )
+    {
+        debugger << "clamping bandwidth at 1." << endl;
+        targetBw = 1.;
+    }
+    else if ( targetBw < 0. )
+    { 
+        debugger << "clamping bandwidth at 0." << endl;
+        targetBw = 0.;
+    }
+        
+    //  don't alias:
+    if ( targetFreq > Pi )  //  radian Nyquist rate
+    {
+        debugger << "fading out Partial above Nyquist rate" << endl;
+        targetAmp = 0.;
+    }
+
+    //  compute trajectories:
+    const double dTime = 1. / (end - begin);
+    const double dFreqOver2 = 0.5 * (targetFreq - m_instfrequency) * dTime;
+    	//	split frequency update in two steps, update phase using average
+    	//	frequency, after adding only half the frequency step
+    	
+    const double dAmp = (targetAmp - m_instamplitude)  * dTime;
+    const double dBw = (targetBw - m_instbandwidth)  * dTime;
+
+    //  Use temporary local variables for speed.
+    //  Probably not worth it when I am computing square roots 
+    //  and cosines...
+    double ph = m_determphase;
+    double f = m_instfrequency;
+    double a = m_instamplitude;
+    double bw = m_instbandwidth;
+    
+    //	Also use a more efficient sample loop when the bandwidth is zero.
+    if ( 0 < bw || 0 < dBw )
+    {
+		double am, nz;
+		for ( double * putItHere = begin; putItHere != end; ++putItHere )
+		{
+			//  use math functions in namespace std:
+			using namespace std;
+	
+			//  compute amplitude modulation due to bandwidth:
+			//
+			//  This will give the right amplitude modulation when scaled
+			//  by the Partial amplitude:
+			//
+			//  carrier amp: sqrt( 1. - bandwidth ) * amp
+			//  modulation index: sqrt( 2. * bandwidth ) * amp
+			//
+			nz = m_filter.apply( m_modulator.sample() );
+			am = sqrt( 1. - bw ) + ( nz * sqrt( 2. * bw ) );  
+					
+			//  compute a sample and add it into the buffer:
+			*putItHere += am * a * cos( ph );
+				
+			//  update the instantaneous oscillator state:
+			f += dFreqOver2;
+			ph += f;   //  frequency is radians per sample
+			f += dFreqOver2;
+			a += dAmp;
+			bw += dBw;
+			if (bw < 0.)
+			{
+				bw = 0.;
+			}				
+		}   // end of sample computation loop
+	}
+	else
+	{
+		for ( double * putItHere = begin; putItHere != end; ++putItHere )
+		{
+			//  use math functions in namespace std:
+			using namespace std;
+	
+			//	no modulation when there is no bandwidth
+			
+			//  compute a sample and add it into the buffer:
+			*putItHere += a * cos( ph );
+				
+			//  update the instantaneous oscillator state:
+			f += dFreqOver2;
+			ph += f;   //  frequency is radians per sample
+			f += dFreqOver2;
+			a += dAmp;
+		}   // end of sample computation loop
+	
+	}
+	
+	
+    //	copy out of the local variables?
+    //	no need because we are assigning to the target
+    //	values below:
+    /*
+    m_instfrequency = f;
+    m_instamplitude = a;
+    m_instbandwidth = bw;
+    */
+    
+    //  wrap phase to prevent eventual loss of precision at
+    //  high oscillation frequencies:
+    //  (Doesn't really matter much exactly how we wrap it, 
+    //  as long as it brings the phase nearer to zero.)
+    m_determphase = m2pi( ph );
+    
+    //  set the state variables to their target values,
+    //  just in case they didn't arrive exactly (overshooting
+    //  amplitude or, especially, bandwidth, could be bad, and
+    //  it does happen):
+    m_instfrequency = targetFreq;
+    m_instamplitude = targetAmp;
+    m_instbandwidth = targetBw;
+}
+
+// ---------------------------------------------------------------------------
+//  protoype filter (static member)
+// ---------------------------------------------------------------------------
+//  Static local function for obtaining a prototype Filter
+//  to use in Oscillator construction. Eventually, allow
+//  external (client) specification of the Filter prototype.
+//
+const Filter & 
+Oscillator::prototype_filter( void )
+{
+    //  Chebychev order 3, cutoff 500, ripple -1.
+    //
+    //  Coefficients obtained from http://www.cs.york.ac.uk/~fisher/mkfilter/
+    //  Digital filter designed by mkfilter/mkshape/gencode   A.J. Fisher
+    //
+    static const double Gain = 4.663939184e+04;
+    static const double ExtraScaling = 6.;
+    static const double MaCoefs[] = { 1., 3., 3., 1. }; 
+    static const double ArCoefs[] = { 1., -2.9258684252, 2.8580608586, -0.9320209046 };
+
+    static const Filter proto( MaCoefs, MaCoefs + 4, ArCoefs, ArCoefs + 4, ExtraScaling/Gain );
+    return proto;
+}
+
+
+
+}   //  end of namespace Loris
diff --git a/src/loris/Oscillator.h b/src/loris/Oscillator.h
new file mode 100644
index 0000000..79631f4
--- /dev/null
+++ b/src/loris/Oscillator.h
@@ -0,0 +1,138 @@
+#ifndef INCLUDE_OSCILLATOR_H
+#define INCLUDE_OSCILLATOR_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Oscillator.h
+ *
+ * Definition of class Loris::Oscillator, a Bandwidth-Enhanced Oscillator.
+ *
+ * Kelly Fitz, 31 Aug 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "NoiseGenerator.h"
+#include "Filter.h"
+
+//  begin namespace
+namespace Loris {
+
+class Breakpoint;
+
+// ---------------------------------------------------------------------------
+//  class Oscillator
+//
+//! Class Oscillator represents the state of a single bandwidth-enhanced
+//! sinusoidal oscillator used for synthesizing sounds from Reassigned
+//! Bandwidth-Enhanced analysis data. Oscillator encapsulates the oscillator
+//! state, including the instantaneous radian frequency (radians per
+//! sample), amplitude, bandwidth coefficient, and phase, and a 
+//! bandlimited stochastic modulator. 
+//!
+//! Class Synthesizer uses an instance of Oscillator to synthesize
+//! bandwidth-enhanced Partials.
+//
+class Oscillator
+{
+//  --- implementation ---
+
+    NoiseGenerator m_modulator;     //! stochastic modulator
+    Filter m_filter;                //! filter applied to the noise generator
+    
+    //  instantaneous oscillator state:
+    double m_instfrequency;         //! radians per sample
+    double m_instamplitude;         //! absolute amplitude
+    double m_instbandwidth;         //! bandwidth coefficient (noise energy / total energy)
+    
+    //  accumulating phase state:
+    double m_determphase;       //! deterministic phase in radians
+
+//  --- interface ---
+public:
+//  --- construction ---
+
+    //! Construct a new Oscillator with all state parameters initialized to 0.
+    Oscillator( void );
+     
+    //  Copy, assignment, and destruction are free.
+    //
+    //  Copied and assigned Oscillators have the duplicate state
+    //  variables and the filters have the same coefficients,
+    //  but the state of the filter delay lines is not copied.
+
+// --- oscillation ---
+     
+    //! Reset the instantaneous envelope parameters 
+    //! (frequency, amplitude, bandwidth, and phase).
+    //! The sample rate is needed to convert the 
+    //! Breakpoint frequency (Hz) to radians per sample.
+    void resetEnvelopes( const Breakpoint & bp, double srate );
+      
+    //! Reset the phase of the Oscillator to the specified
+    //! value. This is done when the amplitude of a Partial 
+    //! goes to zero, so that onsets are preserved in distilled
+    //! and collated Partials.
+    void setPhase( double ph );
+
+    //! Accumulate bandwidth-enhanced sinusoidal samples modulating the
+    //! oscillator state from its current values of radian frequency, amplitude,
+    //! and bandwidth to the specified target values. Accumulate samples into
+    //! the half-open (STL-style) range of doubles, starting at begin, and
+    //! ending before end (no sample is accumulated at end). The caller must
+    //! insure that the indices are valid. Target frequency and bandwidth are
+    //! checked to prevent aliasing and bogus bandwidth enhancement.
+    void oscillate( double * begin, double * end,
+                    const Breakpoint & bp, double srate );
+
+// --- accessors ---
+
+    //! Return the instantaneous amplitde of the Oscillator.
+    double amplitude( void ) const { return m_instamplitude; }
+    
+    //! Return the instantaneous bandwidth of the Oscillator.
+    double bandwidth( void ) const { return m_instbandwidth; }
+    
+    //! Return the instantaneous phase of the Oscillator.
+    double phase( void ) const { return m_determphase; }
+    
+    //! Return the instantaneous radian frequency of the Oscillator.
+    double radianFreq( void ) const { return m_instfrequency; }
+    
+    //! Return access to the Filter used by this oscillator to 
+    //! implement bandwidth-enhanced sinusoidal synthesis.
+    Filter & filter( void ) { return m_filter; }
+    
+// --- static members ---
+
+    //! Static local function for obtaining a prototype Filter
+    //! to use in Oscillator construction. Eventually, allow
+    //! external (client) specification of the Filter prototype.
+    static const Filter & prototype_filter( void );
+     
+};  //  end of class Oscillator
+
+}   //  end of namespace Loris
+
+#endif /* ndef INCLUDE_OSCILLATOR_H */
diff --git a/src/loris/Partial.C b/src/loris/Partial.C
new file mode 100644
index 0000000..b6ea15c
--- /dev/null
+++ b/src/loris/Partial.C
@@ -0,0 +1,860 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Partial.C
+ *
+ * Implementation of class Loris::Partial.
+ *
+ * Kelly Fitz, 16 Aug 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "Partial.h"
+#include "Breakpoint.h"
+#include "LorisExceptions.h"
+#include "Notifier.h"
+
+#include <algorithm>
+#include <cmath>
+
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+	const double Pi = M_PI;
+#else
+	const double Pi = 3.14159265358979324;
+#endif
+
+//	begin namespace
+namespace Loris {
+
+//long Partial::DebugCounter = 0L;
+
+//	comparitor for elements in Partial::container_type
+typedef Partial::container_type::value_type Partial_value_type;
+static 
+bool order_by_time( const Partial_value_type & x, const Partial_value_type & y )
+{
+	//	Partial_value_type is a (time,Breakpoint) pair
+	return x.first < y.first;
+}
+
+//	--- concering the type of Partial::container_type
+//
+//	On the surface, it would seem that a vector of (time,Breakpoint)
+//	pairs would be a more efficient container for the Partial
+//	parameter envelope points, and the changes required to implement
+//	Partial using vector instead of map are minimal and simple. 
+//
+//	However, the crucial factor in that change is the expiration of
+//	Partial::iterators. With map, iterators remain valid after
+//	insertions and removals, but with vector they do not. So it 
+//	is easy to change the container type, but it is a much harder
+//	project to find all the places in Loris that rely on iterators
+//	that remain valid after insertions and removals.
+#undef USE_VECTOR
+
+
+// -- construction --
+
+// ---------------------------------------------------------------------------
+//	Partial constructor
+// ---------------------------------------------------------------------------
+//!	Retun a new empty (no Breakpoints) unlabeled Partial.
+//
+Partial::Partial( void ) :
+	_label( 0 )
+{
+//	++DebugCounter;
+}	
+
+// ---------------------------------------------------------------------------
+//	Partial initialized constructor
+// ---------------------------------------------------------------------------
+//!	Retun a new Partial from a half-open (const) iterator range 
+//!	of time, Breakpoint pairs.
+//
+Partial::Partial( const_iterator beg, const_iterator end ) :
+	_breakpoints( beg._iter, end._iter ),
+	_label( 0 )
+{
+//	++DebugCounter;
+}	
+
+// ---------------------------------------------------------------------------
+//	Partial copy constructor
+// ---------------------------------------------------------------------------
+//!	Return a new Partial that is an exact copy (has an identical set
+//!	of Breakpoints, at identical times, and the same label) of another 
+//!	Partial.
+//
+Partial::Partial( const Partial & other ) :
+	_breakpoints( other._breakpoints ),
+	_label( other._label )
+{
+//	++DebugCounter;
+}
+
+// ---------------------------------------------------------------------------
+//	Partial destructor
+// ---------------------------------------------------------------------------
+//!	Destroy this Partial.
+//
+Partial::~Partial( void )
+{
+//	--DebugCounter;
+}	
+
+// ---------------------------------------------------------------------------
+//	operator=
+// ---------------------------------------------------------------------------
+//!	Make this Partial an exact copy (has an identical set of 
+//!	Breakpoints, at identical times, and the same label) of another 
+//!	Partial.
+//
+Partial & 
+Partial::operator=( const Partial & rhs )
+{
+	if ( this != &rhs )
+	{
+		_breakpoints = rhs._breakpoints;
+		_label = rhs._label;
+	}
+	return *this;
+}
+
+// -- container-dependent implementation --
+
+// ---------------------------------------------------------------------------
+//	begin
+// ---------------------------------------------------------------------------
+//!	Return a const iterator refering to the position of the first
+//!	Breakpoint in this Partial's envelope.
+//		
+Partial::const_iterator Partial::begin( void ) const 
+{ 
+	return _breakpoints.begin(); 
+}
+
+//!	Return an iterator refering to the position of the first
+//!	Breakpoint in this Partial's envelope.
+//		
+Partial::iterator Partial::begin( void ) 
+{ 
+	return _breakpoints.begin(); 
+}
+
+// ---------------------------------------------------------------------------
+//	end
+// ---------------------------------------------------------------------------
+//!	Return a const iterator refering to the position past the last
+//!	Breakpoint in this Partial's envelope. The iterator returned by
+//!	end() (like the iterator returned by the end() member of any STL
+//!	container) does not refer to a valid Breakpoint. 	
+//
+Partial::const_iterator 
+Partial::end( void ) const 
+{ 
+	return _breakpoints.end(); 
+}
+
+//!	Return an iterator refering to the position past the last
+//!	Breakpoint in this Partial's envelope. The iterator returned by
+//!	end() (like the iterator returned by the end() member of any STL
+//!	container) does not refer to a valid Breakpoint. 	
+//
+Partial::iterator 
+Partial::end( void ) 
+{ 
+	return _breakpoints.end(); 
+}
+
+// ---------------------------------------------------------------------------
+//	erase
+// ---------------------------------------------------------------------------
+//!	Breakpoint removal: erase the Breakpoints in the specified range,
+//!	and return an iterator referring to the position after the,
+//!	erased range.
+//
+Partial::iterator 
+Partial::erase( Partial::iterator beg, Partial::iterator end )
+{
+	_breakpoints.erase( beg._iter, end._iter );
+	return end;
+}
+
+// ---------------------------------------------------------------------------
+//	findAfter
+// ---------------------------------------------------------------------------
+//!	Return a const iterator refering to the insertion position for a
+//!	Breakpoint at the specified time (that is, the position of the first
+//!	Breakpoint at a time not earlier than the specified time).
+//	
+Partial::const_iterator 
+Partial::findAfter( double time ) const
+{
+#if defined(USE_VECTOR) 
+	//	see note above
+	Partial_value_type dummy( time, Breakpoint() );
+	return std::upper_bound( _breakpoints.begin(), _breakpoints.end(), dummy, order_by_time );
+#else
+	return _breakpoints.lower_bound( time );
+#endif
+}
+
+//!	Return an iterator refering to the insertion position for a
+//!	Breakpoint at the specified time (that is, the position of the first
+//!	Breakpoint at a time later than the specified time).
+//	
+Partial::iterator 
+Partial::findAfter( double time ) 
+{
+#if defined(USE_VECTOR) 
+	//	see note above
+	Partial_value_type dummy( time, Breakpoint() );
+	return std::upper_bound( _breakpoints.begin(), _breakpoints.end(), dummy, order_by_time );
+#else
+	return _breakpoints.lower_bound( time );
+#endif
+}
+
+// ---------------------------------------------------------------------------
+//	insert
+// ---------------------------------------------------------------------------
+//!	Breakpoint insertion: insert a copy of the specified Breakpoint in the
+//!	parameter envelope at time (seconds), and return an iterator
+//!	refering to the position of the inserted Breakpoint.
+//
+Partial::iterator 
+Partial::insert( double time, const Breakpoint & bp )
+{
+#if defined(USE_VECTOR) 
+	//	see note above
+	//	find the position at which to insert the new Breakpoint:
+	Partial_value_type dummy( time, Breakpoint() );
+	Partial::container_type::iterator insertHere = 
+		std::lower_bound( _breakpoints.begin(), _breakpoints.end(), dummy, order_by_time );
+		
+	//	if the time at insertHere is equal to the insertion time,
+	//	simply replace the Breakpoint, otherwise insert:
+	if ( insertHere->first == time )
+	{
+		insertHere->second = bp;
+	}
+	else
+	{
+		insertHere = _breakpoints.insert( insertHere, Partial_value_type(time, bp) );
+	}
+	return insertHere;
+#else
+    /*
+    //  this allows Breakpoints to be inserted arbitrarily
+    //  close together, which is no good, can cause trouble later:
+    
+	std::pair< container_type::iterator, bool > result = 
+		_breakpoints.insert( container_type::value_type(time, bp) );
+	if ( ! result.second )
+    {
+		result.first->second = bp;
+    }
+	return result.first;
+    */
+    
+    //  do not insert a Breakpoint closer than 1ns away
+    //  from the nearest existing Breakpoint:
+    static const double MinTimeDif = 1.0E-9; // 1 ns
+    
+    //  find the insertion point for this time
+    container_type::iterator pos = _breakpoints.lower_bound( time );
+    
+    //  the time of pos is either equal to or greater
+    //  than the insertion time, if this is too close, 
+    //  remove the Breakpoint at pos:
+    if ( _breakpoints.end() != pos && MinTimeDif > pos->first - time )
+    {
+        _breakpoints.erase( pos++ );
+    }
+    //  otherwise, if the preceding position is too clase, 
+    //  remove the Breakpoint at that position
+    else if ( _breakpoints.begin() != pos && MinTimeDif > time - (--pos)->first )
+    {
+        _breakpoints.erase( pos++ );
+    }
+
+    //  now pos is at most one position away from the insertion point
+    //  so insertion can be performed in constant time, and the new
+    //  Breakpoint is at least 1ns away from any other Breakpoint:
+    pos = _breakpoints.insert( pos, container_type::value_type(time, bp) );
+
+    Assert( pos->first == time );
+
+	return pos;
+
+#endif
+}
+
+// ---------------------------------------------------------------------------
+//	numBreakpoints
+// ---------------------------------------------------------------------------
+//!	Same as size(). Return the number of Breakpoints in this Partial.
+//
+Partial::size_type 
+Partial::numBreakpoints( void ) const 
+{ 	
+	return _breakpoints.size(); 
+}
+// ---------------------------------------------------------------------------
+//	size
+// ---------------------------------------------------------------------------
+//!	Return the number of Breakpoints in this Partial.
+//
+Partial::size_type 
+Partial::size( void ) const 
+{ 	
+	return _breakpoints.size(); 
+}
+
+// ---------------------------------------------------------------------------
+//	label
+// ---------------------------------------------------------------------------
+//!	Return the 32-bit label for this Partial as an integer.
+//
+Partial::label_type 
+Partial::label( void ) const 
+{ 	
+	return _label; 
+}
+
+// ---------------------------------------------------------------------------
+//	first
+// ---------------------------------------------------------------------------
+//!	Return a reference to the first Breakpoint in the Partial's
+//!	envelope. Raises InvalidPartial exception if there are no 
+//!	Breakpoints.
+//
+Breakpoint & 
+Partial::first( void )
+{
+	if ( size() == 0 )
+	{
+		Throw( InvalidPartial, "Tried find first Breakpoint in a Partial with no Breakpoints." );
+	}
+#if defined(USE_VECTOR) 
+	//	see note above
+	return _breakpoints.front().second;
+#else
+	return begin().breakpoint();
+#endif
+}
+
+// ---------------------------------------------------------------------------
+//	first
+// ---------------------------------------------------------------------------
+//!	Return a const reference to the first Breakpoint in the Partial's
+//!	envelope. Raises InvalidPartial exception if there are no 
+//!	Breakpoints.
+//
+const Breakpoint & 
+Partial::first( void ) const
+{
+	if ( size() == 0 )
+	{
+		Throw( InvalidPartial, "Tried find first Breakpoint in a Partial with no Breakpoints." );
+	}
+#if defined(USE_VECTOR) 
+	//	see note above
+	return _breakpoints.front().second;
+#else
+	return begin().breakpoint();
+#endif
+}
+
+// ---------------------------------------------------------------------------
+//	last
+// ---------------------------------------------------------------------------
+//!	Return a reference to the last Breakpoint in the Partial's
+//!	envelope. Raises InvalidPartial exception if there are no 
+//!	Breakpoints.
+//
+Breakpoint & 
+Partial::last( void )
+{
+	if ( size() == 0 )
+	{
+		Throw( InvalidPartial, "Tried find last Breakpoint in a Partial with no Breakpoints." );
+	}
+#if defined(USE_VECTOR) 
+	//	see note above
+	return _breakpoints.back().second;
+#else
+	return (--end()).breakpoint();
+#endif
+}
+
+// ---------------------------------------------------------------------------
+//	last
+// ---------------------------------------------------------------------------
+//!	Return a const reference to the last Breakpoint in the Partial's
+//!	envelope. Raises InvalidPartial exception if there are no 
+//!	Breakpoints.
+//
+const Breakpoint & 
+Partial::last( void ) const
+{
+	if ( size() == 0 )
+	{
+		Throw( InvalidPartial, "Tried find last Breakpoint in a Partial with no Breakpoints." );
+	}	
+#if defined(USE_VECTOR) 
+	//	see note above
+	return _breakpoints.back().second;
+#else
+	return (--end()).breakpoint();
+#endif
+}
+
+// -- container-independent implementation --
+
+// ---------------------------------------------------------------------------
+//	initialPhase
+// ---------------------------------------------------------------------------
+//!	Return starting phase in radians, except (InvalidPartial) if there
+//!	are no Breakpoints.
+//
+double
+Partial::initialPhase( void ) const
+{
+	if ( numBreakpoints() == 0 )
+	{
+		Throw( InvalidPartial, "Tried find intial phase of a Partial with no Breakpoints." );
+	}
+	return first().phase();
+}
+
+// ---------------------------------------------------------------------------
+//	startTime
+// ---------------------------------------------------------------------------
+//!	Return start time in seconds, except (InvalidPartial) if there
+//!	are no Breakpoints.
+//
+double
+Partial::startTime( void ) const
+{
+	if ( numBreakpoints() == 0 )
+	{
+		Throw( InvalidPartial, "Tried to find start time of a Partial with no Breakpoints." );
+	}
+	return begin().time();
+}
+
+// ---------------------------------------------------------------------------
+//	endTime
+// ---------------------------------------------------------------------------
+//!	Return end time in seconds, except (InvalidPartial) if there
+//!	are no Breakpoints.
+//
+double
+Partial::endTime( void ) const
+{
+	if ( numBreakpoints() == 0 )
+	{
+		Throw( InvalidPartial, "Tried to find end time of a Partial with no Breakpoints." );
+	}
+	return (--end()).time();
+}
+
+// ---------------------------------------------------------------------------
+//	absorb
+// ---------------------------------------------------------------------------
+//!	Absorb another Partial's energy as noise (bandwidth), 
+//!	by accumulating the other's energy as noise energy
+//!	in the portion of this Partial's envelope that overlaps
+//!	(in time) with the other Partial's envelope.
+//
+void 
+Partial::absorb( const Partial & other )
+{
+	Partial::iterator it = findAfter( other.startTime() );
+	while ( it != end() && !(it.time() > other.endTime()) )
+	{
+		//	only non-null (non-zero-amplitude) Breakpoints
+		//	abosrb noise energy because null Breakpoints
+		//	are used especially to reset the Partial phase,
+		//	and are not part of the normal analyasis data:
+		if ( it->amplitude() > 0 )
+		{
+			// absorb energy from other at the time
+			// of this Breakpoint:
+			double a = other.amplitudeAt( it.time() );
+			it->addNoiseEnergy( a * a );
+		}	
+		++it;
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	setLabel
+// ---------------------------------------------------------------------------
+//!	Set the label for this Partial to the specified 32-bit value.
+//
+void 
+Partial::setLabel( label_type l ) 
+{ 
+	_label = l; 
+}
+
+// ---------------------------------------------------------------------------
+//	duration
+// ---------------------------------------------------------------------------
+//!	Return time, in seconds, spanned by this Partial, or 0. if there
+//!	are no Breakpoints.
+//
+double
+Partial::duration( void ) const
+{
+	if ( numBreakpoints() == 0 )
+	{
+		return 0.;
+	}
+	return endTime() - startTime();
+}
+
+// ---------------------------------------------------------------------------
+//	erase
+// ---------------------------------------------------------------------------
+//!	Erase the Breakpoint at the position of the 
+//!	given iterator (invalidating the iterator), and
+//!	return an iterator referring to the next position,
+//!	or end if pos is the last Breakpoint in the Partial.
+//
+Partial::iterator 
+Partial::erase( iterator pos )
+{
+	if ( pos != end() )
+	{
+		iterator b= pos;
+		iterator e = ++pos;
+		pos = erase( b, e );
+	}
+	return pos;
+}
+
+// ---------------------------------------------------------------------------
+//	split
+// ---------------------------------------------------------------------------
+//!	Break this Partial at the specified position (iterator).
+//!	The Breakpoint at the specified position becomes the first
+//!	Breakpoint in a new Partial. Breakpoints at the specified
+//!	position and subsequent positions are removed from this
+//!	Partial and added to the new Partial, which is returned.
+//
+Partial 
+Partial::split( iterator pos )
+{
+	Partial res( pos, end() );
+	erase( pos, end() );
+	return res;
+}
+
+// ---------------------------------------------------------------------------
+//	findNearest (const version)
+// ---------------------------------------------------------------------------
+//!	Return the insertion position for the Breakpoint nearest
+//!	the specified time. Always returns a valid iterator (the
+//!	position of the nearest-in-time Breakpoint) unless there
+//!	are no Breakpoints.
+//
+Partial::const_iterator
+Partial::findNearest( double time ) const
+{
+	//	if there are no Breakpoints, return end:
+	if ( numBreakpoints() == 0 )
+	{
+		return end();
+	}
+			
+	//	get the position of the first Breakpoint after time:
+	Partial::const_iterator pos = findAfter( time );
+	
+	//	if there is an earlier Breakpoint that is closer in
+	//	time, prefer that one:
+	if ( pos != begin() )
+	{
+		Partial::const_iterator prev = pos;
+		--prev;
+		if ( pos == end() || pos.time() - time > time - prev.time() )
+		{
+			return prev;
+		}
+	}
+
+	//	failing all else:	
+	return pos;
+} 
+
+// ---------------------------------------------------------------------------
+//	findNearest (non-const version)
+// ---------------------------------------------------------------------------
+//!	Return the insertion position for the Breakpoint nearest
+//!	the specified time. Always returns a valid iterator (the
+//!	position of the nearest-in-time Breakpoint) unless there
+//!	are no Breakpoints.
+//
+Partial::iterator
+Partial::findNearest( double time )
+{
+	//	if there are no Breakpoints, return end:
+	if ( numBreakpoints() == 0 )
+	{
+		return end();
+	}		
+	//	get the position of the first Breakpoint after time:
+	Partial::iterator pos = findAfter( time );
+	
+	//	if there is an earlier Breakpoint that is closer in
+	//	time, prefer that one:
+	if ( pos != begin() )
+	{
+		Partial::iterator prev = pos;
+		--prev;
+		if ( pos == end() || pos.time() - time > time - prev.time() )
+		{
+			return prev;
+		}
+	}
+
+	//	failing all else:	
+	return pos;
+} 
+
+// ---------------------------------------------------------------------------
+//	frequencyAt
+// ---------------------------------------------------------------------------
+//!	Return the interpolated frequency (in Hz) of this Partial at the
+//!	specified time. At times beyond the ends of the Partial, return
+//!	the frequency at the nearest envelope endpoint. Throw an
+//!	InvalidPartial exception if this Partial has no Breakpoints.
+//
+double
+Partial::frequencyAt( double time ) const
+{
+    Breakpoint bp = parametersAt( time );
+    return bp.frequency();
+}
+
+// ---------------------------------------------------------------------------
+//	ShortestSafeFadeTime
+// ---------------------------------------------------------------------------
+//!	Define the default fade time for computing amplitude at the ends
+//!	of a Partial. Floating point round-off errors make fadeTime == 0.0
+//!	dangerous and unpredictable. 1 ns is short enough to prevent rounding
+//!	errors in the least significant bit of a 48-bit mantissa for times
+//!	up to ten hours.
+//
+const double Partial::ShortestSafeFadeTime = 1.0E-9;
+
+// ---------------------------------------------------------------------------
+//	amplitudeAt
+// ---------------------------------------------------------------------------
+//!	Return the interpolated amplitude of this Partial at the
+//!	specified time. Throw an InvalidPartial exception if this 
+//!	Partial has no Breakpoints. If non-zero fadeTime is specified, 
+//!	then the amplitude at the ends of the Partial is coomputed using
+//!	a linear fade. The default fadeTime is ShortestSafeFadeTime,
+//!	see the definition of ShortestSafeFadeTime, above.
+//	
+double
+Partial::amplitudeAt( double time, double fadeTime ) const
+{
+    Breakpoint bp = parametersAt( time, fadeTime );
+    return bp.amplitude();
+}
+
+
+// ---------------------------------------------------------------------------
+//	phaseAt
+// ---------------------------------------------------------------------------
+//!	Return the interpolated phase (in radians) of this Partial at
+//!	the specified time. At times beyond the ends of the Partial,
+//!	return the extrapolated from the nearest envelope endpoint
+//!	(assuming constant frequency, as reported by frequencyAt()).
+//!	
+//! \param time is the time in seconds at which to evaluate the phase
+//!
+//! \throw Throw an InvalidPartial exception if this Partial has no
+//!	Breakpoints.
+//	
+double
+Partial::phaseAt( double time ) const
+{
+    Breakpoint bp = parametersAt( time );
+    return bp.phase();
+}
+
+// ---------------------------------------------------------------------------
+//	bandwidthAt
+// ---------------------------------------------------------------------------
+//!	Return the interpolated bandwidth (noisiness) coefficient of
+//!	this Partial at the specified time. At times beyond the ends of
+//!	the Partial, return the bandwidth coefficient at the nearest
+//!	envelope endpoint. Throw an InvalidPartial exception if this
+//!	Partial has no Breakpoints.
+//	
+double
+Partial::bandwidthAt( double time ) const
+{
+    Breakpoint bp = parametersAt( time );
+    return bp.bandwidth();
+}
+
+// ---------------------------------------------------------------------------
+//  wrapPi
+// ---------------------------------------------------------------------------
+//  O'Donnell's phase wrapping function.
+//
+static inline double wrapPi( double x )
+{
+    using namespace std; // floor should be in std
+    #define ROUND(x) (floor(.5 + (x)))
+    const double TwoPi = 2.0*Pi;
+    return x + ( TwoPi * ROUND(-x/TwoPi) );
+}
+
+// ---------------------------------------------------------------------------
+//	parametersAt
+// ---------------------------------------------------------------------------
+//!	Return the interpolated parameters of this Partial at
+//!	the specified time. If non-zero fadeTime is specified, then the
+//!	amplitude at the ends of the Partial is coomputed using a 
+//!	linear fade. The default fadeTime is ShortestSafeFadeTime.
+//!	Throw an InvalidPartial exception if this Partial has no
+//!	Breakpoints. 
+//
+Breakpoint
+Partial::parametersAt( double time, double fadeTime ) const 
+{
+	if ( numBreakpoints() == 0 )
+	{
+		Throw( InvalidPartial, "Tried to interpolate a Partial with no Breakpoints." );
+	}
+	
+	double freq, amp, bw, ph;			
+	if ( startTime() >= time ) 
+	{
+		//	time is before the onset of the Partial:
+		//	frequency is starting frequency, 
+		//	amplitude is 0 (or fading), bandwidth is starting 
+		//	bandwidth, and phase is rolled back.
+		
+		const Breakpoint & bp = first();
+		double tstart = startTime();
+		
+		//  frequency:
+		freq = bp.frequency();
+		
+		//  amplitude:
+		amp = 0;
+		if ( (fadeTime > 0) && ((tstart - time) < fadeTime) )
+		{
+			//	fade in ampltude if time is before the onset of the Partial:
+			double alpha = 1. - ((tstart - time) / fadeTime);
+			amp = alpha * bp.amplitude();
+		}
+		
+        //  bandwidth:
+        bw = bp.bandwidth();
+        
+		//  phase:
+        double dp = 2. * Pi * (startTime() - time) * bp.frequency();
+		ph = wrapPi( bp.phase() - dp );
+
+	}
+	else if ( endTime() <= time ) 
+	{
+		//	time is past the end of the Partial:
+		//	frequency is ending frequency, 
+		//	amplitude is 0 (or fading), bandwidth is ending 
+		//	bandwidth, and phase is rolled forward.
+		const Breakpoint & bp = last();	
+        double tend = endTime();
+
+		//  frequency:
+		freq = bp.frequency();
+		
+		//  amplitude:		
+		amp = 0;
+		if ( (fadeTime > 0) && ((time - tend) < fadeTime) )
+		{
+			//	fade out ampltude if time is past the end of the Partial:
+			double alpha = 1. - ((time - tend) / fadeTime);
+			amp = alpha * bp.amplitude();
+		}
+
+        //  bandwidth:
+        bw = bp.bandwidth();
+        
+        //  phase:
+		double dp = 2. * Pi * (time - endTime()) * bp.frequency();
+		ph = wrapPi( bp.phase() + dp );
+	}
+	else 
+	{
+        //	findAfter returns the position of the earliest
+        //	Breakpoint later than time, or the end
+        //	position if no such Breakpoint exists:
+        Partial::const_iterator it = findAfter( time );
+	
+        //	interpolate between it and its predeccessor
+        //	(we checked already that it is not begin or end):
+        const Breakpoint & hi = it.breakpoint();
+		double hitime = it.time();
+        const Breakpoint & lo = (--it).breakpoint();
+        double lotime = it.time();
+        
+        double alpha = (time - lotime) / (hitime - lotime);
+		
+        //  frequency:
+        freq = (alpha * hi.frequency()) + ((1. - alpha) * lo.frequency());
+			   
+        //  amplitude:	
+        amp = (alpha * hi.amplitude()) + ((1. - alpha) * lo.amplitude());
+
+        //  bandwidth:
+        bw = (alpha * hi.bandwidth()) + ((1. - alpha) * lo.bandwidth());
+        
+        //  phase:
+        //  interpolated phase is computed from the interpolated frequency 
+        //  and offset from the phase of the preceding Breakpoint:
+        double favg = 0.5 * ( lo.frequency() + freq ); // + hi.frequency() );
+        double dp = 2. * Pi * (time - lotime) * favg;                   
+        ph = wrapPi( lo.phase() + dp );                        	
+	}
+	
+	return Breakpoint( freq, amp, bw, ph );
+}
+
+}	//	end of namespace Loris
diff --git a/src/loris/Partial.h b/src/loris/Partial.h
new file mode 100644
index 0000000..1b26871
--- /dev/null
+++ b/src/loris/Partial.h
@@ -0,0 +1,786 @@
+#ifndef INCLUDE_PARTIAL_H
+#define INCLUDE_PARTIAL_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Partial.h
+ *
+ * Definition of class Loris::Partial, and definitions and implementations of
+ * classes of const and non-const iterators over Partials, and the exception
+ * class InvalidPartial, thrown by some Partial members when invoked on a 
+ * degenerate Partial having no Breakpoints.
+ *
+ * Kelly Fitz, 16 Aug 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "Breakpoint.h"
+#include "LorisExceptions.h"
+
+#include <map>
+//#include <utility>
+//#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+class Partial_Iterator;
+class Partial_ConstIterator;
+
+// ---------------------------------------------------------------------------
+//	class Partial
+//
+//!	An instance of class Partial represents a single component in the
+//!	reassigned bandwidth-enhanced additive model. A Partial consists of a
+//!	chain of Breakpoints describing the time-varying frequency, amplitude,
+//!	and bandwidth (or noisiness) envelopes of the component, and a 4-byte
+//!	label. The Breakpoints are non-uniformly distributed in time. For more
+//!	information about Reassigned Bandwidth-Enhanced Analysis and the
+//!	Reassigned Bandwidth-Enhanced Additive Sound Model, refer to the Loris
+//!	website: www.cerlsoundgroup.org/Loris/.
+//!	
+//!	The constituent time-tagged Breakpoints are accessible through
+//!	Partial:iterator and Partial::const_iterator interfaces.
+//!	These iterator classes implement the interface for bidirectional
+//!	iterators in the STL, including pre and post-increment and decrement,
+//!	and dereferencing. Dereferencing a Partial::itertator or
+//!	Partial::const_itertator yields a reference to a Breakpoint. Additionally,
+//!	these iterator classes have breakpoint() and time() members, returning
+//!	the Breakpoint (by reference) at the current iterator position and the
+//!	time (by value) corresponding to that Breakpoint.
+//!	
+//!	Partial is a leaf class, do not subclass.
+//!
+//!	Most of the implementation of Partial delegates to a few
+//!	container-dependent members. The following members are
+//!	container-dependent, the other members are implemented in 
+//!	terms of these:
+//!		default construction
+//!		copy (construction)
+//!		operator= (assign)
+//!		operator== (equivalence)
+//!		size
+//!		insert( pos, Breakpoint )
+//!		erase( b, e )
+//!		findAfter( time )
+//!		begin (const and non-const)
+//!		end (const and non-const)
+//!		first (const and non-const)
+//!		last (const and non-const)
+//
+class Partial
+{	
+//	-- public interface --
+public:
+
+//	-- types --
+
+	//!	underlying Breakpoint container type, used by 
+	//!	the iterator types defined below:
+	typedef std::map< double, Breakpoint > container_type;
+	
+	//	typedef std::vector< std::pair< double, Breakpoint > > container_type;
+	//	see Partial.C for a discussion of issues surrounding the 
+	//	choice of std::map as a Breakpoint container.
+
+	//! 32 bit type for labeling Partials
+	typedef int label_type;	
+	
+	//!	non-const iterator over (time, Breakpoint) pairs in this Partial
+	typedef Partial_Iterator iterator;	
+	
+	//!	const iterator over (time, Breakpoint) pairs in this Partial
+	typedef Partial_ConstIterator const_iterator;
+	
+	//! size type for number of Breakpoints in this Partial
+	typedef container_type::size_type size_type;
+
+//	-- construction --
+
+	//! Retun a new empty (no Breakpoints) Partial.
+	Partial( void );
+	 
+	//!	Retun a new Partial from a half-open (const) iterator range 
+	//!	of time-Breakpoint pairs.
+	//!
+	//!	\param	beg is the beginning of the range of time-Breakpoint
+	//!			pairs to insert into the new Partial.
+	//!	\param	end is the end of the range of time-Breakpoint pairs
+	//!			to insert into the new Partial.
+	Partial( const_iterator beg, const_iterator end );
+	 
+	//!	Return a new Partial that is an exact copy (has an identical set
+	//!	of Breakpoints, at identical times, and the same label) of another 
+	//!	Partial.
+	//!
+	//!	\param	other is the Partial to copy.
+	Partial( const Partial & other );
+	 
+	//!	Destroy this Partial.
+	~Partial( void );
+	 
+//	-- assignment --
+
+	//!	Make this Partial an exact copy (has an identical set of 
+	//!	Breakpoints, at identical times, and the same label) of another 
+	//!	Partial.
+	//!
+	//!	\param	other is the Partial to copy.
+	Partial & operator=( const Partial & other );
+
+//	-- container-dependent implementation --
+
+	//!	Return an iterator refering to the position of the first
+	//!	Breakpoint in this Partial's envelope, or end() if there
+	//! are no Breakpoints in the Partial.
+	iterator begin( void );
+	 
+	//!	Return a const iterator refering to the position of the first
+	//!	Breakpoint in this Partial's envelope, or end() if there
+	//! are no Breakpoints in the Partial.
+	const_iterator begin( void ) const;
+	
+	//!	Return an iterator refering to the position past the last
+	//!	Breakpoint in this Partial's envelope. The iterator returned by
+	//!	end() (like the iterator returned by the end() member of any STL
+	//!	container) does not refer to a valid Breakpoint. 	
+	iterator end( void );
+
+	//!	Return a const iterator refering to the position past the last
+	//!	Breakpoint in this Partial's envelope. The iterator returned by
+	//!	end() (like the iterator returned by the end() member of any STL
+	//!	container) does not refer to a valid Breakpoint. 	
+	const_iterator end( void ) const;
+
+	//!	Breakpoint removal: erase the Breakpoints in the specified range,
+	//!	and return an iterator referring to the position after the,
+	//!	erased range.
+	//!
+	//! \param 	beg is the beginning of the range of Breakpoints to erase
+	//! \param	end is the end of the range of Breakpoints to erase
+	//!	\return	The position of the first Breakpoint after the range
+	//!			of removed Breakpoints, or end() if the last Breakpoint
+	//!			in the Partial was removed.
+	iterator erase( iterator beg, iterator end );
+
+	//!	Return an iterator refering to the insertion position for a
+	//!	Breakpoint at the specified time (that is, the position of the first
+	//!	Breakpoint at a time later than the specified time).
+	//!
+	//!	\param	time is the time in seconds to find
+	//!	\return The last position (iterator) at which a Breakpoint at the
+	//!			specified time could be inserted (the position of the 
+	//!			first Breakpoint later than time).
+	iterator findAfter( double time );
+
+	//!	Return a const iterator refering to the insertion position for a
+	//!	Breakpoint at the specified time (that is, the position of the first
+	//!	Breakpoint at a time later than the specified time).
+	//!
+	//!	\param	time is the time in seconds to find
+	//!	\return The last position (iterator) at which a Breakpoint at the
+	//!			specified time could be inserted (the position of the 
+	//!			first Breakpoint later than time).
+	const_iterator findAfter( double time ) const;
+
+	//!	Breakpoint insertion: insert a copy of the specified Breakpoint in the
+	//!	parameter envelope at time (seconds), and return an iterator
+	//!	refering to the position of the inserted Breakpoint.
+	//!
+	//!	\param 	time is the time in seconds at which to insert the new
+	//!			Breakpoint.
+	//!	\param 	bp is the new Breakpoint to insert.
+	//!	\return the position (iterator) of the newly-inserted 
+	//!			time-Breakpoint pair.
+	iterator insert( double time, const Breakpoint & bp );
+
+	//!	Return the number of Breakpoints in this Partial.
+	//!
+	//!	\return	The number of Breakpoints in this Partial.
+	size_type size( void ) const;
+		 	
+//	-- access --
+
+	//!	Return the duration (in seconds) spanned by the Breakpoints in
+	//!	this Partial. Note that the synthesized onset time will differ,
+	//!	depending on the fade time used to synthesize this Partial (see
+	//!	class Synthesizer).
+	double duration( void ) const;
+	 
+	//!	Return the time (in seconds) of the last Breakpoint in this
+	//!	Partial. Note that the synthesized onset time will differ,
+	//!	depending on the fade time used to synthesize this Partial (see
+	//!	class Synthesizer).
+	double endTime( void ) const;
+	 
+	//!	Return a reference to the first Breakpoint in the Partial's
+	//!	envelope. 
+	//!
+	//!	\throw InvalidPartial if there are no Breakpoints.
+	Breakpoint & first( void );
+
+	//!	Return a const reference to the first Breakpoint in the Partial's
+	//!	envelope.  
+	//!
+	//!	\throw InvalidPartial if there are no Breakpoints.
+	const Breakpoint & first( void ) const;
+	 
+	//!	Return the phase (in radians) of this Partial at its start time
+	//!	(the phase of the first Breakpoint). Note that the initial
+	//!	synthesized phase will differ, depending on the fade time used
+	//!	to synthesize this Partial (see class Synthesizer).
+	double initialPhase( void ) const;
+	 	 
+	//!	Return the 32-bit label for this Partial as an integer.
+	label_type label( void ) const;
+
+	//!	Return a reference to the last Breakpoint in the Partial's
+	//!	envelope. 
+	//!
+	//!	\throw InvalidPartial if there are no Breakpoints.	 
+	Breakpoint & last( void );
+	
+	//!	Return a const reference to the last Breakpoint in the Partial's
+	//!	envelope. 
+	//!
+	//!	\throw InvalidPartial if there are no Breakpoints.	
+	const Breakpoint & last( void ) const;
+	 
+	//!	Same as size(). Return the number of Breakpoints in this Partial.
+	size_type numBreakpoints( void ) const;
+
+	//!	Return the time (in seconds) of the first Breakpoint in this
+	//!	Partial. Note that the synthesized onset time will differ,
+	//!	depending on the fade time used to synthesize this Partial (see
+	//!	class Synthesizer).
+	double startTime( void ) const;
+	 
+//	-- mutation --
+
+	//!	Absorb another Partial's energy as noise (bandwidth), 
+	//!	by accumulating the other's energy as noise energy
+	//!	in the portion of this Partial's envelope that overlaps
+	//!	(in time) with the other Partial's envelope.
+	//!
+	//!	\param	other is the Partial to absorb.
+	void absorb( const Partial & other );
+
+	//!	Set the label for this Partial to the specified 32-bit value.
+	void setLabel( label_type l );
+
+	//!	Remove the Breakpoint at the position of the given
+	//!	iterator, invalidating the iterator. Return a 
+	//!	iterator referring to the next valid position, or to
+	//!	the end of the Partial if the last Breakpoint is removed.
+	//!
+	//!	\param	pos is the position of the time-Breakpoint pair
+	//!			to be removed.
+	//!	\return The position (iterator) of the time-Breakpoint
+	//!			pair after the one that was removed.
+	//!	\post	The iterator pos is invalid. 
+	iterator erase( iterator pos );
+	 
+	//!	Return an iterator refering to the position of the
+	//!	Breakpoint in this Partial nearest the specified time.
+	//!	
+	//!	\param	time is the time to find.
+	//!	\return	The position (iterator) of the time-Breakpoint
+	//!			pair nearest (in time) to the specified time.
+	iterator findNearest( double time );
+
+	//!	Return a const iterator refering to the position of the
+	//!	Breakpoint in this Partial nearest the specified time.
+	//!	
+	//!	\param	time is the time to find.
+	//!	\return	The position (iterator) of the time-Breakpoint
+	//!			pair nearest (in time) to the specified time.
+	const_iterator findNearest( double time ) const;
+
+	//!	Break this Partial at the specified position (iterator).
+	//!	The Breakpoint at the specified position becomes the first
+	//!	Breakpoint in a new Partial. Breakpoints at the specified
+	//!	position and subsequent positions are removed from this
+	//!	Partial and added to the new Partial, which is returned.
+	//!
+	//!	\param	pos is the position at which to split this Partial.
+	//!	\return A new Partial consisting of time-Breakpoint pairs
+	//!			beginning with pos and extending to the end of this
+	//!			Partial.
+	//!	\post	All positions beginning with pos and extending to
+	//!			the end of this Partial have been removed.
+	Partial split( iterator pos );
+	 
+//	-- parameter interpolation/extrapolation --
+
+	//!	Define the default fade time for computing amplitude at the ends
+	//!	of a Partial. Floating point round-off errors make fadeTime == 0.0
+	//!	dangerous and unpredictable. 1 ns is short enough to prevent rounding
+	//!	errors in the least significant bit of a 48-bit mantissa for times
+	//!	up to ten hours.
+	//!
+	//!	1 nanosecond, see Partial.C
+	static const double ShortestSafeFadeTime;	
+
+	//!	Return the interpolated amplitude of this Partial at the
+	//!	specified time. If non-zero fadeTime is specified, 
+	//!	then the amplitude at the ends of the Partial is computed using
+	//!	a linear fade. The default fadeTime is ShortestSafeFadeTime,
+	//!	see the definition of ShortestSafeFadeTime, above.
+	//!	
+	//!	\param	time is the time in seconds at which to evaluate the 
+	//!			Partial.
+	//!	\param	fadeTime is the duration in seconds over which Partial
+	//!			amplitudes fade at the ends. The default value is
+	//!			ShortestSafeFadeTime, 1 ns.
+	//!	\return	The amplitude of this Partial at the specified time.
+	//! \pre	The Partial must have at least one Breakpoint.
+	//!	\throw	InvalidPartial if the Partial has no Breakpoints.
+	double amplitudeAt( double time, double fadeTime = ShortestSafeFadeTime ) const;
+
+	//!	Return the interpolated bandwidth (noisiness) coefficient of
+	//!	this Partial at the specified time. At times beyond the ends of
+	//!	the Partial, return the bandwidth coefficient at the nearest
+	//!	envelope endpoint. 
+	//!	
+	//!	\param	time is the time in seconds at which to evaluate the 
+	//!			Partial.
+	//!	\return	The bandwidth of this Partial at the specified time.
+	//! \pre	The Partial must have at least one Breakpoint.
+	//!	\throw	InvalidPartial if the Partial has no Breakpoints.
+	double bandwidthAt( double time ) const;
+	 
+	//!	Return the interpolated frequency (in Hz) of this Partial at the
+	//!	specified time. At times beyond the ends of the Partial, return
+	//!	the frequency at the nearest envelope endpoint.
+	//!	
+	//!	\param	time is the time in seconds at which to evaluate the 
+	//!			Partial.
+	//!	\return	The frequency of this Partial at the specified time.
+	//! \pre	The Partial must have at least one Breakpoint.
+	//!	\throw	InvalidPartial if the Partial has no Breakpoints.
+	double frequencyAt( double time ) const;
+	 
+	//!	Return the interpolated phase (in radians) of this Partial at
+	//!	the specified time. At times beyond the ends of the Partial,
+	//!	return the extrapolated from the nearest envelope endpoint
+	//!	(assuming constant frequency, as reported by frequencyAt()).
+	//!	
+	//!	\param	time is the time in seconds at which to evaluate the 
+	//!			Partial.
+	//!	\return	The phase of this Partial at the specified time.
+	//! \pre	The Partial must have at least one Breakpoint.
+	//!	\throw	InvalidPartial if the Partial has no Breakpoints.
+	double phaseAt( double time ) const;
+
+	//!	Return the interpolated parameters of this Partial at
+	//!	the specified time, same as building a Breakpoint from
+	//!	the results of frequencyAt, ampitudeAt, bandwidthAt, and
+	//!	phaseAt, but performs only one Breakpoint envelope search.
+	//!	If non-zero fadeTime is specified, then the
+	//!	amplitude at the ends of the Partial is coomputed using a 
+	//!	linear fade. The default fadeTime is ShortestSafeFadeTime.
+	//!	
+	//!	\param	time is the time in seconds at which to evaluate the 
+	//!			Partial.
+	//!	\param	fadeTime is the duration in seconds over which Partial
+	//!			amplitudes fade at the ends. The default value is
+	//!			ShortestSafeFadeTime, 1 ns.
+	//!	\return	A Breakpoint describing the parameters of this Partial 
+	//!			at the specified time.
+	//! \pre	The Partial must have at least one Breakpoint.
+	//!	\throw	InvalidPartial if the Partial has no Breakpoints.
+	Breakpoint parametersAt( double time, double fadeTime = ShortestSafeFadeTime ) const;
+
+//	-- implementation --
+private:
+
+	label_type _label;
+	container_type _breakpoints;	//	Breakpoint envelope
+	 
+};	//	end of class Partial
+
+// ---------------------------------------------------------------------------
+//	class Partial_Iterator
+//
+//!	Non-const iterator for the Loris::Partial Breakpoint map. Wraps
+//!	the non-const iterator for the (time,Breakpoint) pair container
+//!	Partial::container_type. Partial_Iterator implements a
+//!	bidirectional iterator interface, and additionally offers time
+//!	and Breakpoint (reference) access through time() and breakpoint()
+//!	members.
+//
+class Partial_Iterator
+{
+//	-- instance variables --
+
+	typedef Partial::container_type BaseContainer;
+	typedef BaseContainer::iterator BaseIterator;
+	BaseIterator _iter;
+	
+//	-- public interface --
+public:
+//	-- bidirectional iterator interface --
+
+	//! The iterator category, for copmpatibility with 
+	//! C++ standard library algorithms 
+	typedef BaseIterator::iterator_category	iterator_category;
+	
+	//! The type of element that can be accessed through this 
+	//! iterator (Breakpoint).
+	typedef Breakpoint     					value_type;
+	
+	//! The type representing the distance between two of these
+	//! iterators.
+	typedef BaseIterator::difference_type  	difference_type;
+	
+	//! The type of a pointer to the type of element that can 
+	//! be accessed through this iterator (Breakpoint *).
+	typedef Breakpoint *					pointer;
+
+	//! The type of a reference to the type of element that can 
+	//! be accessed through this iterator (Breakpoint &).
+	typedef Breakpoint &					reference;
+
+//	construction:
+	
+	//!	Construct a new iterator referring to no position in 
+	//!	any Partial.
+	Partial_Iterator( void ) {}
+	
+	//	(allow compiler to generate copy, assignment, and destruction)
+	
+//	pre-increment/decrement:
+
+	//!	Pre-increment operator - advance the position of the iterator
+	//! and return the iterator itself.
+	//!
+	//!	\return	This iterator (reference to self).
+	//!	\pre	The iterator must be a valid position before the end
+	//!			in some Partial.
+	Partial_Iterator& operator ++ () { ++_iter; return *this; }
+
+	//!	Pre-decrement operator - move the position of the iterator
+	//! back by one and return the iterator itself.
+	//!
+	//!	\return	This iterator (reference to self).
+	//!	\pre	The iterator must be a valid position after the beginning
+	//!			in some Partial.
+	Partial_Iterator& operator -- () { --_iter; return *this; }
+
+//	post-increment/decrement:
+
+	//!	Post-increment operator - advance the position of the iterator
+	//! and return a copy of the iterator before it was advanced.
+	//!	The int argument is unused compiler magic.
+	//!	
+	//!	\return	An iterator that is a copy of this iterator before 
+	//!			being advanced.
+	//!	\pre	The iterator must be a valid position before the end
+	//!			in some Partial.
+	Partial_Iterator operator ++ ( int ) { return Partial_Iterator( _iter++ ); } 
+
+	//!	Post-decrement operator - move the position of the iterator
+	//! back by one and return a copy of the iterator before it was 
+	//!	decremented. The int argument is unused compiler magic.
+	//!	
+	//!	\return	An iterator that is a copy of this iterator before 
+	//!			being decremented.
+	//!	\pre	The iterator must be a valid position after the beginning
+	//!			in some Partial.
+	Partial_Iterator operator -- ( int ) { return Partial_Iterator( _iter-- ); } 
+	
+//	dereference (for treating Partial like a 
+//	STL collection of Breakpoints):
+
+	//!	Dereference operator.
+	//!
+	//!	\return	A reference to the Breakpoint at the position of this
+	//!			iterator.
+	Breakpoint & operator * ( void ) const { return breakpoint(); }
+
+
+	//!	Dereference operator.
+	//!
+	//!	\return	A reference to the Breakpoint at the position of this
+	//!			iterator.
+	//Breakpoint & operator * ( void ) { return breakpoint(); }
+	
+	//!	Pointer operator.
+	//!
+	//!	\return	A pointer to the Breakpoint at the position of this
+	//!			iterator.
+	Breakpoint * operator -> ( void ) const  { return & breakpoint(); }
+
+	//!	Pointer operator.
+	//!
+	//!	\return	A pointer to the Breakpoint at the position of this
+	//!			iterator.
+	//Breakpoint * operator -> ( void )  { return & breakpoint(); }
+		
+//	comparison:
+
+	//!	Equality comparison operator.
+	//!
+	//!	\param 	lhs the iterator on the left side of the operator.
+	//!	\param 	rhs the iterator on the right side of the operator.
+	//!	\return	true if the two iterators refer to the same position
+	//!			in the same Partial, false otherwise.
+	friend bool operator == ( const Partial_Iterator & lhs, 
+							  const Partial_Iterator & rhs )
+		{ return lhs._iter == rhs._iter; }
+
+	//!	Inequality comparison operator.
+	//!
+	//!	\param 	lhs the iterator on the left side of the operator.
+	//!	\param 	rhs the iterator on the right side of the operator.
+	//!	\return	false if the two iterators refer to the same position
+	//!			in the same Partial, true otherwise.
+	friend bool operator != ( const Partial_Iterator & lhs, 
+							  const Partial_Iterator & rhs )
+		{ return lhs._iter != rhs._iter; }
+	
+//	-- time and Breakpoint access --
+
+	//!	Breakpoint accessor.
+	//!
+	//!	\return	A const reference to the Breakpoint at the position of this
+	//!			iterator.
+	Breakpoint & breakpoint( void ) const 
+		{ return _iter->second; }
+
+	//!	Breakpoint accessor.
+	//!
+	//!	\return	A reference to the Breakpoint at the position of this
+	//!			iterator.
+	//Breakpoint & breakpoint( void ) 
+	//	{ return _iter->second; }
+
+	//!	Time accessor.
+	//!
+	//!	\return	The time in seconds of the Breakpoint at the position 
+	//!			of this iterator.
+	double time( void ) const  
+		{ return _iter->first; }
+
+//	-- BaseIterator conversions --
+private:
+	//	construction by GenericBreakpointContainer from a BaseIterator:
+	Partial_Iterator( const BaseIterator & it ) :
+		_iter(it) {}
+
+	friend class Partial;
+	
+	//	befriend  Partial_ConstIterator, 
+	//	for const construction from non-const:
+	friend class Partial_ConstIterator;	
+	
+};	//	end of class Partial_Iterator
+
+// ---------------------------------------------------------------------------
+//	class Partial_ConstIterator
+//
+//!	Const iterator for the Loris::Partial Breakpoint map. Wraps
+//!	the non-const iterator for the (time,Breakpoint) pair container
+//!	Partial::container_type. Partial_Iterator implements a
+//!	bidirectional iterator interface, and additionally offers time
+//!	and Breakpoint (reference) access through time() and breakpoint()
+//!	members.
+//
+class Partial_ConstIterator
+{
+//	-- instance variables --
+	typedef Partial::container_type BaseContainer;
+	typedef BaseContainer::const_iterator BaseIterator;
+	BaseIterator _iter;
+	
+//	-- public interface --
+public:
+//	-- bidirectional iterator interface --
+
+	//! The iterator category, for copmpatibility with 
+	//! C++ standard library algorithms 
+	typedef BaseIterator::iterator_category	iterator_category;
+	
+	//! The type of element that can be accessed through this 
+	//! iterator (Breakpoint).
+	typedef Breakpoint     					value_type;
+	
+	//! The type representing the distance between two of these
+	//! iterators.
+	typedef BaseIterator::difference_type  	difference_type;
+	
+	//! The type of a pointer to the type of element that can 
+	//! be accessed through this iterator (const Breakpoint *).
+	typedef const Breakpoint *					pointer;
+
+	//! The type of a reference to the type of element that can 
+	//! be accessed through this iterator (const Breakpoint &).
+	typedef const Breakpoint &					reference;
+
+//	construction:
+
+	//!	Construct a new iterator referring to no position in 
+	//!	any Partial.
+	Partial_ConstIterator( void ) {}
+	
+	//!	Construct a new const iterator from a non-const iterator.
+	//!
+	//!	\param	other a non-const iterator from which to make
+	//!			a read-only copy.
+	Partial_ConstIterator( const Partial_Iterator & other ) :
+		_iter( other._iter ) {}
+	
+	//	(allow compiler to generate copy, assignment, and destruction):
+
+//	pre-increment/decrement:
+
+	//!	Pre-increment operator - advance the position of the iterator
+	//! and return the iterator itself.
+	//!
+	//!	\return	This iterator (reference to self).
+	//!	\pre	The iterator must be a valid position before the end
+	//!			in some Partial.
+	Partial_ConstIterator& operator ++ () { ++_iter; return *this; }
+
+	//!	Pre-decrement operator - move the position of the iterator
+	//! back by one and return the iterator itself.
+	//!
+	//!	\return	This iterator (reference to self).
+	//!	\pre	The iterator must be a valid position after the beginning
+	//!			in some Partial.
+	Partial_ConstIterator& operator -- () { --_iter; return *this; }
+
+//	post-increment/decrement:
+
+	//!	Post-increment operator - advance the position of the iterator
+	//! and return a copy of the iterator before it was advanced.
+	//!	The int argument is unused compiler magic.
+	//!	
+	//!	\return	An iterator that is a copy of this iterator before 
+	//!			being advanced.
+	//!	\pre	The iterator must be a valid position before the end
+	//!			in some Partial.
+	Partial_ConstIterator operator ++ ( int ) { return Partial_ConstIterator( _iter++ ); } 
+
+	//!	Post-decrement operator - move the position of the iterator
+	//! back by one and return a copy of the iterator before it was 
+	//!	decremented. The int argument is unused compiler magic.
+	//!	
+	//!	\return	An iterator that is a copy of this iterator before 
+	//!			being decremented.
+	//!	\pre	The iterator must be a valid position after the beginning
+	//!			in some Partial.
+	Partial_ConstIterator operator -- ( int ) { return Partial_ConstIterator( _iter-- ); } 
+	
+//	dereference (for treating Partial like a 
+//	STL collection of Breakpoints):
+
+	//!	Dereference operator.
+	//!
+	//!	\return	A const reference to the Breakpoint at the position of this
+	//!			iterator.
+	const Breakpoint & operator * ( void ) const { return breakpoint(); }
+
+	//!	Pointer operator.
+	//!
+	//!	\return	A const pointer to the Breakpoint at the position of this
+	//!			iterator.
+	const Breakpoint * operator -> ( void ) const { return & breakpoint(); }
+	
+//	comparison:
+
+	//!	Equality comparison operator.
+	//!
+	//!	\param 	lhs the iterator on the left side of the operator.
+	//!	\param 	rhs the iterator on the right side of the operator.
+	//!	\return	true if the two iterators refer to the same position
+	//!			in the same Partial, false otherwise.
+	friend bool operator == ( const Partial_ConstIterator & lhs, 
+							  const Partial_ConstIterator & rhs )
+		{ return lhs._iter == rhs._iter; }
+
+	//!	Inequality comparison operator.
+	//!
+	//!	\param 	lhs the iterator on the left side of the operator.
+	//!	\param 	rhs the iterator on the right side of the operator.
+	//!	\return	false if the two iterators refer to the same position
+	//!			in the same Partial, true otherwise.
+	friend bool operator != ( const Partial_ConstIterator & lhs, 
+							  const Partial_ConstIterator & rhs )
+		{ return lhs._iter != rhs._iter; }
+	
+//	-- time and Breakpoint access --
+
+	//!	Breakpoint accessor.
+	//!
+	//!	\return	A const reference to the Breakpoint at the position of this
+	//!			iterator.
+	const Breakpoint & breakpoint( void ) const 
+		{ return _iter->second; }
+
+	//!	Time accessor.
+	//!
+	//!	\return	The time in seconds of the Breakpoint at the position 
+	//!			of this iterator.
+	double time( void ) const  
+		{ return _iter->first; }
+	
+//	-- BaseIterator conversions --
+private:
+	//	construction by GenericBreakpointContainer from a BaseIterator:
+	Partial_ConstIterator( BaseIterator it ) :
+		_iter(it) {}
+	
+	friend class Partial;
+
+};	//	end of class Partial_ConstIterator
+
+// ---------------------------------------------------------------------------
+//	class InvalidPartial
+//
+//! Class of exceptions thrown when a Partial is found to be badly configured
+//! or otherwise invalid.
+//
+class InvalidPartial : public InvalidObject
+{
+public: 
+
+	//! Construct a new instance with the specified description and, optionally
+	//! a string identifying the location at which the exception as thrown. The
+	//! Throw( Exception_Class, description_string ) macro generates a location
+   //! string automatically using __FILE__ and __LINE__.
+   //!
+   //! \param  str is a string describing the exceptional condition
+   //! \param  where is an option string describing the location in
+   //!         the source code from which the exception was thrown
+   //!         (generated automatically byt he Throw macro).
+	InvalidPartial( const std::string & str, const std::string & where = "" ) : 
+		InvalidObject( std::string("Invalid Partial -- ").append( str ), where ) {}
+		
+};	//	end of class InvalidPartial
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_PARTIAL_H */
diff --git a/src/loris/PartialBuilder.C b/src/loris/PartialBuilder.C
new file mode 100644
index 0000000..f1ce3be
--- /dev/null
+++ b/src/loris/PartialBuilder.C
@@ -0,0 +1,319 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * PartialBuilder.C
+ *
+ * Implementation of a class representing a policy for connecting peaks
+ * extracted from a reassigned time-frequency spectrum to form ridges
+ * and construct Partials.
+ *
+ * This strategy attemps to follow a mFreqWarping frequency envelope when 
+ * forming Partials, by prewarping all peak frequencies according to the
+ * (inverse of) frequency mFreqWarping envelope. At the end of the analysis, 
+ * Partial frequencies need to be un-warped by calling fixPartialFrequencies().
+ *
+ * The first attempt was the same as the basic partial formation strategy, 
+ * but for purposes of matching, peak frequencies are scaled by the ratio
+ * of the mFreqWarping envelope's value at the previous frame to its value
+ * at the current frame. This was not adequate, didn't store enough history
+ * so it wasn't really following the reference envelope, just using it to
+ * make a local decision about how frequency should drift from one frame to
+ * the next.
+ *
+ * Kelly Fitz, 28 May 2003
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "PartialBuilder.h"
+
+#include "BreakpointEnvelope.h"
+#include "Envelope.h"
+#include "Notifier.h"
+#include "Partial.h"
+#include "PartialList.h"
+#include "PartialPtrs.h"
+#include "SpectralPeaks.h"
+
+#include <algorithm>
+#include <cmath>
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//  HEY - remove mMaxTimeOffset and the hopTime argument, these are wrong
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	construction
+// ---------------------------------------------------------------------------
+//  Construct a new builder that constrains Partial frequnecy
+//  drift by the specified drift value in Hz.
+//
+PartialBuilder::PartialBuilder( double drift ) :
+	mFreqWarping( new BreakpointEnvelope(1.0) ),
+	mFreqDrift( drift )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	construction
+// ---------------------------------------------------------------------------
+//  Construct a new builder that constrains Partial frequnecy
+//  drift by the specified drift value in Hz. The frequency
+//  warping envelope is applied to the spectral peak frequencies
+//  and the frequency drift parameter in each frame before peaks
+//  are linked to eligible Partials. All the Partial frequencies
+//  need to be un-warped at the ned of the building process, by
+//  calling finishBuilding().
+//
+PartialBuilder::PartialBuilder( double drift, const Envelope & env ) :
+	mFreqWarping( env.clone() ),
+	mFreqDrift( drift )
+{
+}
+
+// --- local helpers for Partial building ---
+
+// ---------------------------------------------------------------------------
+//	end_frequency
+// ---------------------------------------------------------------------------
+//	Return the frequency of the last Breakpoint in a Partial.
+//
+static inline double end_frequency( const Partial & partial )
+{
+	return partial.last().frequency();
+}
+
+// ---------------------------------------------------------------------------
+//	freq_distance
+// ---------------------------------------------------------------------------
+//	Helper function, used in formPartials().
+//	Returns the (positive) frequency distance between a Breakpoint 
+//	and the last Breakpoint in a Partial.
+//
+inline double 
+PartialBuilder::freq_distance( const Partial & partial, const SpectralPeak & pk )
+{
+    double normBpFreq = pk.frequency() / mFreqWarping->valueAt( pk.time() );
+    
+    double normPartialEndFreq = 
+        partial.last().frequency() / mFreqWarping->valueAt( partial.endTime() );
+    
+	return std::fabs( normPartialEndFreq - normBpFreq );
+}
+
+// ---------------------------------------------------------------------------
+//	better_match
+// ---------------------------------------------------------------------------
+//	Predicate for choosing the better of two proposed
+//	Partial-to-Breakpoint matches. Note: sometimes this
+//  is used to compare two candidate Breakpoint matches
+//  to the same Partial, other times to candidate Partials
+//  to the same Breakpoint.
+//
+//	Return true if the first match is better, otherwise
+//	return false.
+//
+
+bool PartialBuilder::better_match( const Partial & part, const SpectralPeak & pk1,
+                                   const SpectralPeak & pk2 )
+{
+	Assert( part.numBreakpoints() > 0 );
+	
+	return freq_distance( part, pk1 ) < freq_distance( part, pk2 );
+}	                                   
+                                   
+bool PartialBuilder::better_match( const Partial & part1, 
+                                   const Partial & part2, const SpectralPeak & pk )
+{
+	Assert( part1.numBreakpoints() > 0 );
+	Assert( part2.numBreakpoints() > 0 );
+	
+	return freq_distance( part1, pk ) < freq_distance( part2, pk );
+}	
+
+// --- Partial building members ---
+
+// ---------------------------------------------------------------------------
+//	buildPartials
+// ---------------------------------------------------------------------------
+//	Append spectral peaks, extracted from a reassigned time-frequency
+//	spectrum, to eligible Partials, where possible. Peaks that cannot
+//	be used to extend eliglble Partials spawn new Partials.
+//
+//	This is similar to the basic MQ partial formation strategy, except that
+//	before matching, all frequencies are normalized by the value of the 
+//	warping envelope at the time of the current frame. This means that
+//	the frequency envelopes of all the Partials are warped, and need to 
+//	be un-normalized by calling finishBuilding at the end of the building
+//  process.
+//
+void 
+PartialBuilder::buildPartials( Peaks & peaks, double frameTime )
+{	
+	mNewlyEligible.clear();
+	
+	unsigned int matchCount = 0;	//	for debugging
+		
+	//	frequency-sort the spectral peaks:
+	//	(the eligible partials are always sorted by
+	//	increasing frequency if we always sort the
+	//	peaks this way)
+	std::sort( peaks.begin(), peaks.end(), SpectralPeak::sort_increasing_freq );
+	
+	PartialPtrs::iterator eligible = mEligiblePartials.begin();
+	for ( Peaks::iterator bpIter = peaks.begin(); bpIter != peaks.end(); ++bpIter ) 
+	{
+		//const Breakpoint & bp = bpIter->breakpoint;
+		const double peakTime = frameTime + bpIter->time();
+		
+		// 	find the Partial that is nearest in frequency to the Peak:
+		PartialPtrs::iterator nextEligible = eligible;
+		if ( eligible != mEligiblePartials.end() &&
+			 end_frequency( **eligible ) < bpIter->frequency() )
+		{
+			++nextEligible;
+			while ( nextEligible != mEligiblePartials.end() &&
+					end_frequency( **nextEligible ) < bpIter->frequency() )
+			{
+				++nextEligible;
+				++eligible;
+			}
+			
+			if ( nextEligible != mEligiblePartials.end() &&
+				 better_match( **nextEligible, **eligible, *bpIter ) )
+			{
+				eligible = nextEligible;
+			}
+		}
+		
+		// 	INVARIANT:
+		//
+		//	eligible is the position of the nearest (in frequency)
+		//	eligible Partial (pointer) or it is mEligiblePartials.end().
+		//
+		//	nextEligible is the eligible Partial with frequency 
+		//	greater than bp, or it is mEligiblePartials.end().  
+              
+#if defined(Debug_Loris) && Debug_Loris
+        /*
+		if ( nextEligible != mEligiblePartials.end() )
+		{
+			debugger << matchFrequency << "( " << end_frequency( **eligible )
+					 << ", " << end_frequency( **nextEligible ) << ")" << endl;
+		}
+        */
+#endif
+								
+		//	create a new Partial if there is no eligible Partial,
+		//	or the frequency difference to the eligible Partial is 
+		//	too great, or the next peak is a better match for the 
+		//	eligible Partial, otherwise add this peak to the eligible
+		//	Partial:
+		Peaks::iterator nextPeak = //Peaks::iterator( bpIter ); ++nextPeak;
+								   ++Peaks::iterator( bpIter ); //  some compilers choke on this?
+
+        //  decide whether this match should be made:
+        //  - can only make the match if eligible is not the end of the list
+        //  - the match is only good if it is close enough in frequency
+        //  - even if the match is good, only match if the next one is not better
+        bool makeMatch = false;
+        if ( eligible != mEligiblePartials.end() )
+        {
+            bool matchIsGood =  mFreqDrift > 
+                std::fabs( end_frequency( **eligible ) - bpIter->frequency() );
+            if ( matchIsGood )
+            {
+                bool nextIsBetter = ( nextPeak != peaks.end() &&
+                                      better_match( **eligible, *nextPeak, *bpIter ) ); 
+                if ( ! nextIsBetter )
+                {
+                    makeMatch = true;
+                }
+            }                       
+        }
+        
+        Breakpoint bp = bpIter->createBreakpoint();
+        
+        if ( makeMatch )
+        {
+            //  invariant:
+            //  if makeMatch is true, then eligible is the position of a valid Partial
+            (*eligible)->insert( peakTime, bp );
+			mNewlyEligible.push_back( *eligible );
+			
+			++matchCount;
+        }
+        else
+        {
+            Partial p;
+            p.insert( peakTime, bp );
+            mCollectedPartials.push_back( p );
+            mNewlyEligible.push_back( & mCollectedPartials.back() );
+        }
+        
+		//	update eligible, nextEligible is the eligible Partial
+		//	with frequency greater than bp, or it is mEligiblePartials.end():
+		eligible = nextEligible;
+	}			 
+	 	
+	mEligiblePartials = mNewlyEligible;
+	
+    /*
+	debugger << "PartialBuilder::buildPartials: matched " << matchCount << endl;
+	debugger << "PartialBuilder::buildPartials: " << mNewlyEligible.size() << " newly eligible partials" << endl;
+    */
+}
+
+// ---------------------------------------------------------------------------
+//	finishBuilding
+// ---------------------------------------------------------------------------
+//	Un-do the frequency warping performed in buildPartials, and return 
+//	the Partials that were built. After calling finishBuilding, the
+//  builder is returned to its initial state, and ready to build another
+//  set of Partials. Partials are returned by appending them to the 
+//  supplied PartialList.
+//
+void
+PartialBuilder::finishBuilding( PartialList & product )
+{	
+    //  append the collected Partials to the product list:
+	product.splice( product.end(), mCollectedPartials );
+    
+    //  reset the builder state:
+    mEligiblePartials.clear();
+    mNewlyEligible.clear();
+}
+
+
+
+}	//	end of namespace Loris
diff --git a/src/loris/PartialBuilder.h b/src/loris/PartialBuilder.h
new file mode 100644
index 0000000..2592ffc
--- /dev/null
+++ b/src/loris/PartialBuilder.h
@@ -0,0 +1,143 @@
+#ifndef INCLUDE_PARTIALBUILDER_H
+#define INCLUDE_PARTIALBUILDER_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * PartialBuilder.h
+ *
+ * Implementation of a class representing a policy for connecting peaks
+ * extracted from a reassigned time-frequency spectrum to form ridges
+ * and construct Partials.
+ *
+ * This strategy attemps to follow a reference frequency envelope when 
+ * forming Partials, by prewarping all peak frequencies according to the
+ * (inverse of) frequency reference envelope. At the end of the analysis, 
+ * Partial frequencies need to be un-warped by calling fixPartialFrequencies().
+ *
+ * Kelly Fitz, 28 May 2003
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+ 
+#include "Partial.h"
+#include "PartialList.h"
+#include "PartialPtrs.h"
+#include "SpectralPeaks.h"
+
+#include <memory>
+
+//	begin namespace
+namespace Loris {
+
+class Envelope;
+
+// ---------------------------------------------------------------------------
+//	class PartialBuilder
+//
+//	A class representing the process of connecting peaks (ridges) on a 
+//	reassigned time-frequency surface to form Partials.
+//
+class PartialBuilder
+{
+// --- public interface ---
+
+public:
+
+	//	constructor
+    //
+    //  Construct a new builder that constrains Partial frequnecy
+    //  drift by the specified drift value in Hz.
+	PartialBuilder( double drift );    
+    
+	//	constructor
+    //
+    //  Construct a new builder that constrains Partial frequnecy
+    //  drift by the specified drift value in Hz. The frequency
+    //  warping envelope is applied to the spectral peak frequencies
+    //  and the frequency drift parameter in each frame before peaks
+    //  are linked to eligible Partials. All the Partial frequencies
+    //  need to be un-warped at the ned of the building process, by
+    //  calling finishBuilding().
+	PartialBuilder( double drift, const Envelope & freqWarpEnv );
+	
+    //  buildPartials
+    //
+    //	Append spectral peaks, extracted from a reassigned time-frequency
+    //	spectrum, to eligible Partials, where possible. Peaks that cannot
+    //	be used to extend eliglble Partials spawn new Partials.
+    //
+    //	This is similar to the basic MQ partial formation strategy, except that
+    //	before matching, all frequencies are normalized by the value of the 
+    //	warping envelope at the time of the current frame. This means that
+    //	the frequency envelopes of all the Partials are warped, and need to 
+    //	be un-normalized by calling finishBuilding at the end of the building
+    //  process.
+	void buildPartials( Peaks & peaks, double frameTime );
+
+    //  finishBuilding
+    //
+	//	Un-do the frequency warping performed in buildPartials, and return 
+	//	the Partials that were built. After calling finishBuilding, the
+    //  builder is returned to its initial state, and ready to build another
+    //  set of Partials. Partials are returned by appending them to the 
+    //  supplied PartialList.
+	void finishBuilding( PartialList & product );
+
+private:
+
+// --- auxiliary member functions ---
+
+    double freq_distance( const Partial & partial, const SpectralPeak & pk );
+
+    bool better_match( const Partial & part, const SpectralPeak & pk1,
+		   	           const SpectralPeak & pk2 );
+    bool better_match( const Partial & part1, 
+	  		           const Partial & part2, const SpectralPeak & pk );                       
+                       
+                       
+// --- collected partials ---
+
+	PartialList mCollectedPartials;             //	collect partials here
+
+// --- builder state variables ---
+		
+	PartialPtrs mEligiblePartials;
+    PartialPtrs mNewlyEligible;                 // 	keep track of eligible partials here
+
+// --- parameters ---
+    	
+	std::auto_ptr< Envelope > mFreqWarping;	//	reference envelope
+    
+	double mFreqDrift;
+    	
+// --- disallow copy and assignment ---
+    
+    PartialBuilder( const PartialBuilder & );
+    PartialBuilder& operator=( const PartialBuilder & );
+    
+};	//	end of class PartialBuilder
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_PARTIALBUILDER_H */
diff --git a/src/loris/PartialList.h b/src/loris/PartialList.h
new file mode 100644
index 0000000..ca91509
--- /dev/null
+++ b/src/loris/PartialList.h
@@ -0,0 +1,61 @@
+#ifndef INCLUDE_PARTIALLIST_H
+#define INCLUDE_PARTIALLIST_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ *	PartialList.h
+ *
+ *	Type definition of Loris::PartialList, which is just a name
+ *	for std::list< Loris::Partial >.
+ *
+ * Kelly Fitz, 6 March 2002
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+ 
+//	Seems like we shouldn't need to include Partial.h, but 
+//	without it, I can't instantiate a PartialList. I need
+//	a definition of Partial for PartialList to be unambiguous.
+#include "Partial.h"
+#include <list>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	class PartialList
+//
+//	PartialList is a typedef for a std::list<> of Loris Partials. The
+//	oscciated bidirectional iterators are also defined as
+//	PartialListIterator and PartialListConstIterator. Since these are
+//	simply typedefs, they classes have identical interfaces to std::list,
+//	std::list::iterator, and std::list::const_iterator, respectively.
+//
+typedef std::list< Loris::Partial > PartialList;
+typedef std::list< Loris::Partial >::iterator PartialListIterator;
+typedef std::list< Loris::Partial >::const_iterator PartialListConstIterator;
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_PARTIALLIST_H */
diff --git a/src/loris/PartialPtrs.h b/src/loris/PartialPtrs.h
new file mode 100644
index 0000000..a773aec
--- /dev/null
+++ b/src/loris/PartialPtrs.h
@@ -0,0 +1,106 @@
+#ifndef INCLUDE_PARTIALPTRS_H
+#define INCLUDE_PARTIALPTRS_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ *	PartialPtrs.h
+ *
+ *	Type definition of Loris::PartialPtrs.
+ *
+ *	PartialPtrs is a collection of pointers to Partials that
+ *	can be used (among other things) for algorithms that operate
+ *	on a range of Partials, but don't rely on access to their
+ *	container.
+ *
+ * Kelly Fitz, 23 May 2002
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "Partial.h"
+#include <iterator>
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+
+// ---------------------------------------------------------------------------
+//	class PartialPtrs
+//
+//	PartialPtrs is a typedef for a std::vectror<> of pointers to Loris
+//	Partials. The oscciated bidirectional iterators are also defined as
+//	PartialPtrsIterator and PartialPtrsConstIterator. Since these are
+//	simply typedefs, they classes have identical interfaces to
+//	std::vector, std::vector::iterator, and std::vector::const_iterator,
+//	respectively.
+//	
+//	PartialPtrs is a collection of pointers to Partials that can be used
+//	(among other things) for algorithms that operate on a range of
+//	Partials, but don't rely on access to their container. A template
+//	function defined in a header file can convert a range of Partials to a
+//	PartialPtrs using the template free function fillPartialPtrs() (see
+//	below), and pass the latter to the algorithm implementation, thereby
+//	generalizing access to the algorithm across containers without
+//	exposing the implementation in the header file.
+//
+typedef std::vector< Partial * > PartialPtrs;
+typedef std::vector< Partial * >::iterator PartialPtrsIterator;
+typedef std::vector< Partial * >::const_iterator PartialPtrsConstIterator;
+
+typedef std::vector< const Partial * > ConstPartialPtrs;
+typedef std::vector< const Partial * >::iterator ConstPartialPtrsIterator;
+typedef std::vector< const Partial * >::const_iterator ConstPartialPtrsConstIterator;
+
+
+// ---------------------------------------------------------------------------
+//	fillPartialPtrs
+// ---------------------------------------------------------------------------
+//	Fill the specified PartialPtrs with pointers to the Partials n the
+//	specified half-open (STL-style) range. This is a generally useful
+//	operation that can be used to adapt algorithms to work with arbitrary
+//	containers of Partials without exposing the algorithms themselves in
+//	the header files.
+//
+template <typename Iter>
+void fillPartialPtrs( Iter begin, Iter end, PartialPtrs & fillme )
+{
+	fillme.reserve( std::distance( begin, end ) );
+	fillme.clear();
+	while ( begin != end )
+		fillme.push_back( &(*begin++) );
+}
+
+template <typename Iter>
+void fillPartialPtrs( Iter begin, Iter end, ConstPartialPtrs & fillme )
+{
+	fillme.reserve( std::distance( begin, end ) );
+	fillme.clear();
+	while ( begin != end )
+		fillme.push_back( &(*begin++) );
+}
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_PARTIALPTRS_H */
diff --git a/src/loris/PartialUtils.C b/src/loris/PartialUtils.C
new file mode 100644
index 0000000..6152e09
--- /dev/null
+++ b/src/loris/PartialUtils.C
@@ -0,0 +1,603 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * PartialUtils.C
+ *
+ *	A group of Partial utility function objects for use with STL 
+ *	searching and sorting algorithms. PartialUtils is a namespace
+ *	within the Loris namespace.
+ *
+ * Kelly Fitz, 17 June 2003
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "PartialUtils.h"
+
+#include "Breakpoint.h"
+#include "BreakpointEnvelope.h"
+#include "BreakpointUtils.h"
+#include "Envelope.h"
+#include "Partial.h"
+
+#include "phasefix.h"
+
+#include <algorithm>
+#include <cmath>
+#include <functional>
+#include <utility>
+
+//	begin namespace
+namespace Loris {
+
+namespace PartialUtils {
+
+
+// -- base class --
+
+// ---------------------------------------------------------------------------
+//	PartialMutator constructor from double
+// ---------------------------------------------------------------------------
+PartialMutator::PartialMutator( double x ) : 
+	env( new BreakpointEnvelope( x ) ) 
+{
+}
+	
+// ---------------------------------------------------------------------------
+//	PartialMutator constructor from envelope
+// ---------------------------------------------------------------------------
+PartialMutator::PartialMutator( const Envelope & e ) : 
+	env( e.clone() ) 
+{
+}
+
+// ---------------------------------------------------------------------------
+//	PartialMutator copy constructor
+// ---------------------------------------------------------------------------
+PartialMutator::PartialMutator( const PartialMutator & rhs ) : 
+	env( rhs.env->clone() ) 
+{
+}
+
+// ---------------------------------------------------------------------------
+//	PartialMutator destructor
+// ---------------------------------------------------------------------------
+PartialMutator::~PartialMutator( void )
+{
+	delete env;
+}
+
+// ---------------------------------------------------------------------------
+//	PartialMutator assignment operator
+// ---------------------------------------------------------------------------
+PartialMutator &
+PartialMutator::operator=( const PartialMutator & rhs )
+{
+	if ( this != &rhs )
+	{	
+		delete env;
+		env = rhs.env->clone();
+	}
+	return *this;
+}
+	
+// -- amplitude scaling --
+	
+// ---------------------------------------------------------------------------
+//	AmplitudeScaler function call operator
+// ---------------------------------------------------------------------------
+//	Scale the amplitude of the specified Partial according to
+//	an envelope representing a time-varying amplitude scale value.
+//
+void 
+AmplitudeScaler::operator()( Partial & p ) const
+{
+	for ( Partial::iterator pos = p.begin(); pos != p.end(); ++pos ) 
+	{		
+		pos.breakpoint().setAmplitude( pos.breakpoint().amplitude() * 
+									          env->valueAt( pos.time() ) );
+	}	
+}
+
+// ---------------------------------------------------------------------------
+//	BandwidthScaler function call operator
+// ---------------------------------------------------------------------------
+//	Scale the bandwidth of the specified Partial according to
+//	an envelope representing a time-varying bandwidth scale value.
+//
+void 
+BandwidthScaler::operator()( Partial & p ) const
+{
+	for ( Partial::iterator pos = p.begin(); pos != p.end(); ++pos ) 
+	{		
+		pos.breakpoint().setBandwidth( pos.breakpoint().bandwidth() * 
+									   env->valueAt( pos.time() ) );
+	}	
+}
+
+// ---------------------------------------------------------------------------
+//	BandwidthSetter function call operator
+// ---------------------------------------------------------------------------
+//	Set the bandwidth of the specified Partial according to
+//	an envelope representing a time-varying bandwidth value.
+//
+void 
+BandwidthSetter::operator()( Partial & p ) const
+{
+	for ( Partial::iterator pos = p.begin(); pos != p.end(); ++pos ) 
+	{		
+		pos.breakpoint().setBandwidth( env->valueAt( pos.time() ) );
+	}	
+}
+
+// ---------------------------------------------------------------------------
+//	FrequencyScaler function call operator
+// ---------------------------------------------------------------------------
+//	Scale the frequency of the specified Partial according to
+//	an envelope representing a time-varying frequency scale value.
+//
+void 
+FrequencyScaler::operator()( Partial & p ) const
+{
+	for ( Partial::iterator pos = p.begin(); pos != p.end(); ++pos ) 
+	{		
+		pos.breakpoint().setFrequency( pos.breakpoint().frequency() * 
+									   env->valueAt( pos.time() ) );
+	}	
+}
+
+// ---------------------------------------------------------------------------
+//	NoiseRatioScaler function call operator
+// ---------------------------------------------------------------------------
+//	Scale the relative noise content of the specified Partial according 
+//	to an envelope representing a (time-varying) noise energy 
+//	scale value.
+//
+void 
+NoiseRatioScaler::operator()( Partial & p ) const
+{
+	for ( Partial::iterator pos = p.begin(); pos != p.end(); ++pos ) 
+	{		
+		//	compute new bandwidth value:
+		double bw = pos.breakpoint().bandwidth();
+		if ( bw < 1. ) 
+		{
+			double ratio = bw  / (1. - bw);
+			ratio *= env->valueAt( pos.time() );
+			bw = ratio / ( 1. + ratio );
+		}
+		else 
+		{
+			bw = 1.;
+		}		
+		pos.breakpoint().setBandwidth( bw );
+	}	
+}
+
+// ---------------------------------------------------------------------------
+//	PitchShifter function call operator
+// ---------------------------------------------------------------------------
+//	Shift the pitch of the specified Partial according to 
+//	the given pitch envelope. The pitch envelope is assumed to have 
+//	units of cents (1/100 of a halfstep).
+//
+void 
+PitchShifter::operator()( Partial & p ) const
+{
+	for ( Partial::iterator pos = p.begin(); pos != p.end(); ++pos ) 
+	{		
+		//	compute frequency scale:
+		double scale = 
+			std::pow( 2., ( 0.01 * env->valueAt( pos.time() ) ) / 12. );				
+		pos.breakpoint().setFrequency( pos.breakpoint().frequency() * scale );
+	}	
+}
+
+// ---------------------------------------------------------------------------
+//	Cropper function call operator
+// ---------------------------------------------------------------------------
+//	Trim a Partial by removing Breakpoints outside a specified time span.
+//	Insert a Breakpoint at the boundary when cropping occurs.
+//
+void 
+Cropper::operator()( Partial & p ) const
+{
+	//	crop beginning of Partial
+	Partial::iterator it = p.findAfter( minTime );
+	if ( it != p.begin() )    // Partial begins earlier than minTime
+	{
+	    if ( it != p.end() ) // Partial ends later than minTime
+	    {
+            Breakpoint bp = p.parametersAt( minTime );
+            it = p.insert( minTime, bp );
+        }
+		it = p.erase( p.begin(), it );
+	}
+	
+	//	crop end of Partial
+	it = p.findAfter( maxTime );
+	if ( it != p.end() ) // Partial ends later than maxTime
+	{
+	    if ( it != p.begin() )   // Partial begins earlier than maxTime
+	    {
+	    	Breakpoint bp = p.parametersAt( maxTime );
+    		it = p.insert( maxTime, bp );
+    		++it;   //  advance, we don't want to cut this one off
+		}
+		it = p.erase( it, p.end() );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	TimeShifter function call operator
+// ---------------------------------------------------------------------------
+//	Shift the time of all the Breakpoints in a Partial by a constant amount.
+//
+void 
+TimeShifter::operator()( Partial & p ) const
+{
+	//	Since the Breakpoint times are immutable, the only way to 
+	//	shift the Partial in time is to construct a new Partial and
+	//	assign it to the argument p.
+	Partial result;
+	result.setLabel( p.label() );
+	
+	for ( Partial::iterator pos = p.begin(); pos != p.end(); ++pos ) 
+	{		
+		result.insert( pos.time() + offset, pos.breakpoint() );
+	}	
+	p = result;
+}
+
+// ---------------------------------------------------------------------------
+//	peakAmplitude
+// ---------------------------------------------------------------------------
+//! Return the maximum amplitude achieved by a partial. 
+//!  
+//! \param  p is the Partial to evaluate
+//! \return the maximum (absolute) amplitude achieved by 
+//!         the partial p
+//
+double peakAmplitude( const Partial & p )
+{
+    double peak = 0;
+    for ( Partial::const_iterator it = p.begin();
+          it != p.end();
+          ++it )
+    {
+        peak = std::max( peak, it->amplitude() );
+    }
+    return peak;
+}
+
+// ---------------------------------------------------------------------------
+//	avgAmplitude
+// ---------------------------------------------------------------------------
+//! Return the average amplitude over all Breakpoints in this Partial.
+//! Return zero if the Partial has no Breakpoints.
+//!  
+//! \param  p is the Partial to evaluate
+//! \return the average amplitude of Breakpoints in the Partial p
+//
+double avgAmplitude( const Partial & p )
+{
+    double avg = 0;
+    for ( Partial::const_iterator it = p.begin();
+          it != p.end();
+          ++it )
+    {
+        avg += it->amplitude();
+    }
+    
+    if ( avg != 0 )
+    {
+        avg /= p.numBreakpoints();
+    }
+    
+    return avg;
+}
+
+
+// ---------------------------------------------------------------------------
+//	avgFrequency
+// ---------------------------------------------------------------------------
+//! Return the average frequency over all Breakpoints in this Partial.
+//! Return zero if the Partial has no Breakpoints.
+//!  
+//! \param  p is the Partial to evaluate
+//! \return the average frequency (Hz) of Breakpoints in the Partial p
+//
+double avgFrequency( const Partial & p )
+{
+    double avg = 0;
+    for ( Partial::const_iterator it = p.begin();
+          it != p.end();
+          ++it )
+    {
+        avg += it->frequency();
+    }
+    
+    if ( avg != 0 )
+    {
+        avg /= p.numBreakpoints();
+    }
+    
+    return avg;
+}
+
+
+// ---------------------------------------------------------------------------
+//	weightedAvgFrequency
+// ---------------------------------------------------------------------------
+//! Return the average frequency over all Breakpoints in this Partial, 
+//! weighted by the Breakpoint amplitudes.
+//! Return zero if the Partial has no Breakpoints.
+//!  
+//! \param  p is the Partial to evaluate
+//! \return the average frequency (Hz) of Breakpoints in the Partial p
+//
+double weightedAvgFrequency( const Partial & p )
+{
+    double avg = 0;
+    double ampsum = 0;
+    for ( Partial::const_iterator it = p.begin();
+          it != p.end();
+          ++it )
+    {
+        avg += it->amplitude() * it->frequency();
+        ampsum += it->amplitude();
+    }
+    
+    if ( avg != 0 && ampsum != 0 )
+    {
+        avg /= ampsum;
+    }
+    else
+    {
+        avg = 0;
+    }
+    
+    return avg;
+}
+
+//	-- phase maintenance functions --
+
+// ---------------------------------------------------------------------------
+//	fixPhaseBefore
+//
+//! Recompute phases of all Breakpoints earlier than the specified time 
+//! so that the synthesize phases of those earlier Breakpoints matches 
+//! the stored phase, and the synthesized phase at the specified
+//! time matches the stored (not recomputed) phase.
+//! 
+//! Backward phase-fixing stops if a null (zero-amplitude) Breakpoint
+//! is encountered, because nulls are interpreted as phase reset points
+//! in Loris. If a null is encountered, the remainder of the Partial
+//! (the front part) is fixed in the forward direction, beginning at
+//! the start of the Partial.
+//!
+//! \param p    The Partial whose phases should be fixed.
+//! \param t    The time before which phases should be adjusted.
+//
+void fixPhaseBefore( Partial & p, double t )
+{
+    if ( 1 < p.numBreakpoints() )
+    {
+        Partial::iterator pos = p.findNearest( t );
+        Assert( pos != p.end() );
+
+        fixPhaseBackward( p.begin(), pos );
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	fixPhaseAfter
+//
+//! Recompute phases of all Breakpoints later than the specified time 
+//! so that the synthesize phases of those later Breakpoints matches 
+//! the stored phase, as long as the synthesized phase at the specified
+//! time matches the stored (not recomputed) phase.
+//! 
+//! Phase fixing is only applied to non-null (nonzero-amplitude) Breakpoints,
+//! because null Breakpoints are interpreted as phase reset points in 
+//! Loris. If a null is encountered, its phase is simply left unmodified,
+//! and future phases wil be recomputed from that one.
+//!
+//! \param p    The Partial whose phases should be fixed.
+//! \param t    The time after which phases should be adjusted.
+//
+void fixPhaseAfter( Partial & p, double t )
+{
+    //  nothing to do it there are not at least
+    //  two Breakpoints in the Partial   
+    if ( 1 < p.numBreakpoints() )
+    {
+        Partial::iterator pos = p.findNearest( t );
+        Assert( pos != p.end() );
+
+        fixPhaseForward( pos, --p.end() );
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	fixPhaseForward
+//
+//! Recompute phases of all Breakpoints later than the specified time 
+//! so that the synthesize phases of those later Breakpoints matches 
+//! the stored phase, as long as the synthesized phase at the specified
+//! time matches the stored (not recomputed) phase. Breakpoints later than
+//! tend are unmodified.
+//! 
+//! Phase fixing is only applied to non-null (nonzero-amplitude) Breakpoints,
+//! because null Breakpoints are interpreted as phase reset points in 
+//! Loris. If a null is encountered, its phase is simply left unmodified,
+//! and future phases wil be recomputed from that one.
+//!
+//! HEY Is this interesting, in general? Why would you want to do this?
+//!
+//! \param p    The Partial whose phases should be fixed.
+//! \param tbeg The phases and frequencies of Breakpoints later than the 
+//!             one nearest this time will be modified.
+//! \param tend The phases and frequencies of Breakpoints earlier than the 
+//!             one nearest this time will be modified. Should be greater 
+//!             than tbeg, or else they will be swapped.
+//
+void fixPhaseForward( Partial & p, double tbeg, double tend )
+{
+    if ( tbeg > tend )
+    {
+        std::swap( tbeg, tend );
+    }
+    
+    //  nothing to do it there are not at least
+    //  two Breakpoints in the Partial   
+    if ( 1 < p.numBreakpoints() )
+    {
+        //  find the positions nearest tbeg and tend
+        Partial::iterator posbeg = p.findNearest( tbeg );
+        Partial::iterator posend = p.findNearest( tend );
+        
+        //  if the positions are different, and tend is
+        //  the end, back it up
+        if ( posbeg != posend && posend == p.end() )
+        {
+            --posend;
+        }
+        fixPhaseForward( posbeg, posend );
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	fixPhaseAt
+//
+//! Recompute phases of all Breakpoints in a Partial
+//! so that the synthesize phases match the stored phases, 
+//! and the synthesized phase at (nearest) the specified
+//! time matches the stored (not recomputed) phase.
+//! 
+//! Backward phase-fixing stops if a null (zero-amplitude) Breakpoint
+//! is encountered, because nulls are interpreted as phase reset points
+//! in Loris. If a null is encountered, the remainder of the Partial
+//! (the front part) is fixed in the forward direction, beginning at
+//! the start of the Partial. Forward phase fixing is only applied 
+//! to non-null (nonzero-amplitude) Breakpoints. If a null is encountered, 
+//! its phase is simply left unmodified, and future phases wil be 
+//! recomputed from that one.
+//!
+//! \param p    The Partial whose phases should be fixed.
+//! \param t    The time at which phases should be made correct.
+//
+void fixPhaseAt( Partial & p, double t )
+{
+    if ( 1 < p.numBreakpoints() )
+    {
+        Partial::iterator pos = p.findNearest( t );
+        Assert( pos != p.end() );
+
+        fixPhaseForward( pos, --p.end() );
+        fixPhaseBackward( p.begin(), pos );
+    }
+}
+
+// ---------------------------------------------------------------------------
+//  fixPhaseBetween
+//
+//!	Fix the phase travel between two times by adjusting the
+//!	frequency and phase of Breakpoints between those two times.
+//!
+//!	This algorithm assumes that there is nothing interesting about the
+//!	phases of the intervening Breakpoints, and modifies their frequencies 
+//!	as little as possible to achieve the correct amount of phase travel 
+//!	such that the frequencies and phases at the specified times
+//!	match the stored values. The phases of all the Breakpoints between 
+//! the specified times are recomputed.
+//!
+//! THIS DOES NOT YET TREAT NULL BREAKPOINTS DIFFERENTLY FROM OTHERS.
+//!
+//! \pre        There must be at least one Breakpoint in the
+//!             Partial between the specified times tbeg and tend.
+//! \post       The phases and frequencies of the Breakpoints in the 
+//!             range have been recomputed such that an oscillator
+//!             initialized to the parameters of the first Breakpoint
+//!             will arrive at the parameters of the last Breakpoint,
+//!             and all the intervening Breakpoints will be matched.
+//!	\param p    The partial whose phases and frequencies will be recomputed. 
+//!             The Breakpoint at this position is unaltered.
+//! \param tbeg The phases and frequencies of Breakpoints later than the 
+//!             one nearest this time will be modified.
+//! \param tend The phases and frequencies of Breakpoints earlier than the 
+//!             one nearest this time will be modified. Should be greater 
+//!             than tbeg, or else they will be swapped.
+//
+void fixPhaseBetween( Partial & p, double tbeg, double tend )
+{
+    if ( tbeg > tend )
+    {
+        std::swap( tbeg, tend );
+    }
+
+    // for Partials that do not extend over the entire
+    // specified time range, just recompute phases from
+    // beginning or end of the range:
+    if ( p.endTime() < tend )
+    {
+        // OK if start time is also after tbeg, will
+        // just recompute phases from start of p.
+        fixPhaseAfter( p, tbeg );
+    }
+    else if ( p.startTime() > tbeg )
+    {
+        fixPhaseBefore( p, tend );
+    }
+    else
+    {
+        // invariant:
+        // p begins before tbeg and ends after tend.
+        Partial::iterator b = p.findNearest( tbeg );
+        Partial::iterator e = p.findNearest( tend );
+
+        // if there is a null Breakpoint n between b and e, then
+        // should fix forward from b to n, and backward from
+        // e to n. Otherwise, do this complicated thing.
+        Partial::iterator nullbp = std::find_if( b, e, BreakpointUtils::isNull );
+        if ( nullbp != e )
+        {
+            fixPhaseForward( b, nullbp );
+            fixPhaseBackward( nullbp, e );
+        }
+        else
+        {
+            fixPhaseBetween( b, e );
+        }
+    }
+}
+
+}	//	end of namespace PartialUtils
+
+}	//	end of namespace Loris
+
diff --git a/src/loris/PartialUtils.h b/src/loris/PartialUtils.h
new file mode 100644
index 0000000..afc6895
--- /dev/null
+++ b/src/loris/PartialUtils.h
@@ -0,0 +1,1189 @@
+#ifndef INCLUDE_PARTIALUTILS_H
+#define INCLUDE_PARTIALUTILS_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * PartialUtils.h
+ *
+ *	A group of Partial utility function objects for use with STL 
+ *	searching and sorting algorithms. PartialUtils is a namespace
+ *	within the Loris namespace.
+ *
+ * This file defines three kinds of functors:
+ * - Partial mutators
+ * - predicates on Partials
+ * - Partial comparitors
+ *
+ * Kelly Fitz, 6 July 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "Envelope.h"
+#include "Partial.h"
+
+#include <functional>
+#include <utility>
+
+//	begin namespace
+namespace Loris {
+
+namespace PartialUtils {
+
+//	-- Partial mutating functors --
+
+// ---------------------------------------------------------------------------
+//	PartialMutator
+//	
+//! PartialMutator is an abstract base class for Partial mutators,
+//! functors that operate on Partials according to a time-varying
+//! envelope. The base class manages a polymorphic Envelope instance
+//! that provides the time-varying mutation parameters.
+//!
+//! \invariant	env is a non-zero pointer to a valid instance of a 
+//!            class derived from the abstract class Envelope.
+class PartialMutator : public std::unary_function< Partial, void >
+{
+public:
+
+	//! Construct a new PartialMutator from a constant mutation factor.
+	PartialMutator( double x );
+
+	//! Construct a new PartialMutator from an Envelope representing
+	//! a time-varying mutation factor.
+	PartialMutator( const Envelope & e );
+
+	//! Construct a new PartialMutator that is a copy of another.
+	PartialMutator( const PartialMutator & rhs );
+
+	//! Destroy this PartialMutator, deleting its Envelope.
+	virtual ~PartialMutator( void );
+	
+	//! Make this PartialMutator a duplicate of another one.
+	//!
+	//! \param	rhs is the PartialMutator to copy.
+	PartialMutator & operator=( const PartialMutator & rhs );
+	
+	//! Function call operator: apply a mutation factor to the 
+	//! specified Partial. Derived classes must implement this 
+	//! member.
+	virtual void operator()( Partial & p ) const = 0;
+
+protected:
+
+	//! pointer to an envelope that governs the 
+	//! time-varying mutation
+	Envelope * env;		
+};
+
+// ---------------------------------------------------------------------------
+//	AmplitudeScaler
+//	
+//! Scale the amplitude of the specified Partial according to
+//! an envelope representing a time-varying amplitude scale value.
+//
+class AmplitudeScaler : public PartialMutator
+{
+public:
+
+	//! Construct a new AmplitudeScaler from a constant scale factor.
+	AmplitudeScaler( double x ) : PartialMutator( x ) {}
+	
+	//! Construct a new AmplitudeScaler from an Envelope representing
+	//! a time-varying scale factor.
+	AmplitudeScaler( const Envelope & e ) : PartialMutator( e ) {}
+	
+	//! Function call operator: apply a scale factor to the specified
+	//! Partial.
+	void operator()( Partial & p ) const;
+};
+
+// ---------------------------------------------------------------------------
+//	scaleAmplitude
+// ---------------------------------------------------------------------------
+//! Scale the amplitude of the specified Partial according to
+//! an envelope representing a amplitude scale value or envelope.
+//!
+//! \param	p is a Partial to mutate.
+//! \param	arg is either a constant scale factor or an Envelope
+//!			describing the time-varying scale factor.
+//
+template< class Arg >
+void scaleAmplitude( Partial & p, const Arg & arg )
+{
+	AmplitudeScaler scaler( arg );
+	scaler( p );
+}
+
+// ---------------------------------------------------------------------------
+//	scaleAmplitude
+// ---------------------------------------------------------------------------
+//! Scale the amplitude of a sequence of Partials according to
+//! an envelope representing a amplitude scale value or envelope.
+//!
+//! \param	b is the beginning of a sequence of Partials to mutate.
+//! \param	e is the end of a sequence of Partials to mutate.
+//! \param	arg is either a constant scale factor or an Envelope
+//!			describing the time-varying scale factor.
+//
+template< class Iter, class Arg >
+void scaleAmplitude( Iter b, Iter e, const Arg & arg )
+{
+	AmplitudeScaler scaler( arg );
+	while ( b != e )
+	{
+		scaler( *b++ );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	BandwidthScaler
+//	
+//! Scale the bandwidth of the specified Partial according to
+//! an envelope representing a time-varying bandwidth scale value.
+//
+class BandwidthScaler : public PartialMutator
+{
+public:
+
+	//! Construct a new BandwidthScaler from a constant scale factor.
+	BandwidthScaler( double x ) : PartialMutator( x ) {}
+
+	//! Construct a new BandwidthScaler from an Envelope representing
+	//! a time-varying scale factor.
+	BandwidthScaler( const Envelope & e ) : PartialMutator( e ) {}
+	
+	//! Function call operator: apply a scale factor to the specified
+	//! Partial.
+	void operator()( Partial & p ) const;
+};
+
+// ---------------------------------------------------------------------------
+//	scaleBandwidth
+// ---------------------------------------------------------------------------
+//! Scale the bandwidth of the specified Partial according to
+//! an envelope representing a amplitude scale value or envelope.
+//!
+//! \param	p is a Partial to mutate.
+//! \param	arg is either a constant scale factor or an Envelope
+//!			describing the time-varying scale factor.
+//
+template< class Arg >
+void scaleBandwidth( Partial & p, const Arg & arg )
+{
+	BandwidthScaler scaler( arg );
+	scaler( p );
+}
+
+// ---------------------------------------------------------------------------
+//	scaleBandwidth
+// ---------------------------------------------------------------------------
+//! Scale the bandwidth of a sequence of Partials according to
+//! an envelope representing a bandwidth scale value or envelope.
+//!
+//! \param	b is the beginning of a sequence of Partials to mutate.
+//! \param	e is the end of a sequence of Partials to mutate.
+//! \param	arg is either a constant scale factor or an Envelope
+//!			describing the time-varying scale factor.
+//
+template< class Iter, class Arg >
+void scaleBandwidth( Iter b, Iter e, const Arg & arg )
+{
+	BandwidthScaler scaler( arg );
+	while ( b != e )
+	{
+		scaler( *b++ );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	BandwidthSetter
+//	
+//! Set the bandwidth of the specified Partial according to
+//! an envelope representing a time-varying bandwidth value.
+//
+class BandwidthSetter : public PartialMutator
+{
+public:
+
+	//! Construct a new BandwidthSetter from a constant bw factor.
+	BandwidthSetter( double x ) : PartialMutator( x ) {}
+
+	//! Construct a new BandwidthSetter from an Envelope representing
+	//! a time-varying bw factor.
+	BandwidthSetter( const Envelope & e ) : PartialMutator( e ) {}
+	
+	//! Function call operator: assign a bw factor to the specified
+	//! Partial.
+	void operator()( Partial & p ) const;
+};
+
+// ---------------------------------------------------------------------------
+//	setBandwidth
+// ---------------------------------------------------------------------------
+//! Set the bandwidth of the specified Partial according to
+//! an envelope representing a amplitude scale value or envelope.
+//!
+//! \param	p is a Partial to mutate.
+//! \param	arg is either a constant scale factor or an Envelope
+//!			describing the time-varying bw factor.
+//
+template< class Arg >
+void setBandwidth( Partial & p, const Arg & arg )
+{
+	BandwidthSetter setter( arg );
+	setter( p );
+}
+
+// ---------------------------------------------------------------------------
+//	setBandwidth
+// ---------------------------------------------------------------------------
+//! Set the bandwidth of a sequence of Partials according to
+//! an envelope representing a bandwidth value or envelope.
+//!
+//! \param	b is the beginning of a sequence of Partials to mutate.
+//! \param	e is the end of a sequence of Partials to mutate.
+//! \param	arg is either a constant scale factor or an Envelope
+//!			describing the time-varying scale factor.
+//
+template< class Iter, class Arg >
+void setBandwidth( Iter b, Iter e, const Arg & arg )
+{
+	BandwidthSetter setter( arg );
+	while ( b != e )
+	{
+		setter( *b++ );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	FrequencyScaler
+//	
+//! Scale the frequency of the specified Partial according to
+//! an envelope representing a time-varying bandwidth scale value.
+//
+class FrequencyScaler : public PartialMutator
+{
+public:
+
+	//! Construct a new FrequencyScaler from a constant scale factor.
+	FrequencyScaler( double x ) : PartialMutator( x ) {}
+	
+   //! Construct a new FrequencyScaler from an Envelope representing
+	//! a time-varying scale factor.
+	FrequencyScaler( const Envelope & e ) : PartialMutator( e ) {}
+	
+	//! Function call operator: apply a scale factor to the specified
+	//! Partial.
+	void operator()( Partial & p ) const;
+};
+
+// ---------------------------------------------------------------------------
+//	scaleFrequency
+// ---------------------------------------------------------------------------
+//! Scale the frequency of the specified Partial according to
+//! an envelope representing a frequency scale value or envelope.
+//!
+//! \param	p is a Partial to mutate.
+//! \param	arg is either a constant scale factor or an Envelope
+//!			describing the time-varying scale factor.
+//
+template< class Arg >
+void scaleFrequency( Partial & p, const Arg & arg )
+{
+	FrequencyScaler scaler( arg );
+	scaler( p );
+}
+
+// ---------------------------------------------------------------------------
+//	scaleFrequency
+// ---------------------------------------------------------------------------
+//! Scale the frequency of a sequence of Partials according to
+//! an envelope representing a frequency scale value or envelope.
+//!
+//! \param	b is the beginning of a sequence of Partials to mutate.
+//! \param	e is the end of a sequence of Partials to mutate.
+//! \param	arg is either a constant scale factor or an Envelope
+//!			describing the time-varying scale factor.
+//
+template< class Iter, class Arg >
+void scaleFrequency( Iter b, Iter e, const Arg & arg )
+{
+	FrequencyScaler scaler( arg );
+	while ( b != e )
+	{
+		scaler( *b++ );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	NoiseRatioScaler
+//	
+//! Scale the relative noise content of the specified Partial according 
+//! to an envelope representing a time-varying bandwidth scale value.
+//
+class NoiseRatioScaler : public PartialMutator
+{
+public:
+
+	//! Construct a new NoiseRatioScaler from a constant scale factor.
+	NoiseRatioScaler( double x ) : PartialMutator( x ) {}
+
+	//! Construct a new NoiseRatioScaler from an Envelope representing
+	//! a time-varying scale factor.
+	NoiseRatioScaler( const Envelope & e ) : PartialMutator( e ) {}
+	
+	//! Function call operator: apply a scale factor to the specified
+	//! Partial.
+	void operator()( Partial & p ) const;
+};
+
+// ---------------------------------------------------------------------------
+//	scaleNoiseRatio
+// ---------------------------------------------------------------------------
+//! Scale the relative noise content of the specified Partial according to
+//! an envelope representing a scale value or envelope.
+//!
+//! \param	p is a Partial to mutate.
+//! \param	arg is either a constant scale factor or an Envelope
+//!			describing the time-varying scale factor.
+//
+template< class Arg >
+void scaleNoiseRatio( Partial & p, const Arg & arg )
+{
+	NoiseRatioScaler scaler( arg );
+	scaler( p );
+}
+
+// ---------------------------------------------------------------------------
+//	scaleNoiseRatio
+// ---------------------------------------------------------------------------
+//! Scale the relative noise content of a sequence of Partials according to
+//! an envelope representing a scale value or envelope.
+//!
+//! \param	b is the beginning of a sequence of Partials to mutate.
+//! \param	e is the end of a sequence of Partials to mutate.
+//! \param	arg is either a constant scale factor or an Envelope
+//!			describing the time-varying scale factor.
+//
+template< class Iter, class Arg >
+void scaleNoiseRatio( Iter b, Iter e, const Arg & arg )
+{
+	NoiseRatioScaler scaler( arg );
+	while ( b != e )
+	{
+		scaler( *b++ );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	PitchShifter
+//	
+//! Shift the pitch of the specified Partial according to
+//! the given pitch envelope. The pitch envelope is assumed to have 
+//! units of cents (1/100 of a halfstep).
+//
+class PitchShifter : public PartialMutator
+{
+public:
+
+	//! Construct a new PitchShifter from a constant scale factor.
+	PitchShifter( double x ) : PartialMutator( x ) {}
+
+   //! Construct a new PitchShifter from an Envelope representing
+	//! a time-varying scale factor.
+	PitchShifter( const Envelope & e ) : PartialMutator( e ) {}
+	
+	//! Function call operator: apply a scale factor to the specified
+	//! Partial.
+	void operator()( Partial & p ) const;
+};
+
+// ---------------------------------------------------------------------------
+//	shiftPitch
+// ---------------------------------------------------------------------------
+//! Shift the pitch of the specified Partial according to
+//! an envelope representing a pitch value or envelope.
+//!
+//! \param	p is a Partial to mutate.
+//! \param	arg is either a constant pitch factor or an Envelope
+//!			describing the time-varying pitch factor in cents (1/100 of a 
+//!         halfstep).
+//
+template< class Arg >
+void shiftPitch( Partial & p, const Arg & arg )
+{
+	PitchShifter shifter( arg );
+	shifter( p );
+}
+
+// ---------------------------------------------------------------------------
+//	shiftPitch
+// ---------------------------------------------------------------------------
+//! Shift the pitch of a sequence of Partials according to
+//! an envelope representing a pitch value or envelope.
+//!
+//! \param	b is the beginning of a sequence of Partials to mutate.
+//! \param	e is the end of a sequence of Partials to mutate.
+//! \param	arg is either a constant pitch factor or an Envelope
+//!			describing the time-varying pitch factor in cents (1/100 of a 
+//!         halfstep).
+//
+template< class Iter, class Arg >
+void shiftPitch( Iter b, Iter e, const Arg & arg )
+{
+	PitchShifter shifter( arg );
+	while ( b != e )
+	{
+		shifter( *b++ );
+	}
+}
+
+//	These ones are not derived from PartialMutator, because
+//	they don't use an Envelope and cannot be time-varying.
+
+// ---------------------------------------------------------------------------
+//	Cropper
+//	
+//! Trim a Partial by removing Breakpoints outside a specified time span.
+//!	Insert a Breakpoint at the boundary when cropping occurs.
+class Cropper
+{
+public:
+
+    //! Construct a new Cropper from a pair of times (in seconds)
+    //! representing the span of time to which Partials should be
+    //! cropped.
+	Cropper( double t1, double t2 ) : 
+		minTime( std::min( t1, t2 ) ),
+		maxTime( std::max( t1, t2 ) )
+	{
+	}
+	
+	//! Function call operator: crop the specified Partial.
+    //! Trim a Partial by removing Breakpoints outside the span offset
+    //! [minTime, maxTime]. Insert a Breakpoint at the boundary when 
+    //! cropping occurs.
+	void operator()( Partial & p ) const;
+	
+private:
+	double minTime, maxTime;
+};
+
+// ---------------------------------------------------------------------------
+//	crop
+// ---------------------------------------------------------------------------
+//! Trim a Partial by removing Breakpoints outside a specified time span.
+//! Insert a Breakpoint at the boundary when cropping occurs.
+//! 
+//! This operation may leave the Partial empty, if it previously had
+//! no Breakpoints in the span [t1,t2]. 
+//!
+//! \param	p is the Partial to crop.
+//! \param	t1 is the beginning of the time span to which the Partial
+//!         should be cropped.
+//! \param	t2 is the end of the time span to which the Partial
+//!         should be cropped.
+//
+inline
+void crop( Partial & p, double t1, double t2 )
+{
+	Cropper cropper( t1, t2 );
+	cropper( p );
+}
+
+// ---------------------------------------------------------------------------
+//	crop
+// ---------------------------------------------------------------------------
+//! Trim a sequence of Partials by removing Breakpoints outside a specified 
+//! time span. Insert a Breakpoint at the boundary when cropping occurs.
+//! 
+//! This operation may leave some empty Partials, if they previously had
+//! no Breakpoints in the span [t1,t2]. 
+//!
+//! \param	b is the beginning of a sequence of Partials to crop.
+//! \param	e is the end of a sequence of Partials to crop.
+//! \param	t1 is the beginning of the time span to which the Partials
+//!         should be cropped.
+//! \param	t2 is the end of the time span to which the Partials
+//!         should be cropped.
+//
+template< class Iter >
+void crop( Iter b, Iter e, double t1, double t2 )
+{
+	Cropper cropper( t1, t2 );
+	while ( b != e )
+	{
+		cropper( *b++ );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	TimeShifter
+//	
+//! Shift the time of all the Breakpoints in a Partial by a 
+//! constant amount.
+//
+class TimeShifter
+{
+public:
+
+	//! Construct a new TimeShifter from a constant offset in seconds.
+	TimeShifter( double x ) : offset( x ) {}
+	
+	//! Function call operator: apply a time shift to the specified
+	//! Partial.
+	void operator()( Partial & p ) const;
+	
+private:
+	double offset;
+};
+
+// ---------------------------------------------------------------------------
+//	shiftTime
+// ---------------------------------------------------------------------------
+//! Shift the time of all the Breakpoints in a Partial by a 
+//! constant amount.
+//!
+//! \param	p is a Partial to shift.
+//! \param	offset is a constant offset in seconds.
+//
+inline
+void shiftTime( Partial & p, double offset )
+{
+	TimeShifter shifter( offset );
+	shifter( p );
+}
+
+// ---------------------------------------------------------------------------
+//	shiftTime
+// ---------------------------------------------------------------------------
+//! Shift the time of all the Breakpoints in a Partial by a 
+//! constant amount.
+//!
+//! \param	b is the beginning of a sequence of Partials to shift.
+//! \param	e is the end of a sequence of Partials to shift.
+//! \param	offset is a constant offset in seconds.
+//
+template< class Iter >
+void shiftTime( Iter b, Iter e, double offset )
+{
+	TimeShifter shifter( offset );
+	while ( b != e )
+	{
+		shifter( *b++ );
+	}
+}
+	
+// ---------------------------------------------------------------------------
+//	timeSpan
+// ---------------------------------------------------------------------------
+//! Return the time (in seconds) spanned by a specified half-open
+//! range of Partials as a std::pair composed of the earliest
+//! Partial start time and latest Partial end time in the range.
+//
+template < typename Iterator >
+std::pair< double, double > 
+timeSpan( Iterator begin, Iterator end ) 
+{
+	double tmin = 0., tmax = 0.;
+	if ( begin != end )
+	{
+		Iterator it = begin;
+		tmin = it->startTime();
+		tmax = it->endTime();
+		while( it != end )
+		{
+			tmin = std::min( tmin, it->startTime() );
+			tmax = std::max( tmax, it->endTime() );
+			++it;
+		}
+	}
+	return std::make_pair( tmin, tmax );
+}
+
+// ---------------------------------------------------------------------------
+//	peakAmplitude
+// ---------------------------------------------------------------------------
+//! Return the maximum amplitude achieved by a Partial. 
+//!  
+//! \param  p is the Partial to evaluate
+//! \return the maximum (absolute) amplitude achieved by 
+//!         the partial p
+//
+double peakAmplitude( const Partial & p );
+
+// ---------------------------------------------------------------------------
+//	avgAmplitude
+// ---------------------------------------------------------------------------
+//! Return the average amplitude over all Breakpoints in this Partial.
+//! Return zero if the Partial has no Breakpoints.
+//!  
+//! \param  p is the Partial to evaluate
+//! \return the average amplitude of Breakpoints in the Partial p
+//
+double avgAmplitude( const Partial & p );
+
+// ---------------------------------------------------------------------------
+//	avgFrequency
+// ---------------------------------------------------------------------------
+//! Return the average frequency over all Breakpoints in this Partial.
+//! Return zero if the Partial has no Breakpoints.
+//!  
+//! \param  p is the Partial to evaluate
+//! \return the average frequency (Hz) of Breakpoints in the Partial p
+//
+double avgFrequency( const Partial & p );
+
+// ---------------------------------------------------------------------------
+//	weightedAvgFrequency
+// ---------------------------------------------------------------------------
+//! Return the average frequency over all Breakpoints in this Partial, 
+//! weighted by the Breakpoint amplitudes.
+//! Return zero if the Partial has no Breakpoints.
+//!  
+//! \param  p is the Partial to evaluate
+//! \return the average frequency (Hz) of Breakpoints in the Partial p
+//
+double weightedAvgFrequency( const Partial & p );
+
+//	-- phase maintenance functions --
+
+// ---------------------------------------------------------------------------
+//	fixPhaseBefore
+// ---------------------------------------------------------------------------
+//! Recompute phases of all Breakpoints earlier than the specified time 
+//! so that the synthesized phases of those earlier Breakpoints matches 
+//! the stored phase, and the synthesized phase at the specified
+//! time matches the stored (not recomputed) phase.
+//! 
+//! Backward phase-fixing stops if a null (zero-amplitude) Breakpoint
+//! is encountered, because nulls are interpreted as phase reset points
+//! in Loris. If a null is encountered, the remainder of the Partial
+//! (the front part) is fixed in the forward direction, beginning at
+//! the start of the Partial.
+//!
+//! \param p    The Partial whose phases should be fixed.
+//! \param t    The time before which phases should be adjusted.
+//
+void fixPhaseBefore( Partial & p, double t );
+
+// ---------------------------------------------------------------------------
+//	fixPhaseBefore (range)
+// ---------------------------------------------------------------------------
+//! Recompute phases of all Breakpoints earlier than the specified time 
+//! so that the synthesized phases of those earlier Breakpoints matches 
+//! the stored phase, and the synthesized phase at the specified
+//! time matches the stored (not recomputed) phase.
+//! 
+//! Backward phase-fixing stops if a null (zero-amplitude) Breakpoint
+//! is encountered, because nulls are interpreted as phase reset points
+//! in Loris. If a null is encountered, the remainder of the Partial
+//! (the front part) is fixed in the forward direction, beginning at
+//! the start of the Partial.
+//!
+//! \param b    The beginning of a range of Partials whose phases 
+//!             should be fixed.
+//! \param e    The end of a range of Partials whose phases 
+//!             should be fixed.
+//! \param t    The time before which phases should be adjusted.
+//
+template < class Iter >
+void fixPhaseBefore( Iter b, Iter e, double t )
+{
+    while ( b != e )
+    {
+        fixPhaseBefore( *b, t );
+        ++b;
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	fixPhaseAfter
+// ---------------------------------------------------------------------------
+//! Recompute phases of all Breakpoints later than the specified time 
+//! so that the synthesized phases of those later Breakpoints matches 
+//! the stored phase, as long as the synthesized phase at the specified
+//! time matches the stored (not recomputed) phase.
+//! 
+//! Phase fixing is only applied to non-null (nonzero-amplitude) Breakpoints,
+//! because null Breakpoints are interpreted as phase reset points in 
+//! Loris. If a null is encountered, its phase is simply left unmodified,
+//! and future phases wil be recomputed from that one.
+//!
+//! \param p    The Partial whose phases should be fixed.
+//! \param t    The time after which phases should be adjusted.
+//
+void fixPhaseAfter( Partial & p, double t );
+
+// ---------------------------------------------------------------------------
+//	fixPhaseAfter (range)
+// ---------------------------------------------------------------------------
+//! Recompute phases of all Breakpoints later than the specified time 
+//! so that the synthesized phases of those later Breakpoints matches 
+//! the stored phase, as long as the synthesized phase at the specified
+//! time matches the stored (not recomputed) phase.
+//! 
+//! Phase fixing is only applied to non-null (nonzero-amplitude) Breakpoints,
+//! because null Breakpoints are interpreted as phase reset points in 
+//! Loris. If a null is encountered, its phase is simply left unmodified,
+//! and future phases wil be recomputed from that one.
+//!
+//! \param b    The beginning of a range of Partials whose phases 
+//!             should be fixed.
+//! \param e    The end of a range of Partials whose phases 
+//!             should be fixed.
+//! \param t    The time after which phases should be adjusted.
+//
+template < class Iter >
+void fixPhaseAfter( Iter b, Iter e, double t )
+{
+    while ( b != e )
+    {
+        fixPhaseAfter( *b, t );
+        ++b;
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	fixPhaseForward
+// ---------------------------------------------------------------------------
+//! Recompute phases of all Breakpoints later than the specified time 
+//! so that the synthesize phases of those later Breakpoints matches 
+//! the stored phase, as long as the synthesized phase at the specified
+//! time matches the stored (not recomputed) phase. Breakpoints later than
+//! tend are unmodified.
+//! 
+//! Phase fixing is only applied to non-null (nonzero-amplitude) Breakpoints,
+//! because null Breakpoints are interpreted as phase reset points in 
+//! Loris. If a null is encountered, its phase is simply left unmodified,
+//! and future phases wil be recomputed from that one.
+//!
+//! \param p    The Partial whose phases should be fixed.
+//! \param tbeg The phases and frequencies of Breakpoints later than the 
+//!             one nearest this time will be modified.
+//! \param tend The phases and frequencies of Breakpoints earlier than the 
+//!             one nearest this time will be modified. Should be greater 
+//!             than tbeg, or else they will be swapped.
+//
+void fixPhaseForward( Partial & p, double tbeg, double tend );
+
+// ---------------------------------------------------------------------------
+//	fixPhaseForward (range)
+// ---------------------------------------------------------------------------
+//! Recompute phases of all Breakpoints later than the specified time 
+//! so that the synthesize phases of those later Breakpoints matches 
+//! the stored phase, as long as the synthesized phase at the specified
+//! time matches the stored (not recomputed) phase.
+//! 
+//! Phase fixing is only applied to non-null (nonzero-amplitude) Breakpoints,
+//! because null Breakpoints are interpreted as phase reset points in 
+//! Loris. If a null is encountered, its phase is simply left unmodified,
+//! and future phases wil be recomputed from that one.
+//!
+//! \param b    The beginning of a range of Partials whose phases 
+//!             should be fixed.
+//! \param e    The end of a range of Partials whose phases 
+//!             should be fixed.
+//! \param tbeg The phases and frequencies of Breakpoints later than the 
+//!             one nearest this time will be modified.
+//! \param tend The phases and frequencies of Breakpoints earlier than the 
+//!             one nearest this time will be modified. Should be greater 
+//!             than tbeg, or else they will be swapped.
+//
+template < class Iter >
+void fixPhaseForward( Iter b, Iter e, double tbeg, double tend )
+{
+    while ( b != e )
+    {
+        fixPhaseForward( *b, tbeg, tend );
+        ++b;
+    }
+}
+
+
+// ---------------------------------------------------------------------------
+//	fixPhaseAt
+// ---------------------------------------------------------------------------
+//! Recompute phases of all Breakpoints in a Partial
+//! so that the synthesized phases match the stored phases, 
+//! and the synthesized phase at (nearest) the specified
+//! time matches the stored (not recomputed) phase.
+//! 
+//! Backward phase-fixing stops if a null (zero-amplitude) Breakpoint
+//! is encountered, because nulls are interpreted as phase reset points
+//! in Loris. If a null is encountered, the remainder of the Partial
+//! (the front part) is fixed in the forward direction, beginning at
+//! the start of the Partial. Forward phase fixing is only applied 
+//! to non-null (nonzero-amplitude) Breakpoints. If a null is encountered, 
+//! its phase is simply left unmodified, and future phases wil be 
+//! recomputed from that one.
+//!
+//! \param p    The Partial whose phases should be fixed.
+//! \param t    The time at which phases should be made correct.
+//
+void fixPhaseAt( Partial & p, double t );
+
+// ---------------------------------------------------------------------------
+//	fixPhaseAt (range)
+// ---------------------------------------------------------------------------
+//! Recompute phases of all Breakpoints in a Partial
+//! so that the synthesize phases match the stored phases, 
+//! and the synthesized phase at (nearest) the specified
+//! time matches the stored (not recomputed) phase.
+//! 
+//! Backward phase-fixing stops if a null (zero-amplitude) Breakpoint
+//! is encountered, because nulls are interpreted as phase reset points
+//! in Loris. If a null is encountered, the remainder of the Partial
+//! (the front part) is fixed in the forward direction, beginning at
+//! the start of the Partial. Forward phase fixing is only applied 
+//! to non-null (nonzero-amplitude) Breakpoints. If a null is encountered, 
+//! its phase is simply left unmodified, and future phases wil be 
+//! recomputed from that one.
+//!
+//! \param b    The beginning of a range of Partials whose phases 
+//!             should be fixed.
+//! \param e    The end of a range of Partials whose phases 
+//!             should be fixed.
+//! \param t    The time at which phases should be made correct.
+//
+template < class Iter >
+void fixPhaseAt( Iter b, Iter e, double t )
+{
+    while ( b != e )
+    {
+        fixPhaseAt( *b, t );
+        ++b;
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	fixPhaseBetween
+// ---------------------------------------------------------------------------
+//!	Fix the phase travel between two times by adjusting the
+//!	frequency and phase of Breakpoints between those two times.
+//!
+//!	This algorithm assumes that there is nothing interesting about the
+//!	phases of the intervening Breakpoints, and modifies their frequencies 
+//!	as little as possible to achieve the correct amount of phase travel 
+//!	such that the frequencies and phases at the specified times
+//!	match the stored values. The phases of all the Breakpoints between 
+//! the specified times are recomputed.
+//!
+//! THIS DOES NOT YET TREAT NULL BREAKPOINTS DIFFERENTLY FROM OTHERS.
+//!
+//! \pre      Thre must be at least one Breakpoint in the
+//!           Partial between the specified times t1 and t2.
+//!           If this condition is not met, the Partial is
+//!           unmodified.
+//! \post     The phases and frequencies of the Breakpoints in the 
+//!           range have been recomputed such that an oscillator
+//!           initialized to the parameters of the first Breakpoint
+//!           will arrive at the parameters of the last Breakpoint,
+//!           and all the intervening Breakpoints will be matched.
+//!	\param p  The partial whose phases and frequencies will be recomputed. 
+//!           The Breakpoint at this position is unaltered.
+//! \param t1 The time before which Partial frequencies and phases will 
+//!           not be modified.
+//! \param t2 The time after which Partial frequencies and phases will 
+//!           not be modified. Should be greater than t1, or else they
+//!           will be swapped.
+//
+void fixPhaseBetween( Partial & p, double t1, double t2 );
+
+// ---------------------------------------------------------------------------
+//	fixPhaseBetween (range)
+// ---------------------------------------------------------------------------
+//!	Fix the phase travel between two times by adjusting the
+//!	frequency and phase of Breakpoints between those two times.
+//!
+//!	This algorithm assumes that there is nothing interesting about the
+//!	phases of the intervening Breakpoints, and modifies their frequencies 
+//!	as little as possible to achieve the correct amount of phase travel 
+//!	such that the frequencies and phases at the specified times
+//!	match the stored values. The phases of all the Breakpoints between 
+//! the specified times are recomputed.
+//!
+//! THIS DOES NOT YET TREAT NULL BREAKPOINTS DIFFERENTLY FROM OTHERS.
+//!
+//! \pre        Thre must be at least one Breakpoint in each
+//!             Partial between the specified times t1 and t2.
+//!             If this condition is not met, the Partial is
+//!             unmodified.
+//! \post       The phases and frequencies of the Breakpoints in the 
+//!             range have been recomputed such that an oscillator
+//!             initialized to the parameters of the first Breakpoint
+//!             will arrive at the parameters of the last Breakpoint,
+//!             and all the intervening Breakpoints will be matched.
+//! \param b    The beginning of a range of Partials whose phases 
+//!             should be fixed.
+//! \param e    The end of a range of Partials whose phases 
+//!             should be fixed.
+//! \param t1   The time before which Partial frequencies and phases will 
+//!             not be modified.
+//! \param t2   The time after which Partial frequencies and phases will 
+//!             not be modified. Should be greater than t1, or else they
+//!             will be swapped.
+//
+template < class Iter >
+void fixPhaseBetween( Iter b, Iter e, double t1, double t2 )
+{
+    while ( b != e )
+    {
+        fixPhaseBetween( *b, t1, t2 );
+        ++b;
+    }
+}
+
+
+	
+//	-- predicates --
+
+// ---------------------------------------------------------------------------
+//	isDurationLess
+//	
+//! Predicate functor returning true if the duration of its 
+//! Partial argument is less than the specified duration in
+//! seconds, and false otherwise.
+//
+class isDurationLess : public std::unary_function< const Partial, bool >
+{
+public:
+    //! Initialize a new instance with the specified label.
+	isDurationLess( double x ) : mDurationSecs(x) {}
+
+	//! Function call operator: evaluate a Partial.
+	bool operator()( const Partial & p ) const 
+		{ return p.duration() < mDurationSecs; }
+		
+	//! Function call operator: evaluate a Partial pointer.
+	bool operator()( const Partial * p ) const 
+		{ return p->duration() < mDurationSecs; }
+        
+private:	
+	double mDurationSecs;
+};
+
+// ---------------------------------------------------------------------------
+//	isLabelEqual
+//	
+//! Predicate functor returning true if the label of its Partial argument is
+//! equal to the specified 32-bit label, and false otherwise.
+//
+class isLabelEqual : public std::unary_function< const Partial, bool >
+{
+public:
+    //! Initialize a new instance with the specified label.
+	isLabelEqual( int l ) : label(l) {}
+	
+	//! Function call operator: evaluate a Partial.
+	bool operator()( const Partial & p ) const 
+		{ return p.label() == label; }
+		
+	//! Function call operator: evaluate a Partial pointer.
+	bool operator()( const Partial * p ) const 
+		{ return p->label() == label; }
+
+private:	
+	int label;
+};
+	
+// ---------------------------------------------------------------------------
+//	isLabelGreater
+//	
+//! Predicate functor returning true if the label of its Partial argument is
+//! greater than the specified 32-bit label, and false otherwise.
+//
+class isLabelGreater : public std::unary_function< const Partial, bool >
+{
+public:
+   //! Initialize a new instance with the specified label.
+	isLabelGreater( int l ) : label(l) {}
+	
+	//! Function call operator: evaluate a Partial.
+	bool operator()( const Partial & p ) const 
+		{ return p.label() > label; }
+		
+	//! Function call operator: evaluate a Partial pointer.
+	bool operator()( const Partial * p ) const 
+		{ return p->label() > label; }
+
+private:	
+	int label;
+};
+		
+// ---------------------------------------------------------------------------
+//	isLabelLess
+//	
+//! Predicate functor returning true if the label of its Partial argument is
+//! less than the specified 32-bit label, and false otherwise.
+//
+class isLabelLess : public std::unary_function< const Partial, bool >
+{
+public:
+   //! Initialize a new instance with the specified label.
+	isLabelLess( int l ) : label(l) {}
+	
+	//! Function call operator: evaluate a Partial.
+	bool operator()( const Partial & p ) const 
+		{ return p.label() < label; }
+		
+	//! Function call operator: evaluate a Partial pointer.
+	bool operator()( const Partial * p ) const 
+		{ return p->label() < label; }
+
+private:	
+	int label;
+};
+		
+// ---------------------------------------------------------------------------
+//	isPeakLess
+//	
+//! Predicate functor returning true if the peak amplitude achieved by its 
+//! Partial argument is less than the specified absolute amplitude, and 
+//! false otherwise.
+//
+class isPeakLess : public std::unary_function< const Partial, bool >
+{
+public:
+    //! Initialize a new instance with the specified peak amplitude.
+	isPeakLess( double x ) : thresh(x) {}
+
+	//! Function call operator: evaluate a Partial.
+	bool operator()( const Partial & p ) const 
+		{ return peakAmplitude( p ) < thresh; }
+        
+	//! Function call operator: evaluate a Partial pointer.
+	bool operator()( const Partial * p ) const 
+		{ return peakAmplitude( *p ) < thresh; }
+
+private:	
+	double thresh;
+};
+
+//	-- comparitors --
+
+// ---------------------------------------------------------------------------
+//	compareLabelLess
+//	
+//! Comparitor (binary) functor returning true if its first Partial
+//! argument has a label whose 32-bit integer representation is less than
+//! that of the second Partial argument's label, and false otherwise.
+//
+class compareLabelLess : 
+	public std::binary_function< const Partial, const Partial, bool >
+{
+public:
+   //! Compare two Partials, return true if its first Partial
+   //! argument has a label whose 32-bit integer representation is less than
+   //! that of the second Partial argument's label, and false otherwise.
+	bool operator()( const Partial & lhs, const Partial & rhs ) const 
+		{ return lhs.label() < rhs.label(); }
+
+   //! Compare two Partials, return true if its first Partial
+   //! argument has a label whose 32-bit integer representation is less than
+   //! that of the second Partial argument's label, and false otherwise.
+	bool operator()( const Partial * lhs, const Partial * rhs ) const 
+		{ return lhs->label() < rhs->label(); }
+};
+
+// ---------------------------------------------------------------------------
+//	compareDurationLess
+//	
+//! Comparitor (binary) functor returning true if its first Partial
+//! argument has duration less than that of the second Partial
+//! argument, and false otherwise.
+//
+class compareDurationLess : 
+	public std::binary_function< const Partial, const Partial, bool >
+{
+public:
+   //! Compare two Partials, return true if its first Partial
+   //! argument has duration less than that of the second Partial
+   //! argument, and false otherwise.
+	bool operator()( const Partial & lhs, const Partial & rhs ) const 
+		{ return lhs.duration() < rhs.duration(); }
+
+   //! Compare two Partials, return true if its first Partial
+   //! argument has duration less than that of the second Partial
+   //! argument, and false otherwise.
+	bool operator()( const Partial * lhs, const Partial * rhs ) const 
+		{ return lhs->duration() < rhs->duration(); }
+};
+
+// ---------------------------------------------------------------------------
+//	compareDurationGreater
+//	
+//! Comparitor (binary) functor returning true if its first Partial
+//! argument has duration greater than that of the second Partial
+//! argument, and false otherwise.
+//
+class compareDurationGreater : 
+	public std::binary_function< const Partial, const Partial, bool >
+{
+public:
+   //! Compare two Partials, return true if its first Partial
+   //! argument has duration greater than that of the second Partial
+   //! argument, and false otherwise.
+	bool operator()( const Partial & lhs, const Partial & rhs ) const 
+		{ return lhs.duration() > rhs.duration(); }
+
+   //! Compare two Partials, return true if its first Partial
+   //! argument has duration greater than that of the second Partial
+   //! argument, and false otherwise.
+	bool operator()( const Partial * lhs, const Partial * rhs ) const 
+		{ return lhs->duration() > rhs->duration(); }
+};
+
+// ---------------------------------------------------------------------------
+//	compareStartTimeLess
+//	
+//! Comparitor (binary) functor returning true if its first Partial
+//! argument has start time earlier than that of the second Partial
+//! argument, and false otherwise.
+//
+class compareStartTimeLess : 
+	public std::binary_function< const Partial, const Partial, bool >
+{
+public:
+   //! Compare two Partials, return true if its first Partial
+   //! argument has start time earlier than that of the second Partial
+   //! argument, and false otherwise.
+	bool operator()( const Partial & lhs, const Partial & rhs ) const 
+		{ return lhs.startTime() < rhs.startTime(); }
+
+   //! Compare two Partials, return true if its first Partial
+   //! argument has start time earlier than that of the second Partial
+   //! argument, and false otherwise.
+	bool operator()( const Partial * lhs, const Partial * rhs ) const 
+		{ return lhs->startTime() < rhs->startTime(); }
+};
+
+
+
+}	//	end of namespace PartialUtils
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_PARTIALUTILS_H */
diff --git a/src/loris/README b/src/loris/README
new file mode 100644
index 0000000..0a2ab2b
--- /dev/null
+++ b/src/loris/README
@@ -0,0 +1,4 @@
+This directory contains the source code for the Loris C++ library. In
+addition to the interface presented by the C++ classes, the Loris
+library presents a simplified, C-linkable procedural interface through
+the functions descried in loris.h
diff --git a/src/loris/ReassignedSpectrum.C b/src/loris/ReassignedSpectrum.C
new file mode 100644
index 0000000..0292905
--- /dev/null
+++ b/src/loris/ReassignedSpectrum.C
@@ -0,0 +1,746 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * ReassignedSpectrum.C
+ *
+ * Implementation of class Loris::ReassignedSpectrum.
+ *
+ * Kelly Fitz, 9 Dec 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "ReassignedSpectrum.h"
+#include "Notifier.h"
+#include "LorisExceptions.h"
+#include <algorithm>	//	for std::transform(), others
+#include <functional>	//	for bind1st, multiplies, etc.
+#include <cstdlib>	    //	for std::abs()
+#include <numeric>	    //	for std::accumulate()
+
+#include <cmath>	//	for M_PI (except when its not there), fmod, fabs
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+	const double Pi = M_PI;
+#else
+	const double Pi = 3.14159265358979324;
+#endif
+
+// The old quadratic interpolation code is still around, in case
+// we ever want to use it for comparison, Lemur used to use that.
+#if defined(Like_Lemur)
+#define USE_PARABOLIC_INTERPOLATION
+#endif
+
+//	define this symbol to compute the mixed phase derivative
+#define COMPUTE_MIXED_PHASE_DERIVATIVE 1
+
+//	there's a lot of std in here, 
+//	import the whole namespace, as ugly as that is.
+using namespace std;
+
+//	begin namespace
+namespace Loris {
+
+static unsigned long nextPO2( unsigned long N )
+{
+    return (unsigned long)ceil( log( double(N) ) / log( 2. ) );
+}
+                          
+// ---------------------------------------------------------------------------
+//	ReassignedSpectrum constructor
+// ---------------------------------------------------------------------------
+//! Construct a new instance using the specified short-time window.
+//!	Transform lengths are the smallest power of two greater than twice the
+//!	window length.
+//
+ReassignedSpectrum::ReassignedSpectrum( const std::vector< double > & window ) :
+	mMagnitudeTransform( 1 << ( 1 + nextPO2( window.size() ) ) ),
+	mCorrectionTransform( 1 << ( 1 + nextPO2( window.size() ) ) )
+{	
+    //  Build and store the window functions.
+	buildReassignmentWindows( window );                        
+
+	debugger << "ReassignedSpectrum: length is " << mMagnitudeTransform.size() << endl;
+}
+
+// ---------------------------------------------------------------------------
+//	ReassignedSpectrum constructor
+// ---------------------------------------------------------------------------
+//! Construct a new instance using the specified short-time window and
+//! its time derivative.
+//!	Transform lengths are the smallest power of two greater than twice the
+//!	window length.
+ReassignedSpectrum::ReassignedSpectrum( const std::vector< double > & window,
+                                        const std::vector< double > & windowDerivative ) :
+	mMagnitudeTransform( 1 << ( 1 + nextPO2( window.size() ) ) ),
+	mCorrectionTransform( 1 << ( 1 + nextPO2( window.size() ) ) )
+{
+    //  Build and store the window functions.
+	buildReassignmentWindows( window, windowDerivative );  
+
+	debugger << "ReassignedSpectrum: length is " << mMagnitudeTransform.size() << endl;
+}
+
+
+// ---------------------------------------------------------------------------
+//	transform
+// ---------------------------------------------------------------------------
+//!	Compute the reassigned Fourier transform of the samples on the half open
+//!	range [sampsBegin, sampsEnd), aligning sampCenter with the center of
+//!	the analysis window.
+//!
+//! \param  sampsBegin pointer representing the beginning of 
+//!         the (half-open) range of samples to transform
+//! \param  sampCenter the sample in the range that is to be 
+//!         aligned with the center of the analysis window
+//! \param  sampsEnd pointer representing the end of 
+//!         the (half-open) range of samples to transform
+//!
+//! \pre    sampsBegin must not be past sampCenter
+//! \pre    sampsEnd must be past sampCenter
+//! \post   the transform buffers store the reassigned 
+//!         short-time transform data for the specified 
+//!         samples
+//
+void
+ReassignedSpectrum::transform( const double * sampsBegin, 
+                               const double * sampCenter, 
+                               const double * sampsEnd )
+{
+    if ( sampCenter < sampsBegin ||  sampCenter >= sampsEnd )
+    {
+        Throw( InvalidArgument, "Invalid sample range boundaries." );
+    }
+
+	const long firstHalfWinLength = window().size() / 2;
+	const long secondHalfWinLength = (window().size() - 1) / 2;
+	    
+    //  ensure that samples outside the window are not used:
+    sampsBegin = std::max( sampsBegin, sampCenter - firstHalfWinLength );
+    sampsEnd = std::min( sampsEnd, sampCenter + secondHalfWinLength + 1 );
+		
+	//	we will skip the beginning of the window
+	//	only if pos is too close to the start of 
+	//	the buffer:
+	long winBeginOffset = 0; 
+	if ( sampCenter - sampsBegin < (window().size() / 2) )
+	{
+		winBeginOffset = (window().size() / 2) - ( sampCenter - sampsBegin );
+	}			
+		
+	//	to get phase right, we will rotate the Fourier transform 
+	//	input by pos - sampsBegin samples:
+	long rotateBy = sampCenter - sampsBegin;
+		
+	//	window and rotate input and compute normal transform:
+	//	window the samples into the FT buffer:
+	FourierTransform::iterator it = 
+		std::transform( sampsBegin, sampsEnd, mCplxWin_W_Wtd.begin() + winBeginOffset, 
+						mMagnitudeTransform.begin(), std::multiplies< std::complex< double > >() );
+	//	fill the rest with zeros:
+	std::fill( it, mMagnitudeTransform.end(), 0. );
+	//	rotate to align phase:
+	std::rotate( mMagnitudeTransform.begin(), mMagnitudeTransform.begin() + rotateBy, mMagnitudeTransform.end() );
+
+	//	compute transform:
+	mMagnitudeTransform.transform();
+
+	//	compute the dual reassignment transform:
+	//	window the samples into the reassignment FT buffer,
+	//	using the complex-valued reassignment window:
+	it = std::transform( sampsBegin, sampsEnd, mCplxWin_Wd_Wt.begin() + winBeginOffset, 
+						 mCorrectionTransform.begin(), std::multiplies< std::complex<double> >() );
+	//	fill the rest with zeros:
+	std::fill( it, mCorrectionTransform.end(), 0. );
+	//	rotate to align phase:
+	std::rotate( mCorrectionTransform.begin(), mCorrectionTransform.begin() + rotateBy, mCorrectionTransform.end() );
+	//	compute the transform:
+	mCorrectionTransform.transform();
+}
+
+// ---------------------------------------------------------------------------
+//	size
+// ---------------------------------------------------------------------------
+//! Return the length of the Fourier transforms.
+//
+ReassignedSpectrum::size_type 
+ReassignedSpectrum::size( void ) const 
+{ 
+    return mMagnitudeTransform.size(); 
+}
+
+// ---------------------------------------------------------------------------
+//	window
+// ---------------------------------------------------------------------------
+//! Return read access to the short-time window samples.
+//!	(Peers may need to know about the analysis window
+//!	or about the scale factors in introduces.)
+//
+const std::vector< double > &
+ReassignedSpectrum::window( void ) const 
+{ 
+    return mWindow; 
+}
+
+// ---------------------------------------------------------------------------
+//	circEvenPartAt - helper
+// ---------------------------------------------------------------------------
+// Extract the circular even part from Fourier transform data.
+// Used for computing two real transforms using a single complex transform.
+//
+template< class TransformData >
+static std::complex<double>
+circEvenPartAt( const TransformData & td, long idx )
+{
+    const long N = td.size();
+    while( idx < 0 )
+    {
+        idx += N;
+    }
+    while( idx >= N )
+    {
+        idx -= N;
+    }
+
+ 	long flip_idx;
+	if ( idx != 0 )
+	{
+		flip_idx = N - idx;
+	}
+	else
+    {
+		flip_idx = idx;
+	}
+		
+	return 0.5*( td[idx] + std::conj( td[flip_idx] ) );
+}   
+
+// ---------------------------------------------------------------------------
+//	circOddPartAt - helper
+// ---------------------------------------------------------------------------
+// Extract the circular odd part divided by j from Fourier transform data.
+// Used for computing two real transforms using a single complex transform.
+//
+template< class TransformData >
+static std::complex<double>
+circOddPartAt( const TransformData & td, long idx )
+{
+    const long N = td.size();
+    while( idx < 0 )
+    {
+        idx += N;
+    }
+    while( idx >= N )
+    {
+        idx -= N;
+    }
+
+ 	long flip_idx;
+	if ( idx != 0 )
+	{
+		flip_idx = N - idx;
+	}
+	else
+    {
+		flip_idx = idx;
+	}
+
+	/*
+	const std::complex<double> minus_j(0,-1);
+	std::complex<double> tra_part = minus_j * 0.5 * 
+									( td[idx] - std::conj( td[flip_idx] ) );
+	*/
+	//	can compute this without complex multiplies:
+	std::complex<double> tmp = td[idx] - std::conj( td[flip_idx] );
+	return std::complex<double>( 0.5*tmp.imag(), -0.5*tmp.real() );
+}   
+
+// ---------------------------------------------------------------------------
+//	frequencyCorrection
+// ---------------------------------------------------------------------------
+//!	Compute the frequency correction at the specified frequency sample
+//! using the method of Auger and Flandrin to evaluate the partial
+//! derivative of spectrum phase w.r.t. time.
+//!
+//!	Correction is computed in fractional frequency samples, because
+//!	that's the kind of frequency domain ramp we used on our window.
+//!	sample is the frequency sample index, the nominal component 
+//!	frequency in samples. 
+//
+//	Parabolic interpolation can be tried too (see reassignedFrequency()) 
+//	but it appears to give slightly worse results, for example, with 
+//	a square wave.
+//
+double
+ReassignedSpectrum::frequencyCorrection( long idx ) const
+{
+	std::complex<double> X_h = circEvenPartAt( mMagnitudeTransform, idx );
+    std::complex<double> X_Dh = circEvenPartAt( mCorrectionTransform, idx );
+	
+	double num = X_h.real() * X_Dh.imag() -
+				 X_h.imag() * X_Dh.real();
+	
+	double magSquared = std::norm( X_h );
+
+	//	need to scale by the oversampling factor
+	double oversampling = (double)mCorrectionTransform.size() / mCplxWin_W_Wtd.size();
+	return - oversampling * num / magSquared;
+}
+
+// ---------------------------------------------------------------------------
+//	timeCorrection
+// ---------------------------------------------------------------------------
+//!	Compute the time correction at the specified frequency sample
+//! using the method of Auger and Flandrin to evaluate the partial
+//! derivative of spectrum phase w.r.t. frequency.
+//!
+//!	Correction is computed in fractional samples, because
+//!	that's the kind of ramp we used on our window.
+//
+double
+ReassignedSpectrum::timeCorrection( long idx ) const
+{
+	std::complex<double> X_h = circEvenPartAt( mMagnitudeTransform, idx );
+	std::complex<double> X_Th = circOddPartAt( mCorrectionTransform, idx ); 
+
+	double num = X_h.real() * X_Th.real() +
+		  		 X_h.imag() * X_Th.imag();
+	double magSquared = norm( X_h );
+	
+	//	No need to scale by the oversampling factor.
+	//	No, seems to sound bad, why?
+	//	(try alienthreat)
+	// double oversampling = (double)mCorrectionTransform.size() / mCplxWin_W_Wtd.size();
+	return num / magSquared;
+}
+
+// ---------------------------------------------------------------------------
+//	reassignedFrequency
+// ---------------------------------------------------------------------------
+//! Return the reassigned frequency in fractional frequency 
+//! samples computed at the specified transform index.
+//!
+//! \param  idx the frequency sample at which to evaluate the
+//!         transform
+//
+double
+ReassignedSpectrum::reassignedFrequency( long idx ) const
+{
+#if ! defined(USE_PARABOLIC_INTERPOLATION)
+
+	return double(idx) + frequencyCorrection( idx );
+	
+#else // defined(USE_PARABOLIC_INTERPOLATION)
+
+	double dbLeft = 20. * log10( abs( circEvenPartAt( mMagnitudeTransform, idx-1 ) ) );
+	double dbCandidate = 20. * log10( abs( circEvenPartAt( mMagnitudeTransform, idx ) ) );
+	double dbRight = 20. * log10( abs( circEvenPartAt( mMagnitudeTransform, idx+1 ) ) );
+	
+	double peakXOffset = 0.5 * (dbLeft - dbRight) /
+						 (dbLeft - 2.0 * dbCandidate + dbRight);
+
+	return idx + peakXOffset;
+	
+#endif	//	defined USE_PARABOLIC_INTERPOLATION
+}
+
+// ---------------------------------------------------------------------------
+//	reassignedTime
+// ---------------------------------------------------------------------------
+//! Return the reassigned time in fractional samples
+//! computed at the specified transform index.
+//!
+//! \param  idx the frequency sample at which to evaluate the
+//!         transform
+//
+double
+ReassignedSpectrum::reassignedTime( long idx ) const
+{
+	return timeCorrection( idx );
+}
+
+// ---------------------------------------------------------------------------
+//	reassignedMagnitude
+// ---------------------------------------------------------------------------
+//! Return the spectrum magnitude (absolute)
+//! computed at the specified transform index.
+//!
+//! \param  idx the frequency sample at which to evaluate the
+//!         transform
+//
+double
+ReassignedSpectrum::reassignedMagnitude( long idx ) const
+{
+#if ! defined(USE_PARABOLIC_INTERPOLATION)
+	
+	//	compute the nominal spectral amplitude by scaling
+	//	the peak spectral sample:
+	return abs( circEvenPartAt( mMagnitudeTransform, idx ) );
+	
+#else // defined(USE_PARABOLIC_INTERPOLATION)
+	
+	//	keep this parabolic interpolation computation around
+	//	only for sake of comparison, it is unlikely to yield
+	//	good results with bandwidth association:
+	double dbLeft = 20. * log10( abs( circEvenPartAt( mMagnitudeTransform, idx-1 ) ) );
+	double dbCandidate = 20. * log10( abs( circEvenPartAt( mMagnitudeTransform, idx ) ) );
+	double dbRight = 20. * log10( abs( circEvenPartAt( mMagnitudeTransform, idx+1 ) ) );
+	
+	double peakXOffset = 0.5 * (dbLeft - dbRight) /
+						 (dbLeft - 2.0 * dbCandidate + dbRight);
+	double dbmag = dbCandidate - 0.25 * (dbLeft - dbRight) * peakXOffset;
+	double x = pow( 10., 0.05 * dbmag );
+	
+	return x;
+	
+#endif	//	defined USE_PARABOLIC_INTERPOLATION
+}
+
+// ---------------------------------------------------------------------------
+//	reassignedPhase
+// ---------------------------------------------------------------------------
+//! Return the phase in radians computed at the specified transform index.
+//!	The reassigned phase is shifted to account for the time
+//!	correction according to the corrected frequency.
+//!
+//! \param  idx the frequency sample at which to evaluate the
+//!         transform
+//
+double
+ReassignedSpectrum::reassignedPhase( long idx ) const
+{
+	double phase = arg( circEvenPartAt( mMagnitudeTransform, idx ) );
+	
+	const double offsetTime = timeCorrection( idx );
+	const double offsetFreq = frequencyCorrection( idx );
+	
+	//	adjust phase according to the frequency correction:
+	//	first compute H(1):
+	//
+	//  this seems like it would be a good idea, but in practice,
+	//	it screws the phases up badly.
+	//  Am I just correcting in the wrong direction? No, its 
+	//	something else.
+	//
+	//  Seems like I had the slope way too big. Changed to compute 
+	//	the slope from H(1) of a rotated window, and now the slope
+	//	is so small that it seems like there will never be any phase
+	//	correction.
+	//
+	//  Phase ought to be linear anyway, so I should just be
+	//  able to use dumb old linear interpolation.
+    //  offsetFreq is in fractional frequency samples
+    if ( offsetFreq > 0 )
+    {
+        double nextphase = arg( circEvenPartAt( mMagnitudeTransform, idx+1 ) );
+        double slope = nextphase - phase;
+        phase += offsetFreq * slope;
+    }
+    else
+    {   
+        double prevphase = arg( circEvenPartAt( mMagnitudeTransform, idx-1 ) );
+        double slope = phase - prevphase;
+        phase += offsetFreq * slope;
+    }
+    
+		
+	//	adjust phase according to the time correction:
+	const double fracFreqSample = idx + offsetFreq; 
+	phase += offsetTime * fracFreqSample * 2. * Pi / mMagnitudeTransform.size();
+    
+    //  NOTICE
+    //  This could be pretty much anything -- a sample reassigned by a
+    //  millisecond at 1000 Hz in a 1024 FFT at 44k sample rate is 
+    //  adjusted by 2Pi.
+    //  
+    //  What if the frequency estimate is bad? Corrupts the phase estimate too!
+	
+	return fmod( phase, 2. * Pi );
+}
+
+// ---------------------------------------------------------------------------
+//	convergence
+// ---------------------------------------------------------------------------
+//! Compute and return the convergence indicator, computed from the 
+//!	mixed partial derivative of spectral phase, optionally used in 
+//!	BW enhanced analysis as a convergence indicator. The convergence
+//!	value is on the range [0,1], 0 for a sinusoid, and 1 for an impulse.
+//!
+//! \param  idx the frequency sample at which to evaluate the
+//!         transform
+//
+double
+ReassignedSpectrum::convergence( long idx ) const
+{
+#if defined(COMPUTE_MIXED_PHASE_DERIVATIVE)
+
+  	std::complex<double> X_h = circEvenPartAt( mMagnitudeTransform, idx );
+	std::complex<double> X_Th = circOddPartAt( mCorrectionTransform, idx ); 
+    std::complex<double> X_Dh = circEvenPartAt( mCorrectionTransform, idx );
+    std::complex<double> X_TDh = circOddPartAt( mMagnitudeTransform, idx );
+
+	double term1 = (X_TDh * conj(X_h)).real() / norm( X_h );
+	double term2 = ((X_Th * X_Dh) / (X_h * X_h)).real();
+		  		  
+	double scaleBy = 2. * Pi / mCplxWin_W_Wtd.size();
+
+    double bw = fabs( 1.0 + (scaleBy * (term1 - term2)) );
+    bw = min( 1.0, bw );
+
+#else
+	double bw = 0.;
+#endif
+
+    return bw;  
+}
+
+// ---------------------------------------------------------------------------
+//	subscript operator (deprecated)
+// ---------------------------------------------------------------------------
+//  Included to support old code.
+//  The signature has changed, can no longer return a reference,
+//  but since the reference returned was const, this version should 
+//  keep most old code working, if not all.
+//
+std::complex< double >
+ReassignedSpectrum::operator[]( unsigned long idx ) const
+{
+    return circEvenPartAt( mMagnitudeTransform, idx );
+}
+
+// ---------------------------------------------------------------------------
+//	make_complex
+// ---------------------------------------------------------------------------
+//	Function object for building complex numbers.
+//
+template <class T>
+struct make_complex
+	: binary_function< T, T, std::complex<T> >
+{
+	std::complex<T> operator()(const T& re, const T& im) const
+    {
+    	return std::complex<T>( re, im );
+    }
+};
+
+// ---------------------------------------------------------------------------
+//	applyFreqRamp
+// ---------------------------------------------------------------------------
+//	Adapted from the FrequencyReassignment constructor in Lemur 5.
+//  
+//  This function computes an estimate of the time derivative of the 
+//  specified window function, scaled by N/2pi, appropriate for computing
+//  frequency reassignment.
+//
+static inline void applyFreqRamp( vector< double > & w  )
+{
+	//	we're going to do the frequency-domain ramp 
+	//	by Fourier transforming the window, ramping,
+	//	then transforming again. 
+	//	Use a transform exactly as long as the window.
+	//	load, w/out rotation, and transform.
+	FourierTransform temp( w.size() );
+	FourierTransform::iterator it =  std::copy( w.begin(), w.end(), temp.begin() );
+	std::fill( it, temp.end(), 0. );
+	temp.transform();
+	
+	//	extract complex transform and multiply by
+	//	a frequency (sample) ramp:
+	//	(the frequency ramp goes from 0 to N/2
+	//	over the first half, then -N/2 to 0 over 
+	//	the second (aliased) half of the transform,
+	//	and has to be scaled by the ratio of the 
+	//	transform lengths, so that k spans the length
+	//	of the padded transforms, N)
+	for ( int k = 0 ; k < temp.size(); ++k ) 
+	{
+	   double x = (double)k;   // to get type promotion right
+		if ( k < temp.size() / 2 ) 
+		{
+			temp[ k ] *= x;
+		}
+		else 
+		{
+			temp[ k ] *= ( x - temp.size() );
+		}
+	}
+	
+	//	invert the transform:
+	temp.transform();
+	
+	//	the DFT of a DFT gives the scaled and INDEX REVERSED
+	//	sequence. See p. 539 of O and S.
+	//	DFT( X[n] ) -- DFT --> Nx[ -k mod N ] 
+	//
+	//	seems that I want the imaginary part of the index-reversed
+	//	transform scaled by the size of the transform:
+	std::reverse( temp.begin() + 1, temp.end() );
+	for ( int i = 0; i < w.size(); ++i ) 
+	{
+		w[i] = - imag( temp[i] ) / temp.size();
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	applyTimeRamp
+// ---------------------------------------------------------------------------
+//	Make a copy of mWindow scaled by a ramp from -N/2 to N/2 for computing
+//	time corrections in samples.
+//
+static inline void applyTimeRamp( vector< double > & w )
+{
+	//	the very center of the window should be scaled by 0.,
+	//	need a fractional value for even-length windows, a
+	//	whole number for odd-length windows:
+	double offset = 0.5 * ( w.size() - 1 );
+	for ( int k = 0 ; k < w.size(); ++k ) 
+	{
+		w[ k ] *= ( k - offset );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	buildReassignmentWindows (private)
+// ---------------------------------------------------------------------------
+//	Build a pair of complex-valued windows, one having the frequency-ramp 
+//  (time-derivative) window in the real part and the time-ramp window in the 
+//  imagnary part, and the other having the unmodified window in the real part
+//  and, if computing mixed deriviatives, the time-ramp time-derivative window
+//  in the imaginary part.
+//
+//  Input is the unmodified window function.
+//
+void 
+ReassignedSpectrum::buildReassignmentWindows( const std::vector< double > & window )
+{
+    mWindow.resize( window.size(), 0. );
+	
+    // Scale the window so that the reported magnitudes
+	// are correct.
+	double winsum = std::accumulate( window.begin(), window.end(), 0. );    
+    std::transform( window.begin(), window.end(), mWindow.begin(), 
+			        std::bind1st( std::multiplies<double>(), 2/winsum ) );                    
+    
+
+    //  Construct the ramped windows from the scaled window.
+	std::vector< double > tramp = mWindow;
+	applyTimeRamp( tramp );
+	
+	std::vector< double > framp = mWindow;
+	applyFreqRamp( framp );
+
+	std::vector< double > tframp( mWindow.size(), 0. );
+	
+#if defined(COMPUTE_MIXED_PHASE_DERIVATIVE)
+
+    //  Do this only if we are computing the mixed 
+    //  partial derivative of phase, otherwise, leave
+    //  that vector empty.
+	tframp = framp;
+	applyTimeRamp( tframp );
+	
+#endif
+
+    //  Copy the windows into real and imaginary parts of 
+    //  complex window vectors.
+    mCplxWin_W_Wtd.resize( mWindow.size(), 0. );
+    mCplxWin_Wd_Wt.resize( mWindow.size(), 0. );
+
+	std::transform( framp.begin(), framp.end(), tramp.begin(),
+					mCplxWin_Wd_Wt.begin(), make_complex< double >() );	
+    
+	std::transform( mWindow.begin(), mWindow.end(), tframp.begin(),
+					mCplxWin_W_Wtd.begin(), make_complex< double >() );	
+}
+
+// ---------------------------------------------------------------------------
+//	buildReassignmentWindows
+// ---------------------------------------------------------------------------
+//	Build a pair of complex-valued windows, one having the frequency-ramp 
+//  (time-derivative) window in the real part and the time-ramp window in the 
+//  imagnary part, and the other having the unmodified window in the real part
+//  and, if computing mixed deriviatives, the time-ramp time-derivative window
+//  in the imaginary part.
+//
+//  Input is the unmodified window function and its time derivative, so the
+//  DFT kludge is unnecessary.
+//
+
+void 
+ReassignedSpectrum::buildReassignmentWindows( const std::vector< double > & window,
+                                              const std::vector< double > & windowDerivative )  
+{
+
+    mWindow.resize( window.size(), 0. );
+	
+    // Scale the windows so that the reported magnitudes
+	// are correct.
+	double winsum = std::accumulate( window.begin(), window.end(), 0. );    
+    std::transform( window.begin(), window.end(), mWindow.begin(), 
+			        std::bind1st( std::multiplies<double>(), 2/winsum ) ); 
+                    
+                        
+    //  The fancy frequency reassignment window needs to scale the
+    //  time derivative window by N (its length) / 2pi, in addition
+    //  to scaling by 2/winsum to match the amplitude scaling above.
+    const double fancyScale = windowDerivative.size() / ( winsum * Pi );
+	std::vector< double > framp( windowDerivative.size(), 0 );
+	std::transform( windowDerivative.begin(), windowDerivative.end(), framp.begin(), 
+			        std::bind1st( std::multiplies<double>(), fancyScale ) );
+                    
+
+    //  Construct the ramped windows from the scaled window.
+	std::vector< double > tramp = mWindow;
+	applyTimeRamp( tramp );
+	
+	std::vector< double > tframp( mWindow.size(), 0. );	
+	
+#if defined(COMPUTE_MIXED_PHASE_DERIVATIVE)
+
+    //  Do this only if we are computing the mixed 
+    //  partial derivative of phase, otherwise, leave
+    //  that vector empty.
+	tframp = framp;
+	applyTimeRamp( tframp );
+	
+#endif
+
+    //  Copy the windows into real and imaginary parts of 
+    //  complex window vectors.
+    mCplxWin_W_Wtd.resize( mWindow.size(), 0. );
+    mCplxWin_Wd_Wt.resize( mWindow.size(), 0. );
+
+	std::transform( framp.begin(), framp.end(), tramp.begin(),
+					mCplxWin_Wd_Wt.begin(), make_complex< double >() );	
+    
+	std::transform( mWindow.begin(), mWindow.end(), tframp.begin(),
+					mCplxWin_W_Wtd.begin(), make_complex< double >() );	
+}
+
+
+}	//	end of namespace Loris
diff --git a/src/loris/ReassignedSpectrum.h b/src/loris/ReassignedSpectrum.h
new file mode 100644
index 0000000..cd8ae69
--- /dev/null
+++ b/src/loris/ReassignedSpectrum.h
@@ -0,0 +1,229 @@
+#ifndef INCLUDE_REASSIGNEDSPECTRUM_H
+#define INCLUDE_REASSIGNEDSPECTRUM_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * ReassignedSpectrum.h
+ *
+ * Definition of class Loris::ReassignedSpectrum.
+ *
+ * Kelly Fitz, 7 Dec 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "FourierTransform.h"
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	class ReassignedSpectrum
+//
+//!	Computes a reassigned short-time Fourier spectrum using the transform
+//! method of Auger and Flandrin. 
+//	
+class ReassignedSpectrum
+{
+//	-- public interface --
+public:
+    //! An unsigned integral type large enough
+    //! to represent the length of any transform.
+    typedef FourierTransform::size_type size_type;
+
+//	--- lifecycle ---
+
+    //! Construct a new instance using the specified short-time window.
+    //!	Transform lengths are the smallest power of two greater than twice the
+    //!	window length.
+	ReassignedSpectrum( const std::vector< double > & window );
+
+    //! Construct a new instance using the specified short-time window and
+    //! its time derivative.
+    //!	Transform lengths are the smallest power of two greater than twice the
+    //!	window length.
+	ReassignedSpectrum( const std::vector< double > & window,
+                        const std::vector< double > & windowDerivative );
+    
+	// compiler-generated copy, assign, and destroy are sufficient
+
+//	--- operations ---
+
+    //!	Compute the reassigned Fourier transform of the samples on the half open
+    //!	range [sampsBegin, sampsEnd), aligning sampCenter with the center of
+    //!	the analysis window.
+    //!
+    //! \param  sampsBegin pointer representing the beginning of 
+    //!         the (half-open) range of samples to transform
+    //! \param  sampCenter the sample in the range that is to be 
+    //!         aligned with the center of the analysis window
+    //! \param  sampsEnd pointer representing the end of 
+    //!         the (half-open) range of samples to transform
+    //!
+    //! \pre    sampsBegin must not be past sampCenter
+    //! \pre    sampsEnd must be past sampCenter
+    //! \post   the transform buffers store the reassigned 
+    //!         short-time transform data for the specified 
+    //!         samples
+	void transform( const double * sampsBegin, const double * pos, const double * sampsEnd );
+	
+//	--- inquiry ---
+
+    //! Return the length of the Fourier transforms.
+	size_type size( void ) const;	
+
+    //! Return read access to the short-time window samples.
+    //!	(Peers may need to know about the analysis window
+    //!	or about the scale factors in introduces.)
+	const std::vector< double > & window( void ) const;
+	
+
+//	--- reassigned transform access ---
+        
+	//! Compute and return the convergence indicator, computed from the 
+	//!	mixed partial derivative of spectral phase, optionally used in 
+	//!	BW enhanced analysis as a convergence indicator. The convergence
+	//!	value is on the range [0,1], 0 for a sinusoid, and 1 for an impulse.
+    //!
+    //! \param  idx the frequency sample at which to evaluate the
+    //!         transform
+	double convergence( long idx ) const;
+
+    //! Return the reassigned frequency in fractional frequency 
+    //! samples computed at the specified transform index.
+    //!
+    //! \param  idx the frequency sample at which to evaluate the
+    //!         transform
+	double reassignedFrequency( long idx ) const;
+
+    //! Return the spectrum magnitude (absolute)
+    //! computed at the specified transform index.
+    //!
+    //! \param  idx the frequency sample at which to evaluate the
+    //!         transform
+	double reassignedMagnitude( long idx ) const;
+
+    //! Return the phase in radians computed at the specified transform index.
+    //!	The reassigned phase is shifted to account for the time
+    //!	correction according to the corrected frequency.
+    //!
+    //!
+    //! \param  idx the frequency sample at which to evaluate the
+    //!         transform
+	double reassignedPhase( long idx ) const;	
+
+    //! Return the reassigned time in fractional samples
+    //! computed at the specified transform index.
+    //!
+    //! \param  idx the frequency sample at which to evaluate the
+    //!         transform
+	double reassignedTime( long idx ) const;
+
+//	--- reassignment operations ---
+	
+    //!	Compute the frequency correction at the specified frequency sample
+    //! using the method of Auger and Flandrin to evaluate the partial
+    //! derivative of spectrum phase w.r.t. time.
+    //!
+    //!	Correction is computed in fractional frequency samples, because
+    //!	that's the kind of frequency domain ramp we used on our window.
+    //!	sample is the frequency sample index, the nominal component 
+    //!	frequency in samples. 
+	double frequencyCorrection( long sample ) const;
+
+    //!	Compute the time correction at the specified frequency sample
+    //! using the method of Auger and Flandrin to evaluate the partial
+    //! derivative of spectrum phase w.r.t. frequency.
+    //!
+    //!	Correction is computed in fractional samples, because
+    //!	that's the kind of ramp we used on our window.
+	double timeCorrection( long sample ) const;
+
+//	--- legacy support ---
+
+    //  These members are deprecated, and included only
+    //  to support old code. New code should use the
+    //  corresponding documented members.
+    //  All of these members are deprecated.
+    
+    double reassignedPhase( long idx, double, double ) const
+        { return reassignedPhase( idx ); }
+    double reassignedMagnitude( double, long intBinNumber ) const
+        { return reassignedMagnitude( intBinNumber ); }
+    
+    //  subscript operator
+    //  The signature has changed, can no longer return a reference,
+    //  but since the reference returned was const, this version should 
+    //  keep most old code working, if not all.
+    std::complex< double > operator[]( unsigned long idx ) const;
+	
+private:
+
+//	-- window building helpers --
+
+    //	Build a pair of complex-valued windows, one having the frequency-ramp 
+    //  (time-derivative) window in the real part and the time-ramp window in the 
+    //  imagnary part, and the other having the unmodified window in the real part
+    //  and, if computing mixed deriviatives, the time-ramp time-derivative window
+    //  in the imaginary part.
+    //
+    //  Input is the unmodified window function.
+    void buildReassignmentWindows( const std::vector< double > & window );
+    
+    //	Build a pair of complex-valued windows, one having the frequency-ramp 
+    //  (time-derivative) window in the real part and the time-ramp window in the 
+    //  imagnary part, and the other having the unmodified window in the real part
+    //  and, if computing mixed deriviatives, the time-ramp time-derivative window
+    //  in the imaginary part.
+    //
+    //  Input is the unmodified window function and its time derivative, so the
+    //  DFT kludge is unnecessary.
+    void buildReassignmentWindows( const std::vector< double > & window,
+                                   const std::vector< double > & windowDerivative );    
+
+//	-- instance variables --
+
+	//! the FourierTransform for computing magnitude and phase
+	FourierTransform mMagnitudeTransform;
+	
+	//! the FourierTransform for computing time and frequency corrections
+	FourierTransform mCorrectionTransform;
+	
+	//! the original short-time analysis window samples
+	std::vector< double > mWindow;                          //  W(n)
+	
+	//! the complex window used to compute the 
+    //! magnitude/phase transform
+	std::vector< std::complex< double > > mCplxWin_W_Wtd;   //  real W(n), imag nW'(n)
+
+	//! the complex window used to compute the 
+    //! time/frequency correction transform
+	std::vector< std::complex< double > > mCplxWin_Wd_Wt;   //  real W'(n), imag nW(n)
+		
+};	//	end of class ReassignedSpectrum
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_REASSIGNEDSPECTRUM_H */
diff --git a/src/loris/Resampler.C b/src/loris/Resampler.C
new file mode 100644
index 0000000..be39674
--- /dev/null
+++ b/src/loris/Resampler.C
@@ -0,0 +1,398 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Resampler.C
+ *
+ * Implementation of class Resampler, for converting reassigned Partial envelopes
+ * into more conventional additive synthesis envelopes, having data points
+ * at regular time intervals. The benefits of reassigned analysis are NOT
+ * lost in this process, since the elimination of unreliable data and the
+ * reduction of temporal smearing are reflected in the resampled data.
+ *
+ * Lippold, 7 Aug 2003
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ *
+ * Phase correction added by Kelly 13 Dec 2005.
+ */
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "Resampler.h"
+#include "Breakpoint.h"
+#include "LinearEnvelope.h"
+#include "LorisExceptions.h"
+#include "Notifier.h"
+#include "Partial.h"
+#include "phasefix.h"
+
+#include <cmath>
+
+//	begin namespace
+namespace Loris {
+
+//  helper declarations:
+static Partial::iterator insert_resampled_at( Partial & newp, const Partial & p, 
+                                              double sampleTime, double insertTime );
+
+/*
+TODO
+    - remove empties (currently handled automatically in the Python module
+    
+    - remove insert_resampled_at
+    
+    - phase correct with timing?
+    
+    - fade time (for amplitude envelope sampling) - equal to interval? half?
+*/
+
+
+// ---------------------------------------------------------------------------
+//	constructor - sampling interval
+// ---------------------------------------------------------------------------
+//! Initialize a Resampler having the specified uniform sampling
+//! interval. Enable phase-correct resampling, in which frequencies
+//! of resampled Partials are modified (using fixFrequency) such 
+//! that the resampled phases are achieved in synthesis. Phase-
+//! correct resampling can be disabled using setPhaseCorrect.
+//!
+//! Resampled Partials will be composed of Breakpoints at every 
+//! integer multiple of the resampling interval.
+//!
+//! \sa setPhaseCorrect
+//! \sa fixFrequency
+//!
+//! \param  sampleInterval is the resampling interval in seconds, 
+//!         Breakpoint data is computed at integer multiples of
+//!         sampleInterval seconds.
+//! \throw  InvalidArgument if sampleInterval is not positive.
+//
+Resampler::Resampler( double sampleInterval ) :
+    interval_( sampleInterval ),
+    phaseCorrect_( true )
+{
+    if ( sampleInterval <= 0. )
+    {
+      Throw( InvalidArgument, "Resampler sample interval must be positive." );
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	setPhaseCorrect
+// ---------------------------------------------------------------------------
+//! Specify phase-corrected resampling, or not. If phase
+//! correct, Partial frequencies are altered slightly
+//! to match, as nearly as possible, the Breakpoint 
+//! phases after resampling. Phases are updated so that
+//! the Partial frequencies and phases are consistent after
+//! resampling.
+//!
+//! \param  correctPhase is a boolean flag specifying that 
+//!         (if true) frequency/phase correction should be
+//!         applied after resampling.
+void Resampler::setPhaseCorrect( bool correctPhase )
+{
+    phaseCorrect_ = correctPhase;
+}
+
+// ---------------------------------------------------------------------------
+//	resample
+// ---------------------------------------------------------------------------
+//! Resample a Partial using this Resampler's stored quanitization interval.
+//! If sparse resampling (the default) has be selected, Breakpoint times
+//! are quantized to integer multiples of the resampling interval.
+//! If dense resampling is selected, a Breakpoint will be provided at
+//! every integer multiple of the resampling interval in the time span of
+//! the Partial, starting and ending with the nearest multiples to the
+//! ends of the Partial. Frequencies and phases are corrected to be in 
+//! agreement and to match as nearly as possible the resampled phases if
+//! phase correct resampling is specified (the default). Resampling
+//! is performed in-place. 
+//!
+//! \param  p is the Partial to resample
+//
+void 
+Resampler::resample( Partial & p ) const
+{
+	debugger << "resampling Partial labeled " << p.label()
+	         << " having " << p.numBreakpoints() 
+			 << " Breakpoints" << endl;
+
+
+	//	create the new Partial:
+	Partial newp;
+	newp.setLabel( p.label() );
+
+	//  find time of first and last breakpoint for the resampled envelope:
+	double firstInsertTime = interval_ * int( 0.5 + p.startTime() / interval_ );
+	double lastInsertTime  = p.endTime() + ( 0.5 * interval_ );
+		
+	//  resample:
+	for (  double tins = firstInsertTime; tins <= lastInsertTime; tins += interval_ ) 
+	{
+	    //  sample time is obtained from the timing envelope, if specified, 
+	    //  otherwise same as the insert time:
+	    double tsamp = tins;
+        insert_resampled_at( newp, p, tins, tins );        
+	}
+	
+	//	store the new Partial:
+	p = newp;
+    
+	debugger << "resampled Partial has " << p.numBreakpoints() 
+			 << " Breakpoints" << endl;
+    
+    
+	if ( phaseCorrect_ )
+    {
+        fixFrequency( p ); // use default maxFixPct
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	resample
+// ---------------------------------------------------------------------------
+//! Resample a Partial using this Resampler's stored quanitization interval.
+//! If sparse resampling (the default) has be selected, Breakpoint times
+//! are quantized to integer multiples of the resampling interval.
+//! If dense resampling is selected, a Breakpoint will be provided at
+//! every integer multiple of the resampling interval in the time span of
+//! the Partial, starting and ending with the nearest multiples to the
+//! ends of the Partial. Frequencies and phases are corrected to be in 
+//! agreement and to match as nearly as possible the resampled phases if
+//! phase correct resampling is specified (the default). Resampling
+//! is performed in-place. 
+//!
+//! \param  p is the Partial to resample
+//!
+//! \param  timingEnv is the timing envelope, a map of Breakpoint 
+//!         times in resampled Partials onto parameter sampling 
+//!         instants in the original Partials.
+//!
+//! \throw  InvalidArgument if timingEnv has any negative breakpoint
+//!         times or values.
+//
+void 
+Resampler::resample( Partial & p, const LinearEnvelope & timingEnv ) const
+{
+	debugger << "resampling Partial labeled " << p.label()
+	         << " having " << p.numBreakpoints() 
+			 << " Breakpoints" << endl;
+
+
+    Assert(  0 != timingEnv.size() );
+    
+	//	create the new Partial:
+	Partial newp;
+	newp.setLabel( p.label() );
+
+	//  find the extent of the timing envelope, if specified, otherwise
+	//  the insert time range is the same as the sample time range:
+	double firstInsertTime = interval_ * int( 0.5 + timingEnv.begin()->first / interval_ );
+    double lastInsertTime = (--timingEnv.end())->first + ( 0.5 * interval_ );
+	
+	//  resample:
+	for (  double insertTime = firstInsertTime; 
+	       insertTime <= lastInsertTime; 
+	       insertTime += interval_ ) 
+	{
+	    //  sample time is obtained from the timing envelope, if specified, 
+	    //  otherwise same as the insert time:
+	    double sampleTime = timingEnv.valueAt( insertTime );	    	            
+        
+        //  make a resampled Breakpoint:
+        Breakpoint newbp = p.parametersAt( sampleTime );
+                
+        Partial::iterator ret_pos = newp.insert( insertTime, newbp );
+                
+	}
+		
+	//  remove excess null Breakpoints at the ends of the newly-formed
+	//  Partial, no simple way to anticipate these, without evaluating
+	//  the timing envelope at all points.
+	//
+	//  Also runs of nulls in the middle?
+	Partial::iterator it = newp.begin();
+	while( it != newp.end() && 0 == it->amplitude() )
+	{
+	    ++it;
+	}
+	newp.erase( newp.begin(), it );
+	
+	it = newp.end();
+	while( it != newp.begin() && 0 == (--it)->amplitude() )
+	{
+    }
+    if ( it != newp.end() )
+    {
+        newp.erase( ++it, newp.end() );
+    }
+	
+	//  is this a good idea? generally not.
+	if ( phaseCorrect_ && ( 0 != newp.numBreakpoints() ) )
+    {
+        fixFrequency( newp ); // use default maxFixPct
+    }
+    
+	//	store the new Partial:
+    p = newp;
+    
+    debugger << "resampled Partial has " << p.numBreakpoints() 
+			 << " Breakpoints" << endl;
+}
+
+// ---------------------------------------------------------------------------
+//	quantize
+// ---------------------------------------------------------------------------
+//! The Breakpoint times in the resampled Partial will comprise a  
+//! sparse sequence of integer multiples of the sampling interval,
+//! beginning with the multiple nearest to the Partial's start time and
+//! ending with the multiple nearest to the Partial's end time, and including
+//! only multiples that are near to Breakpoint times in the original Partial.
+//! Resampling is performed in-place. 
+//!
+//! \param  p is the Partial to resample
+//
+void Resampler::quantize( Partial & p ) const
+{
+	debugger << "quantizing Partial labeled " << p.label()
+	         << " having " << p.numBreakpoints() 
+			 << " Breakpoints" << endl;
+
+    //  for phase-correct quantization, first make the phases correct by
+    //  fixing them from the initial phase (ideally this should have
+    //  no effect but there's no way to be phase-correct after quantization
+    //  unless the phases start correct), then quantize the Breakpoint
+    //  times, then afterwards, adjust the frequencies to match
+    //  the interpolated phases:
+    if ( phaseCorrect_ )
+    {
+        fixPhaseForward( p.begin(), --p.end() );
+    }
+
+	//	create the new Partial:
+	Partial newp;
+	newp.setLabel( p.label() );
+	
+	Partial::const_iterator iter = p.begin();        
+	while( iter != p.end() )
+	{            
+	    const Breakpoint & bp = iter.breakpoint();
+	    double bpt = iter.time();
+	    
+	    //  find the nearest multiple of the quantization interval:
+        long qstep = long( 0.5 + ( bpt / interval_ ) );
+        
+        long endstep = qstep-1; //  guarantee first insertion
+        if ( newp.numBreakpoints() != 0 )
+        {
+            endstep = long( 0.5 + ( newp.endTime() / interval_ ) );
+        }
+        
+        //  insert a new Breakpoint if it does not duplicate
+        //  a previous insertion, or if it is a Null (needed
+        //  for phase-correction):
+        if ( (endstep != qstep) || (0 == bp.amplitude()) )
+        {        
+	        double qt = interval_ * qstep; 
+            
+            //  insert another Breakpoint and advance the Breakpoint 
+            //  iterator and the current time:
+            //
+            //  sample the Partial with a long fade time so that 
+            //  the amplitudes at the ends keep their original values:
+            const double a_long_time = 1.;
+            Breakpoint newbp = p.parametersAt( qt, a_long_time );
+            Partial::iterator new_pos = newp.insert( qt, newbp );
+            
+            //  tricky: if the quantized position (iter) is a null Breakpoint, 
+            //  we had better made the new position a null also, very important
+            //  for making phase resets happen at synthesis time. 
+            //
+            //  Also, if new_pos is earlier than iter, the phase should be rolled 
+            //  back from iter, rather than interpolated. If new_pos is later
+            //  than iter, then its phase will have been correctly interpolated.
+            if ( 0 == bp.amplitude() )
+            {
+                new_pos.breakpoint().setAmplitude( 0 );
+
+                if ( new_pos.time() < bpt )
+                {
+                    double dp = phaseTravel( new_pos.breakpoint(), bp,
+                                             bpt - new_pos.time() );
+                    new_pos.breakpoint().setPhase( bp.phase() - dp );
+                } 
+            }
+        }
+        ++iter;
+    }
+    
+    //  for phase-correct quantization, adjust the frequencies to match
+    //  the interpolated phases:
+    if ( phaseCorrect_ )
+    {
+        fixFrequency( newp, 5 );
+    }
+    
+    
+	debugger << "quantized Partial has " << newp.numBreakpoints() 
+			 << " Breakpoints" << endl;
+
+	//	store the new Partial:
+	p = newp;
+}
+
+// ---------------------------------------------------------------------------
+//	insert_resampled_at (helper)
+// ---------------------------------------------------------------------------
+//
+static Partial::iterator 
+insert_resampled_at( Partial & newp, const Partial & p, 
+                     double sampleTime, double insertTime )
+{
+    //  make a resampled Breakpoint:
+    Breakpoint newbp = p.parametersAt( sampleTime );
+    
+    //  handle end points to reduce error at ends
+    if ( sampleTime < p.startTime() )
+    {
+        newbp.setAmplitude( p.first().amplitude() );
+    }
+    else if ( sampleTime > p.endTime() )
+    {
+        newbp.setAmplitude( p.last().amplitude() );
+    }
+   
+    
+    Partial::iterator ret_pos = newp.insert( insertTime, newbp );
+    
+    debugger << "inserted Breakpoint having amplitude " << newbp.amplitude() 
+             << " at time " << insertTime << endl;
+             
+    return ret_pos;             
+}
+
+}	//	end of namespace Loris
+
diff --git a/src/loris/Resampler.h b/src/loris/Resampler.h
new file mode 100644
index 0000000..bc45eb3
--- /dev/null
+++ b/src/loris/Resampler.h
@@ -0,0 +1,449 @@
+#ifndef INCLUDE_RESAMPLER_H
+#define INCLUDE_RESAMPLER_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Resampler.h
+ *
+ * Definition of class Resampler, for converting reassigned Partial envelopes
+ * into more conventional additive synthesis envelopes, having data points
+ * at regular time intervals. The benefits of reassigned analysis are NOT
+ * lost in this process, since the elimination of unreliable data and the
+ * reduction of temporal smearing are reflected in the resampled data.
+ *
+ * Lippold, 7 Aug 2003
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "PartialList.h"
+#include "LinearEnvelope.h"
+
+//	begin namespace
+namespace Loris {
+
+class Partial;
+
+// ---------------------------------------------------------------------------
+//	class Resampler
+//
+//!	Class Resampler represents an algorithm for resampling Partial envelopes
+//!	at regular time intervals. Resampling makes the envelope data more suitable 
+//!	for exchange (as SDIF data, for example) with other applications that
+//!	cannot process raw (continuously-distributed) reassigned data. Resampling
+//!	will often greatly reduce the size of the data (by greatly reducing the 
+//!	number of Breakpoints in the Partials) without adversely affecting the
+//!	quality of the reconstruction.
+//
+class Resampler
+{
+//	--- public interface ---
+public:
+//	--- lifecycle ---
+
+    //! Initialize a Resampler having the specified uniform sampling
+    //! interval. Enable phase-correct resampling, in which frequencies
+    //! of resampled Partials are modified (using fixFrequency) such 
+    //! that the resampled phases are achieved in synthesis. Phase-
+    //! correct resampling can be disabled using setPhaseCorrect.
+    //!
+    //! Resampled Partials will be composed of Breakpoints at every 
+    //! integer multiple of the resampling interval.
+    //!
+    //! \sa setPhaseCorrect
+    //! \sa fixFrequency
+    //!
+    //! \param  sampleInterval is the resampling interval in seconds, 
+    //!         Breakpoint data is computed at integer multiples of
+    //!         sampleInterval seconds.
+    //!
+    //! \throw  InvalidArgument if sampleInterval is not positive.
+    explicit Resampler( double sampleInterval );
+
+
+    // --- use compiler-generated copy/assign/destroy ---
+    
+//  --- parameters ---
+
+    //! Specify phase-corrected resampling, or not. If phase
+    //! correct, Partial frequencies are altered slightly
+    //! to match, as nearly as possible, the Breakpoint 
+    //! phases after resampling. Phases are updated so that
+    //! the Partial frequencies and phases are consistent after
+    //! resampling.
+    //!
+    //! \param  correctPhase is a boolean flag specifying that 
+    //!         (if true) frequency/phase correction should be
+    //!         applied after resampling.
+    void setPhaseCorrect( bool correctPhase );
+    	
+//	--- resampling ---
+
+	//! Resample the specified Partial using the stored quanitization interval. 
+	//! The Breakpoint times will comprise a contiguous sequence of all integer 
+	//! multiples of the sampling interval, starting and ending with the nearest 
+	//! multiples to the ends of the Partial. If phase correct resampling is 
+	//! specified (the default)≤ frequencies and phases are corrected to be in 
+    //! agreement and to match as nearly as possible the resampled phases. 
+    //!
+    //! Resampling is performed in-place. 
+    //!
+    //! \param  p is the Partial to resample
+    void resample( Partial & p ) const;
+
+    //! Function call operator: same as resample( p ).
+    void operator() ( Partial & p ) const 
+    { 
+        resample( p ); 
+    }
+    
+	//! Resample the specified Partial using the stored quanitization interval. 
+	//! The Breakpoint times will comprise a contiguous sequence of all integer 
+	//! multiples of the sampling interval, starting and ending with the nearest 
+	//! multiples to the ends of the Partial. If phase correct resampling is 
+	//! specified (the default)≤ frequencies and phases are corrected to be in 
+    //! agreement and to match as nearly as possible the resampled phases. 
+    //!
+    //! The timing envelope represents a warping of the time axis that is 
+    //! applied during resampling. The Breakpoint times in resampled Partials 
+    //! will a comprise contiguous sequence of all integer multiples of the 
+    //! sampling interval between the first and last breakpoints in the timing 
+    //! envelope, and each Breakpoint will represent the parameters of the 
+    //! original Partial at the time that is the value of the timing envelope 
+    //! at that instant. 
+    //! 
+    //! Resampling is performed in-place. 
+    //!
+    //! \param  p is the Partial to resample
+    //!
+    //! \param  timingEnv is the timing envelope, a map of Breakpoint 
+    //!         times in resampled Partials onto parameter sampling 
+    //!         instants in the original Partials.
+    //!
+    //! \throw  InvalidArgument if timingEnv has any negative breakpoint
+    //!         times or values.
+    void resample( Partial & p, const LinearEnvelope & timingEnv ) const;
+    
+    //! Quantize the Breakpoint times using the specified Partial using the 
+    //! stored quanitization interval. Each Breakpoint in the Partial is 
+    //! replaced by a Breakpoint constructed by resampling the Partial at 
+    //! the nearest integer multiple of the of the resampling interval.
+    //! 
+    //! Quantization is performed in-place. 
+    //!
+    //! \param  p is the Partial to resample
+    void quantize( Partial & p ) const;
+
+	 
+	//! Resample all Partials in the specified (half-open) range using this
+	//! Resampler's stored quanitization interval. The Breakpoint times in 
+	//! resampled Partials will comprise a contiguous sequence of all integer 
+	//! multiples of the sampling interval, starting and ending with the nearest 
+	//! multiples to the ends of the Partial. If phase correct resampling is 
+	//! specified (the default)≤ frequencies and phases are corrected to be in 
+    //! agreement and to match as nearly as possible the resampled phases. 
+    //! 
+    //! Resampling is performed in-place. 
+	//!	
+	//!	\param begin is the beginning of the range of Partials to resample
+	//!	\param end is (one-past) the end of the range of Partials to resample
+	//!	
+	//!	If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+	//!	must be PartialList::iterators, otherwise they can be any type
+	//!	of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+	void resample( Iter begin, Iter end ) const;
+#else
+   inline 
+	void resample( PartialList::iterator begin, PartialList::iterator end  ) const;
+#endif	 
+
+	//!	Function call operator: same as resample( begin, end ).
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+	void operator()( Iter begin, Iter end ) const
+#else
+	void operator()( PartialList::iterator begin, PartialList::iterator end  ) const
+#endif	 
+	{ 
+	   resample( begin, end ); 
+	}
+ 
+	//! Resample all Partials in the specified (half-open) range using this
+	//! Resampler's stored quanitization interval. The Breakpoint times in 
+	//! resampled Partials will comprise a contiguous sequence of all integer 
+	//! multiples of the sampling interval, starting and ending with the nearest 
+	//! multiples to the ends of the Partial. If phase correct resampling is 
+	//! specified (the default)≤ frequencies and phases are corrected to be in 
+    //! agreement and to match as nearly as possible the resampled phases. 
+    //!
+    //! The timing envelope represents a warping of the time axis that is 
+    //! applied during resampling. The Breakpoint times in resampled Partials 
+    //! will a comprise contiguous sequence of all integer multiples of the 
+    //! sampling interval between the first and last breakpoints in the timing 
+    //! envelope, and each Breakpoint will represent the parameters of the 
+    //! original Partial at the time that is the value of the timing envelope 
+    //! at that instant. 
+    //! 
+    //! Resampling is performed in-place. 
+	//!	
+	//!	\param  begin is the beginning of the range of Partials to resample
+	//!	\param  end is (one-past) the end of the range of Partials to resample
+    //! \param  timingEnv is the timing envelope, a map of Breakpoint 
+    //!         times in resampled Partials onto parameter sampling 
+    //!         instants in the original Partials.
+	//!	
+	//!	If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+	//!	must be PartialList::iterators, otherwise they can be any type
+	//!	of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+	void resample( Iter begin, Iter end, const LinearEnvelope & timingEnv ) const;
+#else
+   inline 
+	void resample( PartialList::iterator begin, PartialList::iterator end,
+	               const LinearEnvelope & timingEnv) const;
+#endif	 
+
+    //! Quantize all Partials in the specified (half-open) range.
+    //! Each Breakpoint in the Partials is replaced by a Breakpoint
+    //! constructed by resampling the Partial at the nearest
+    //! integer multiple of the of the resampling interval.
+    //!	
+    //!	\param begin is the beginning of the range of Partials to quantize
+    //!	\param end is (one-past) the end of the range of Partials to quantize
+    //!	
+    //!	If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+    //!	must be PartialList::iterators, otherwise they can be any type
+    //!	of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+	void quantize( Iter begin, Iter end ) const;
+#else
+   inline 
+	void quantize( PartialList::iterator begin, PartialList::iterator end  ) const;
+#endif	 
+   	 
+// -- static members --
+
+	//! Static member that constructs an instance and applies
+	//! it to a sequence of Partials. 
+	//! Construct a Resampler using the specified resampling
+	//! interval, and use it to channelize a sequence of Partials. 
+	//!
+	//! \param  begin is the beginning of a sequence of Partials to 
+	//!         resample.
+	//! \param  end is the end of a sequence of Partials to 
+	//!         resample.
+	//! \param  sampleInterval is the resampling interval in seconds, 
+	//!         Breakpoint data is computed at integer multiples of
+	//!         sampleInterval seconds.
+    //! \param  denseResampling is a boolean flag indicating that dense
+    //!         resamping (Breakpoint at every integer multiple of the 
+    //!         resampling interval) should be performed. If false (the
+    //!         default), sparse resampling (Breakpoints only at multiples
+    //!         of the resampling interval near Breakpoint times in the
+    //!         original Partial) is performed.
+	//! \throw  InvalidArgument if sampleInterval is not positive.
+	//!	
+	//!	If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+	//!	must be PartialList::iterators, otherwise they can be any type
+	//!	of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template< typename Iter >
+	static 
+	void resample( Iter begin, Iter end, double sampleInterval, 
+	               bool denseResampling = false );
+#else
+	static inline 
+	void resample( PartialList::iterator begin, PartialList::iterator end,
+                  double sampleInterval, bool denseResampling = false );
+#endif	 
+
+//	--- instance variables ---
+private:
+    
+    //! the resampling interval in seconds
+    double interval_;	
+    
+    //! boolean flag selecting phase-corrected resampling
+    //! (default is true)
+    bool phaseCorrect_;
+	
+};	//	end of class Resampler
+
+// ---------------------------------------------------------------------------
+//	resample (sequence of Partials)
+// ---------------------------------------------------------------------------
+//! Resample all Partials in the specified (half-open) range using this
+//! Resampler's stored sampling interval, so that the Breakpoints in 
+//! the Partial envelopes will all lie on a common temporal grid.
+//! The Breakpoint times in the resampled Partial will comprise a  
+//! contiguous sequence of integer multiples of the sampling interval,
+//! beginning with the multiple nearest to the Partial's start time and
+//! ending with the multiple nearest to the Partial's end time. Resampling
+//! is performed in-place. 
+//!	
+//!	\param begin is the beginning of the range of Partials to resample
+//!	\param end is (one-past) the end of the range of Partials to resample
+//!	
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+//!	must be PartialList::iterators, otherwise they can be any type
+//!	of iterators over a sequence of Partials.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void Resampler::resample( Iter begin, Iter end ) const
+#else
+inline 
+void Resampler::resample( PartialList::iterator begin, PartialList::iterator end  ) const
+#endif	 
+{
+	while ( begin != end )
+	{
+		resample( *begin++ );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	resample (sequence of Partials, with timing envelope)
+// ---------------------------------------------------------------------------
+//! Resample all Partials in the specified (half-open) range using this
+//! Resampler's stored sampling interval, so that the Breakpoints in 
+//! the Partial envelopes will all lie on a common temporal grid.
+//! The Breakpoint times in the resampled Partial will comprise a  
+//! contiguous sequence of integer multiples of the sampling interval,
+//! beginning with the multiple nearest to the Partial's start time and
+//! ending with the multiple nearest to the Partial's end time. Resampling
+//! is performed in-place. 
+//!	
+//!	\param begin is the beginning of the range of Partials to resample
+//!	\param end is (one-past) the end of the range of Partials to resample
+//! \param  timingEnv is the timing envelope, a map of Breakpoint 
+//!         times in resampled Partials onto parameter sampling 
+//!         instants in the original Partials.
+//!	
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+//!	must be PartialList::iterators, otherwise they can be any type
+//!	of iterators over a sequence of Partials.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void Resampler::resample( Iter begin, Iter end, const LinearEnvelope & timingEnv ) const
+#else
+inline 
+void Resampler::resample( PartialList::iterator begin, PartialList::iterator end, 
+                          const LinearEnvelope & timingEnv  ) const
+#endif	 
+{
+	while ( begin != end )
+	{
+		resample( *begin++, timingEnv );
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	quantize (sequence of Partials)
+// ---------------------------------------------------------------------------
+//! Quantize all Partials in the specified (half-open) range.
+//! Each Breakpoint in the Partials is replaced by a Breakpoint
+//! constructed by resampling the Partial at the nearest
+//! integer multiple of the of the resampling interval.
+//!	
+//!	\param begin is the beginning of the range of Partials to quantize
+//!	\param end is (one-past) the end of the range of Partials to quantize
+//!	
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+//!	must be PartialList::iterators, otherwise they can be any type
+//!	of iterators over a sequence of Partials.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void Resampler::quantize( Iter begin, Iter end ) const
+#else
+inline 
+void Resampler::quantize( PartialList::iterator begin, PartialList::iterator end  ) const
+#endif	 
+{
+	while ( begin != end )
+	{
+		quantize( *begin++ );
+	}
+}
+
+
+// ---------------------------------------------------------------------------
+//	resample (static)
+// ---------------------------------------------------------------------------
+//! Static member that constructs an instance and applies
+//! phase-correct resampling to a sequence of Partials. 
+//! Construct a Resampler using the specified resampling
+//! interval, and use it to channelize a sequence of Partials. 
+//!
+//! \param  begin is the beginning of a sequence of Partials to 
+//!         resample.
+//! \param  end is the end of a sequence of Partials to 
+//!         resample.
+//! \param  sampleInterval is the resampling interval in seconds, 
+//!         Breakpoint data is computed at integer multiples of
+//!         sampleInterval seconds.
+//! \param  denseResampling is a boolean flag indicating that dense
+//!         resamping (Breakpoint at every integer multiple of the 
+//!         resampling interval) should be performed. If false (the
+//!         default), sparse resampling (Breakpoints only at multiples
+//!         of the resampling interval near Breakpoint times in the
+//!         original Partial) is performed.
+//! \throw  InvalidArgument if sampleInterval is not positive.
+//!	
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+//!	must be PartialList::iterators, otherwise they can be any type
+//!	of iterators over a sequence of Partials.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename Iter >
+void Resampler::resample( Iter begin, Iter end, double sampleInterval, 
+                          bool denseResampling )
+#else
+inline
+void Resampler::resample( PartialList::iterator begin, PartialList::iterator end,
+                          double sampleInterval, bool denseResampling )
+#endif	 
+{
+    Resampler instance( sampleInterval );
+    
+    if ( denseResampling )
+    {
+        instance.resample( begin, end );
+    }
+    else
+    {
+        instance.quantize( begin, end );
+    }
+}
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_RESAMPLER_H */
+
diff --git a/src/loris/SdifFile.C b/src/loris/SdifFile.C
new file mode 100644
index 0000000..9ca879e
--- /dev/null
+++ b/src/loris/SdifFile.C
@@ -0,0 +1,2176 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * SdifFile.C
+ *
+ * Implementation of class SdifFile, which reads and writes SDIF files.
+ *
+ * Lippold Haken, 4 July 2000, using CNMAT SDIF library
+ * Lippold Haken, 20 October 2000, using IRCAM SDIF library (tutorial by Diemo Schwarz)
+ * Lippold Haken, 22 December 2000, using 1LBL frames
+ * Lippold Haken, 27 March 2001, write only 7-column 1TRC, combine reading and writing classes
+ * Lippold Haken, 31 Jan 2002, write either 4-column 1TRC or 6-column RBEP
+ * Lippold Haken, 20 Apr 2004, back to using CNMAT SDIF library
+ * Lippold Haken, 06 Oct 2004, write 64-bit float files, read both 32-bit and 64-bit float
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+/*
+
+Portions of this code are from the CNMAT SDIF library.
+
+Copyright (c) 1996. 1997, 1998, 1999.  The Regents of the University of California
+(Regents). All Rights Reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation, without fee and without a signed licensing agreement, is hereby
+granted, provided that the above copyright notice, this paragraph and the
+following two paragraphs appear in all copies, modifications, and
+distributions.  Contact The Office of Technology Licensing, UC Berkeley, 2150
+Shattuck Avenue, Suite 510, Berkeley, CA 94720-1620, (510) 643-7201, for
+commercial licensing opportunities.
+
+Written by Matt Wright, Amar Chaudhary, and Sami Khoury, The Center for New
+Music and Audio Technologies, University of California, Berkeley.
+
+     IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
+     SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST
+     PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
+     DOCUMENTATION, EVEN IF REGENTS HAS BEEN ADVISED OF THE POSSIBILITY OF
+     SUCH DAMAGE.
+
+     REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
+     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+     FOR A PARTICULAR PURPOSE. THE SOFTWARE AND ACCOMPANYING
+     DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS".
+     REGENTS HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
+     ENHANCEMENTS, OR MODIFICATIONS.
+
+SDIF spec: http://www.cnmat.berkeley.edu/SDIF/
+
+*/
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "SdifFile.h"
+#include "LorisExceptions.h"
+#include "Notifier.h"
+#include "Partial.h"
+#include "PartialList.h"
+#include "PartialPtrs.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <list>
+#include <string>
+#include <vector>
+
+#if HAVE_M_PI
+	const double Pi = M_PI;
+#else
+	const double Pi = 3.14159265358979324;
+#endif
+
+using namespace std;
+
+//	begin namespace
+namespace Loris {
+
+// -- CNMAT SDIF definitions --
+// ---------------------------------------------------------------------------
+//	CNMAT SDIF types
+// ---------------------------------------------------------------------------
+
+//	try to use the information gathered by configure -- if not using 
+//  config.h, then pick some (hopefully-) reasonable values for
+//	these things and hope for the best...
+#if ! defined( SIZEOF_SHORT )
+#define SIZEOF_SHORT 2
+#endif
+
+#if ! defined( SIZEOF_INT )
+#define SIZEOF_INT 4
+#endif
+
+#if ! defined( SIZEOF_LONG )
+#define SIZEOF_LONG 4	
+#endif
+
+#if defined(SIZEOF_SHORT) && (SIZEOF_SHORT == 2)
+typedef unsigned short  sdif_unicode;
+typedef short           sdif_int16;
+#elif defined(SIZEOF_INT) && (SIZEOF_INT == 2)
+typedef unsigned int    sdif_unicode;
+typedef int             sdif_int16;
+#else
+#error "SdifFile.C: cannot identify a two-byte integer type, define SIZEOF_SHORT or SIZEOF_INT"
+#endif
+
+#if defined(SIZEOF_INT) && (SIZEOF_INT == 4)
+typedef int             sdif_int32;
+typedef unsigned int    sdif_uint32;
+#elif defined(SIZEOF_LONG) && (SIZEOF_LONG == 4)
+typedef long            sdif_int32;
+typedef unsigned long   sdif_uint32;
+#else
+#error "SdifFile.C: cannot identify a four-byte integer type, define SIZEOF_INT or SIZEOF_LONG"
+#endif
+
+// It is probably an unnecessary nuisance to check these, since there's
+// no alternative type to try. Requiring builders to define these 
+// symbols doesn't really serve any purpose. C++ doesn't provide a 
+// standard way to find a data type having a particular size 
+//  (as stdint.h does for interger types in C99).
+/*
+#if SIZEOF_FLOAT == 4
+typedef float           sdif_float32;
+#else
+#error "SdifFile.C: cannot identify a four-byte floating-point type"
+#endif
+
+#if SIZEOF_DOUBLE == 8
+typedef double          sdif_float64;
+#else
+#error "SdifFile.C: cannot identify a eight-byte floating-point type"
+#endif
+*/
+typedef float           sdif_float32;
+typedef double          sdif_float64;
+
+
+
+// ---------------------------------------------------------------------------
+//	SDIF_GlobalHeader
+// ---------------------------------------------------------------------------
+typedef struct {
+    char  SDIF[4];          /* must be 'S', 'D', 'I', 'F' */
+    sdif_int32 size;        /* size of header frame, not including SDIF or size. */
+    sdif_int32 SDIFversion;
+    sdif_int32 SDIFStandardTypesVersion;
+} SDIF_GlobalHeader;
+
+// ---------------------------------------------------------------------------
+//	SDIF_FrameHeader
+// ---------------------------------------------------------------------------
+typedef struct {
+    char         frameType[4];        /* should be a registered frame type */
+    sdif_int32   size;                /* # bytes in this frame, not including
+                                         frameType or size */
+    sdif_float64 time;                /* time corresponding to frame */
+    sdif_int32   streamID;            /* frames that go together have the same ID */
+    sdif_int32   matrixCount;         /* number of matrices in frame */
+} SDIF_FrameHeader;
+
+
+// ---------------------------------------------------------------------------
+//	SDIF_MatrixHeader
+// ---------------------------------------------------------------------------
+typedef struct {
+    char matrixType[4];
+    sdif_int32 matrixDataType;
+    sdif_int32 rowCount;
+    sdif_int32 columnCount;
+} SDIF_MatrixHeader;
+
+
+/* Version numbers for SDIF_GlobalHeader associated with this library */
+#define SDIF_SPEC_VERSION 3
+#define SDIF_LIBRARY_VERSION 1
+
+// ---------------------------------------------------------------------------
+//	Enumerations for type definitions in matrices.
+// ---------------------------------------------------------------------------
+typedef enum {
+    SDIF_FLOAT32 = 0x0004,
+    SDIF_FLOAT64 = 0x0008,
+    SDIF_INT16 = 0x0102,
+    SDIF_INT32 = 0x0104,
+    SDIF_INT64 = 0x0108,
+    SDIF_UINT32 = 0x0204,
+    SDIF_UTF8 = 0x0301,
+    SDIF_BYTE = 0x0401,
+    SDIF_NO_TYPE = -1
+} SDIF_MatrixDataType;
+
+typedef enum {
+    SDIF_FLOAT = 0,
+    SDIF_INT = 1,
+    SDIF_UINT = 2,
+    SDIF_TEXT = 3,
+    SDIF_ARBITRARY = 4
+} SDIF_MatrixDataTypeHighOrder;
+
+/* SDIF_GetMatrixDataTypeSize --
+   Find the size in bytes of the data type indicated by "d" */
+#define SDIF_GetMatrixDataTypeSize(d) ((d) & 0xff)
+
+// -- CNMAT SDIF errors --
+// ---------------------------------------------------------------------------
+//	CNMAT SDIF error handling machinery.
+// ---------------------------------------------------------------------------
+typedef enum {
+    ESDIF_SUCCESS=0,
+    ESDIF_SEE_ERRNO=1,
+    ESDIF_BAD_SDIF_HEADER=2,
+    ESDIF_BAD_FRAME_HEADER=3,
+    ESDIF_SKIP_FAILED=4,
+    ESDIF_BAD_MATRIX_DATA_TYPE=5,
+    ESDIF_BAD_SIZEOF=6,
+    ESDIF_END_OF_DATA=7,  /* Not necessarily an error */
+    ESDIF_BAD_MATRIX_HEADER=8,
+    ESDIF_OBSOLETE_FILE_VERSION=9,
+    ESDIF_OBSOLETE_TYPES_VERSION=10,
+    ESDIF_WRITE_FAILED=11,
+    ESDIF_READ_FAILED=12,
+    ESDIF_OUT_OF_MEMORY=13,  /* Used only by sdif-mem.c */
+    ESDIF_DUPLICATE_MATRIX_TYPE_IN_FRAME=14
+} SDIFresult;
+static const char *error_string_array[] = {
+    "Everything's cool",
+    "This program should display strerror(errno) instead of this string", 
+    "Bad SDIF header",
+    "Frame header's size is too low for time tag and stream ID",
+    "fseek() failed while skipping over data",
+    "Unknown matrix data type encountered in SDIF_WriteFrame().",
+    (char *) NULL,   /* this will be set by SizeofSanityCheck() */
+    "End of data",
+    "Bad SDIF matrix header",
+    "Obsolete SDIF file from an old version of SDIF",
+    "Obsolete version of the standard SDIF frame and matrix types",
+    "I/O error: couldn't write",
+    "I/O error: couldn't read",
+    "Out of memory",
+    "Frame has two matrices with the same MatrixType"
+};
+
+// -- CNMAT SDIF endian --
+// ---------------------------------------------------------------------------
+//	CNMAT SDIF little endian machinery.
+// ---------------------------------------------------------------------------
+
+//	WORDS_BIGENDIAN is defined (or not) in config.h, determined 
+//	at configure-time, changed from test of LITTLE_ENDIAN
+//	which might be erroneously defined in some standard header.
+
+//  If we didn't run configure, try to make a good guess.
+#if !(HAVE_CONFIG_H) && !defined(WORDS_BIGENDIAN)
+    #if (defined(__ppc__) || defined(__ppc64__))
+    #define WORDS_BIGENDIAN 1
+    #else
+    #undef WORDS_BIGENDIAN
+    #endif
+#endif
+
+#if !defined(WORDS_BIGENDIAN)
+#define BUFSIZE 4096
+static	char	p[BUFSIZE];
+#endif
+
+
+static SDIFresult SDIF_Write1(const void *block, size_t n, FILE *f) {
+    return (fwrite (block,1,n,f) == n) ? ESDIF_SUCCESS : ESDIF_WRITE_FAILED;
+}
+
+
+static SDIFresult SDIF_Write2(const void *block, size_t n, FILE *f) {
+#if !defined(WORDS_BIGENDIAN)
+    SDIFresult r;
+    const char *q = (const char *)block;
+    int	i, m = 2*n;
+
+    if ((n << 1) > BUFSIZE) {
+	/* Too big for buffer */
+	int num = BUFSIZE >> 1;
+	if (r = SDIF_Write2(block, num, f)) return r;
+	return SDIF_Write2(((char *) block) + (num<<1), n-num, f);
+    }
+
+    for (i = 0; i < m; i += 2) {
+	p[i] = q[i+1];
+	p[i+1] = q[i];
+    }
+
+    return (fwrite(p,2,n,f)==n) ? ESDIF_SUCCESS : ESDIF_WRITE_FAILED;
+
+#else
+    return (fwrite (block,2,n,f) == n) ? ESDIF_SUCCESS : ESDIF_WRITE_FAILED;
+#endif
+}
+
+
+
+static SDIFresult SDIF_Write4(const void *block, size_t n, FILE *f) {
+#if !defined(WORDS_BIGENDIAN)
+    SDIFresult r;
+   const char *q = (const char *)block;
+    int i, m = 4*n;
+
+    if ((n << 2) > BUFSIZE) 
+    {
+		int num = BUFSIZE >> 2;
+		if (r = SDIF_Write4(block, num, f)) return r;
+		return SDIF_Write4(((char *) block) + (num<<2), n-num, f);
+    }
+
+    for (i = 0; i < m; i += 4) 
+    {
+		p[i] = q[i+3];
+		p[i+3] = q[i];
+		p[i+1] = q[i+2];
+		p[i+2] = q[i+1];
+    }
+
+    return (fwrite(p,4,n,f) == n) ? ESDIF_SUCCESS : ESDIF_WRITE_FAILED;
+#else
+    return (fwrite(block,4,n,f) == n) ? ESDIF_SUCCESS : ESDIF_WRITE_FAILED;
+#endif
+}
+
+
+
+static SDIFresult SDIF_Write8(const void *block, size_t n, FILE *f) {
+#if !defined(WORDS_BIGENDIAN)
+    SDIFresult r;
+   const char *q = (const char *)block;
+    int i, m = 8*n;
+
+    if ((n << 3) > BUFSIZE) {
+	int num = BUFSIZE >> 3;
+	if (r = SDIF_Write8(block, num, f)) return r;
+	return SDIF_Write8(((char *) block) + (num<<3), n-num, f);
+    }
+
+    for (i = 0; i < m; i += 8) {
+	p[i] = q[i+7];
+	p[i+7] = q[i];
+	p[i+1] = q[i+6];
+	p[i+6] = q[i+1];
+	p[i+2] = q[i+5];
+	p[i+5] = q[i+2];
+	p[i+3] = q[i+4];
+	p[i+4] = q[i+3];
+    }
+
+    return (fwrite(p,8,n,f) == n) ? ESDIF_SUCCESS : ESDIF_WRITE_FAILED;
+#else
+    return (fwrite(block,8,n,f) == n) ? ESDIF_SUCCESS : ESDIF_WRITE_FAILED;
+#endif
+}
+
+
+static SDIFresult SDIF_Read1(void *block, size_t n, FILE *f) {
+    return (fread (block,1,n,f) == n) ? ESDIF_SUCCESS : ESDIF_READ_FAILED;
+}
+
+
+static SDIFresult SDIF_Read2(void *block, size_t n, FILE *f) {
+
+#if !defined(WORDS_BIGENDIAN)
+    SDIFresult r;
+    char *q = (char *)block;
+    int i, m = 2*n;
+
+    if ((n << 1) > BUFSIZE) {
+	int num = BUFSIZE >> 1;
+	if (r = SDIF_Read2(block, num, f)) return r;
+	return SDIF_Read2(((char *) block) + (num<<1), n-num, f);
+    }
+
+    if (fread(p,2,n,f) != n) return ESDIF_READ_FAILED;
+
+    for (i = 0; i < m; i += 2) {
+	q[i] = p[i+1];
+	q[i+1] = p[i];
+    }
+
+    return ESDIF_SUCCESS;
+#else
+    return (fread(block,2,n,f) == n) ? ESDIF_SUCCESS : ESDIF_READ_FAILED;
+#endif
+
+}
+
+
+static SDIFresult SDIF_Read4(void *block, size_t n, FILE *f) {
+#if !defined(WORDS_BIGENDIAN)
+    SDIFresult r;
+    char *q = (char *)block;
+    int i, m = 4*n;
+
+    if ((n << 2) > BUFSIZE) {
+	int num = BUFSIZE >> 2;
+	if (r = SDIF_Read4(block, num, f)) return r;
+	return SDIF_Read4(((char *) block) + (num<<2), n-num, f);
+    }
+
+    if (fread(p,4,n,f) != n) return ESDIF_READ_FAILED;
+
+    for (i = 0; i < m; i += 4) {
+	q[i] = p[i+3];
+	q[i+3] = p[i];
+	q[i+1] = p[i+2];
+	q[i+2] = p[i+1];
+    }
+
+    return ESDIF_SUCCESS;
+
+#else
+    return (fread(block,4,n,f) == n) ? ESDIF_SUCCESS : ESDIF_READ_FAILED;
+#endif
+
+}
+
+
+static SDIFresult SDIF_Read8(void *block, size_t n, FILE *f) {
+#if !defined(WORDS_BIGENDIAN)
+    SDIFresult r;
+    char *q = (char *)block;
+    int i, m = 8*n;
+
+    if ((n << 3) > BUFSIZE) {
+	int num = BUFSIZE >> 3;
+	if (r = SDIF_Read8(block, num, f)) return r;
+	return SDIF_Read8(((char *) block) + (num<<3), n-num, f);
+    }
+
+    if (fread(p,8,n,f) != n) return ESDIF_READ_FAILED;
+
+    for (i = 0; i < m; i += 8) {
+	q[i] = p[i+7];
+	q[i+7] = p[i];
+	q[i+1] = p[i+6];
+	q[i+6] = p[i+1];
+	q[i+2] = p[i+5];
+	q[i+5] = p[i+2];
+	q[i+3] = p[i+4];
+	q[i+4] = p[i+3];
+    }
+
+    return ESDIF_SUCCESS;
+
+#else
+    return (fread(block,8,n,f) == n) ? ESDIF_SUCCESS : ESDIF_READ_FAILED;
+#endif
+}
+
+// -- CNMAT SDIF intialization --
+// ---------------------------------------------------------------------------
+//	CNMAT SDIF initialization.
+// ---------------------------------------------------------------------------
+static int SizeofSanityCheck(void) {
+    int OK = 1;
+    static char errorMessage[sizeof("sizeof(sdif_float64) is 999!!!")];
+
+    if (sizeof(sdif_int16) != 2) {
+    	sprintf(errorMessage, "sizeof(sdif_int16) is %d!", (int)sizeof(sdif_int16));
+		OK = 0;
+    }
+
+    if (sizeof(sdif_int32) != 4) {
+    	sprintf(errorMessage, "sizeof(sdif_int32) is %d!", (int)sizeof(sdif_int32));
+		OK = 0;
+    }
+
+    if (sizeof(sdif_float32) != 4) {
+		sprintf(errorMessage, "sizeof(sdif_float32) is %d!", (int)sizeof(sdif_float32));
+		OK = 0;
+    }
+
+    if (sizeof(sdif_float64) != 8) {
+		sprintf(errorMessage, "sizeof(sdif_float64) is %d!", (int)sizeof(sdif_float64));
+		OK = 0;
+    }
+
+    if (!OK) {
+        error_string_array[ESDIF_BAD_SIZEOF] = errorMessage;
+    }
+    return OK;
+}
+
+
+
+static SDIFresult SDIF_Init(void) {
+	if (!SizeofSanityCheck()) {
+		return ESDIF_BAD_SIZEOF;
+	}
+	return ESDIF_SUCCESS;
+}
+
+// -- CNMAT SDIF frame header --
+// ---------------------------------------------------------------------------
+//	CNMAT SDIF frame headers.
+// ---------------------------------------------------------------------------
+static void SDIF_Copy4Bytes(char *target, const char *string) {
+    target[0] = string[0];
+    target[1] = string[1];
+    target[2] = string[2];
+    target[3] = string[3];
+}
+
+static int SDIF_Char4Eq(const char *ths, const char *that) {
+    return ths[0] == that[0] && ths[1] == that[1] &&
+	ths[2] == that[2] && ths[3] == that[3];
+}
+
+static void SDIF_FillGlobalHeader(SDIF_GlobalHeader *h) {
+    SDIF_Copy4Bytes(h->SDIF, "SDIF");
+    h->size = 8;
+    h->SDIFversion = SDIF_SPEC_VERSION;
+    h->SDIFStandardTypesVersion = SDIF_LIBRARY_VERSION;
+}
+
+static SDIFresult SDIF_WriteGlobalHeader(const SDIF_GlobalHeader *h, FILE *f) {
+#if !defined(WORDS_BIGENDIAN)
+    SDIFresult r;
+    if (r = SDIF_Write1(&(h->SDIF), 4, f)) return r;
+    if (r = SDIF_Write4(&(h->size), 1, f)) return r;
+    if (r = SDIF_Write4(&(h->SDIFversion), 1, f)) return r;
+    if (r = SDIF_Write4(&(h->SDIFStandardTypesVersion), 1, f)) return r;
+    return ESDIF_SUCCESS;
+#else
+
+    return (fwrite(h, sizeof(*h), 1, f) == 1) ?ESDIF_SUCCESS:ESDIF_WRITE_FAILED;
+
+#endif
+}
+
+static SDIFresult SDIF_ReadFrameHeader(SDIF_FrameHeader *fh, FILE *f) {
+#if !defined(WORDS_BIGENDIAN)
+    SDIFresult r;
+
+    if (SDIF_Read1(&(fh->frameType),4,f)) {
+    	if (feof(f)) {
+	    return ESDIF_END_OF_DATA;
+	}
+	return ESDIF_READ_FAILED;
+    }
+    if (r = SDIF_Read4(&(fh->size),1,f)) return r;
+    if (r = SDIF_Read8(&(fh->time),1,f)) return r;
+    if (r = SDIF_Read4(&(fh->streamID),1,f)) return r;
+    if (r = SDIF_Read4(&(fh->matrixCount),1,f)) return r;
+    return ESDIF_SUCCESS;
+#else
+    size_t amount_read;
+
+    amount_read = fread(fh, sizeof(*fh), 1, f);
+    if (amount_read == 1) return ESDIF_SUCCESS;
+    if (amount_read == 0) {
+	/* Now that fread failed, maybe we're at EOF. */
+	if (feof(f)) {
+	    return ESDIF_END_OF_DATA;
+	}
+    }
+    return ESDIF_READ_FAILED;
+#endif /* ! WORDS_BIGENDIAN */
+}
+
+
+static SDIFresult SDIF_WriteFrameHeader(const SDIF_FrameHeader *fh, FILE *f) {
+
+#if !defined(WORDS_BIGENDIAN)
+    SDIFresult r;
+
+    if (r = SDIF_Write1(&(fh->frameType),4,f)) return r;
+    if (r = SDIF_Write4(&(fh->size),1,f)) return r;
+    if (r = SDIF_Write8(&(fh->time),1,f)) return r;
+    if (r = SDIF_Write4(&(fh->streamID),1,f)) return r;
+    if (r = SDIF_Write4(&(fh->matrixCount),1,f)) return r;
+#ifdef __WIN32__
+    fflush(f);
+#endif
+    return ESDIF_SUCCESS;
+#else
+
+    return (fwrite(fh, sizeof(*fh), 1, f) == 1)?ESDIF_SUCCESS:ESDIF_WRITE_FAILED;
+
+#endif
+}
+
+static SDIFresult SkipBytes(FILE *f, int bytesToSkip) {
+#ifdef STREAMING
+    /* Can't fseek in a stream, so waste some time needlessly copying
+       some bytes in memory */
+    {
+#define BLOCK_SIZE 1024
+		char buf[BLOCK_SIZE];
+		while (bytesToSkip > BLOCK_SIZE) 
+		{
+		    if (fread (buf, BLOCK_SIZE, 1, f) != 1) 
+		    {
+				return ESDIF_READ_FAILED;
+		    }
+		    bytesToSkip -= BLOCK_SIZE;
+		}
+
+		if (fread (buf, bytesToSkip, 1, f) != 1) 
+		{
+		    return ESDIF_READ_FAILED;
+		}
+    }
+#else
+    /* More efficient implementation */
+    if (fseek(f, bytesToSkip, SEEK_CUR) != 0) 
+    {
+		return ESDIF_SKIP_FAILED;
+    }
+#endif
+   return ESDIF_SUCCESS;
+}
+
+static SDIFresult SDIF_SkipFrame(const SDIF_FrameHeader *head, FILE *f) {
+    /* The header's size count includes the 8-byte time tag, 4-byte
+       stream ID and 4-byte matrix count that we already read. */
+    int bytesToSkip = head->size - 16;
+
+    if (bytesToSkip < 0) {
+	return ESDIF_BAD_FRAME_HEADER;
+    }
+
+    return SkipBytes(f, bytesToSkip);
+}
+
+// -- CNMAT SDIF matrix header --
+// ---------------------------------------------------------------------------
+//	CNMAT SDIF matrix headers.
+// ---------------------------------------------------------------------------
+static SDIFresult SDIF_ReadMatrixHeader(SDIF_MatrixHeader *m, FILE *f) {
+#if !defined(WORDS_BIGENDIAN)
+    SDIFresult r;
+    if (r = SDIF_Read1(&(m->matrixType),4,f)) return r;
+    if (r = SDIF_Read4(&(m->matrixDataType),1,f)) return r;
+    if (r = SDIF_Read4(&(m->rowCount),1,f)) return r;
+    if (r = SDIF_Read4(&(m->columnCount),1,f)) return r;
+    return ESDIF_SUCCESS;
+#else
+    if (fread(m, sizeof(*m), 1, f) == 1) {
+	return ESDIF_SUCCESS;
+    } else {
+	return ESDIF_READ_FAILED;
+    }
+#endif
+
+}
+
+static SDIFresult SDIF_WriteMatrixHeader(const SDIF_MatrixHeader *m, FILE *f) {
+#if !defined(WORDS_BIGENDIAN)
+    SDIFresult r;
+    if (r = SDIF_Write1(&(m->matrixType),4,f)) return r;
+    if (r = SDIF_Write4(&(m->matrixDataType),1,f)) return r;
+    if (r = SDIF_Write4(&(m->rowCount),1,f)) return r;
+    if (r = SDIF_Write4(&(m->columnCount),1,f)) return r;
+    return ESDIF_SUCCESS;
+#else
+    return (fwrite(m, sizeof(*m), 1, f) == 1) ? ESDIF_SUCCESS:ESDIF_READ_FAILED;
+#endif
+}
+
+
+static int SDIF_GetMatrixDataSize(const SDIF_MatrixHeader *m) {
+    int size;
+    size = SDIF_GetMatrixDataTypeSize(m->matrixDataType) *
+	    m->rowCount * m->columnCount;
+
+    if ((size % 8) != 0) {
+        size += (8 - (size % 8));
+    }
+
+    return size;
+}
+
+static int SDIF_PaddingRequired(const SDIF_MatrixHeader *m) {
+    int size;
+    size = SDIF_GetMatrixDataTypeSize(m->matrixDataType) *
+            m->rowCount * m->columnCount;
+
+    if ((size % 8) != 0) {
+	return (8 - (size % 8));
+    } else {
+	return 0;
+    }
+}
+
+// -- CNMAT SDIF matrix data --
+// ---------------------------------------------------------------------------
+//	CNMAT SDIF matrix data.
+// ---------------------------------------------------------------------------
+static SDIFresult SDIF_SkipMatrix(const SDIF_MatrixHeader *head, FILE *f) {
+    int size = SDIF_GetMatrixDataSize(head);
+    
+    if (size < 0) {
+        return ESDIF_BAD_MATRIX_HEADER;
+    }
+    
+    return SkipBytes(f, size);
+}
+
+
+static SDIFresult SDIF_WriteMatrixPadding(FILE *f, const SDIF_MatrixHeader *head) {
+    int paddingBytes;
+    sdif_int32 paddingBuffer[2] = {0,0};
+    SDIFresult r;
+
+    paddingBytes = SDIF_PaddingRequired(head);
+    if ((r = SDIF_Write1(paddingBuffer, paddingBytes, f))) return r;
+
+    return ESDIF_SUCCESS;
+}
+
+
+static SDIFresult SDIF_WriteMatrixData(FILE *f, const SDIF_MatrixHeader *head, void *data) {
+    size_t datumSize = (size_t) SDIF_GetMatrixDataTypeSize(head->matrixDataType);
+    size_t numItems = (size_t) (head->rowCount * head->columnCount);
+
+#if !defined(WORDS_BIGENDIAN)
+	SDIFresult r;
+    switch (datumSize) {
+        case 1:
+            if (r = SDIF_Write1(data, numItems, f)) return r;
+            break;
+        case 2:
+            if (r = SDIF_Write2(data, numItems, f)) return r;
+            break;
+        case 4:
+            if (r = SDIF_Write4(data, numItems, f)) return r;
+            break;
+        case 8:
+            if (r = SDIF_Write8(data, numItems, f)) return r;
+            break;
+        default:
+            return ESDIF_BAD_MATRIX_DATA_TYPE;
+    }
+#else
+    if (fwrite(data, datumSize, numItems, f) != numItems) {
+        return ESDIF_READ_FAILED;
+    }
+#endif
+
+    /* Handle padding */
+    return SDIF_WriteMatrixPadding(f, head);
+}
+
+// -- CNMAT SDIF open and close --
+// ---------------------------------------------------------------------------
+//	CNMAT SDIF file open and close.
+// ---------------------------------------------------------------------------
+
+static SDIFresult SDIF_BeginWrite(FILE *output) {
+    SDIF_GlobalHeader h;
+
+    SDIF_FillGlobalHeader(&h);
+    return SDIF_WriteGlobalHeader(&h, output);
+}
+
+static SDIFresult SDIF_OpenWrite(const char *filename, FILE **resultp) {
+    FILE *result;
+    SDIFresult r;
+
+    if ((result = fopen(filename, "wb")) == NULL) 
+    {
+		return ESDIF_SEE_ERRNO;
+    }
+    if ((r = SDIF_BeginWrite(result))) 
+    {
+		fclose(result);
+		return r;
+    }
+    *resultp = result;
+    return ESDIF_SUCCESS;
+}
+
+static SDIFresult SDIF_CloseWrite(FILE *f) {
+    fflush(f);
+    if (fclose(f) == 0) {
+	return ESDIF_SUCCESS;
+    } else {
+	return ESDIF_SEE_ERRNO;
+    }
+}
+
+static SDIFresult SDIF_BeginRead(FILE *input) {
+    SDIF_GlobalHeader sgh;
+    SDIFresult r;
+
+    /* make sure the header is OK. */
+    if ((r = SDIF_Read1(sgh.SDIF, 4, input))) return r;
+    if (!SDIF_Char4Eq(sgh.SDIF, "SDIF")) return ESDIF_BAD_SDIF_HEADER;
+    if ((r = SDIF_Read4(&sgh.size, 1, input))) return r;
+    if (sgh.size % 8 != 0) return ESDIF_BAD_SDIF_HEADER;
+    if (sgh.size < 8) return ESDIF_BAD_SDIF_HEADER;
+    if ((r = SDIF_Read4(&sgh.SDIFversion, 1, input))) return r;
+    if ((r = SDIF_Read4(&sgh.SDIFStandardTypesVersion, 1, input))) return r;
+
+    if (sgh.SDIFversion < 3) {
+	return ESDIF_OBSOLETE_FILE_VERSION;
+    }
+
+    if (sgh.SDIFStandardTypesVersion < 1) {
+	return ESDIF_OBSOLETE_TYPES_VERSION;
+    }
+
+    /* skip size-8 bytes.  (We already read the first two version numbers,
+       but maybe there's more data in the header frame.) */
+
+    if (sgh.size == 8) {
+	return ESDIF_SUCCESS;
+    }
+
+    if (SkipBytes(input, sgh.size-8)) {
+	return ESDIF_BAD_SDIF_HEADER;
+    }
+
+    return ESDIF_SUCCESS;
+}
+
+static SDIFresult SDIF_OpenRead(const char *filename, FILE **resultp) {
+    FILE *result = NULL;
+    SDIFresult r;
+
+    if ((result = fopen(filename, "rb")) == NULL) {
+        return ESDIF_SEE_ERRNO;
+    }
+
+    if ((r = SDIF_BeginRead(result))) {
+        fclose(result);
+        return r;
+    }
+
+    *resultp = result;
+    return ESDIF_SUCCESS;
+}
+
+static SDIFresult SDIF_CloseRead(FILE *f) {
+    if (fclose(f) == 0) {
+	return ESDIF_SUCCESS;
+    } else {
+	return ESDIF_SEE_ERRNO;
+    }
+}
+
+// -- construction --
+						 
+// ---------------------------------------------------------------------------
+//	SdifFile construction helpers
+// ---------------------------------------------------------------------------
+
+// import_sdif reads SDIF data from the specified file path and
+// stores data in its PartialList and MarkerContainer arguments.
+static void import_sdif( const std::string &, SdifFile::partials_type &, 
+						 SdifFile::markers_type & );
+
+// export_sdif writes the data in its  PartialList and MarkerContainer 
+// arguments to a specified SDIF file path. Writes bandwidth-enhanced
+// Partials if enhanced is true, otherwise writes sinusoidal partials.
+static void export_sdif( const std::string &, const SdifFile::partials_type &, 
+						 const SdifFile::markers_type &, bool enhanced );
+						 
+// ---------------------------------------------------------------------------
+//	SdifFile constructor from filename
+// ---------------------------------------------------------------------------
+//	Initialize an instance of SdifFile by importing Partial data from 
+//	from the file having the specified filename or path.
+//
+SdifFile::SdifFile( const std::string & filename )
+{
+	import_sdif( filename, partials_, markers_ );
+}
+
+// ---------------------------------------------------------------------------
+//	SdifFile constructor, empty
+// ---------------------------------------------------------------------------
+//	Initialize an empty instance of SdifFile having no Partials. 
+//
+SdifFile::SdifFile( void )
+{
+}
+
+// -- access --
+// ---------------------------------------------------------------------------
+//	markers
+// ---------------------------------------------------------------------------
+//	Return a reference to the MarkerContainer (see Marker.h) for this SdifFile. 
+SdifFile::markers_type & SdifFile::markers( void )
+{
+	return markers_;
+}
+
+const SdifFile::markers_type & SdifFile::markers( void ) const  
+{
+	return markers_;
+}
+
+// ---------------------------------------------------------------------------
+//	partials
+// ---------------------------------------------------------------------------
+//	Return a reference (or const reference) to the bandwidth-enhanced
+//	Partials represented by the envelope parameter streams in this SdifFile.
+SdifFile::partials_type & SdifFile::partials( void ) 
+{ 
+	return partials_; 
+}
+
+const SdifFile::partials_type & SdifFile::partials( void ) const 
+{ 
+	return partials_; 
+}
+
+// -- mutation --
+// ---------------------------------------------------------------------------
+//	addPartial
+// ---------------------------------------------------------------------------
+//	Add a copy of the specified Partial to this SdifFile.
+//
+//	This member exists only for consistency with other File I/O
+//	classes in Loris. The same operation can be achieved by directly
+//	accessing the PartialList.
+//
+void SdifFile::addPartial( const Loris::Partial & p )
+{
+	partials_.push_back( p );
+}
+
+// ---------------------------------------------------------------------------
+//	write (to path)
+// ---------------------------------------------------------------------------
+//	Export the envelope Partials represented by this SdifFile to
+//	the file having the specified filename or path.
+//
+void SdifFile::write( const std::string & path )
+{
+	export_sdif( path, partials_, markers_, true );
+}
+
+// ---------------------------------------------------------------------------
+//	write (to path)
+// ---------------------------------------------------------------------------
+//	Export the envelope Partials represented by this SdifFile to
+//	the file having the specified filename or path in the 1TRC
+//	format, resampled, and without phase or bandwidth information.
+//
+void SdifFile::write1TRC( const std::string & path )
+{
+	export_sdif( path, partials_, markers_, false );
+}
+
+
+// -- Loris SDIF definitions --
+// ---------------------------------------------------------------------------
+//	Loris SDIF types
+// ---------------------------------------------------------------------------
+//	Row of matrix data in SDIF RBEP, 1TRC, or RBEL format.
+//
+//  The RBEP matrices are for reassigned bandwidth enhanced partials (in 6 columns).
+//	The 1TRC matrices are for sine-only partials (in 4 columns).
+//  The first four columns of an RBEP matrix correspond to the 4 columns in 1TRC.
+//	In the past, Loris exported a 7-column 1TRC; this is no longer exported, but can be imported.
+//
+//	The RBEL format always has two columns, index and partial label.
+//	The RBEL matrix is optional; it has partial label information (in 2 columns).
+int lorisRowMaxElements = 7;
+int lorisRowEnhancedElements = 6;
+int lorisRowSineOnlyElements = 4;
+
+typedef struct {
+    sdif_float64 index, freqOrLabel, amp, phase, noise, timeOffset, resampledFlag;
+} RowOfLorisData64;
+
+typedef struct {
+    sdif_float32 index, freqOrLabel, amp, phase, noise, timeOffset, resampledFlag;
+} RowOfLorisData32;
+
+
+//  SDIF signatures used by Loris.
+typedef char sdif_signature[4];
+static sdif_signature lorisEnhancedSignature = { 'R','B','E','P' };
+static sdif_signature lorisLabelsSignature = { 'R','B','E','L' };
+static sdif_signature lorisSineOnlySignature = { '1','T','R','C' };
+static sdif_signature lorisMarkersSignature = { 'R','B','E','M' };
+
+
+//	Exception class for handling errors in SDIF library:
+class SdifLibraryError : public FileIOException
+{
+public:
+	SdifLibraryError( const std::string & str, const std::string & where = "" ) : 
+		FileIOException( std::string("SDIF library error -- ").append( str ), where ) {}
+};	//	end of class SdifLibraryError
+
+//	macro to check for SDIF library errors and throw exceptions when
+//	they occur, which we really ought to do after every SDIF library
+//	call:
+#define ThrowIfSdifError( errNum, report )										\
+	if (errNum)																	\
+	{																			\
+		const char* errPtr = error_string_array[errNum];								\
+		if (errPtr)																\
+		{																		\
+	        debugger << "SDIF error " << errPtr << endl;						\
+			std::string s(report);												\
+			s.append(", SDIF error message: ");									\
+			s.append(errPtr);													\
+			Throw( SdifLibraryError, s );										\
+		}																		\
+	}	
+
+// -- SDIF reading helpers --
+// ---------------------------------------------------------------------------
+//	processRow64
+// ---------------------------------------------------------------------------
+//	Add to existing Loris partials, or create new Loris partials for this data.
+//
+static void
+processRow64( const sdif_signature msig, const RowOfLorisData64 & rowData, const double frameTime, 
+				  std::vector< Partial > & partialsVector )
+{	
+
+//
+// Skip this if the data point is not from the original data (7-column 1TRC format).
+//
+	if (rowData.resampledFlag)
+		return;
+	
+//
+// Make sure we have enough partials for this partial's index.
+//
+	if (partialsVector.size() <= rowData.index)
+	{
+		partialsVector.resize( long(rowData.index) + 500 );
+	}
+
+//
+// Create a new breakpoint and insert it.
+//	
+	if (SDIF_Char4Eq(msig, lorisEnhancedSignature) || SDIF_Char4Eq(msig, lorisSineOnlySignature)) 
+	{
+		Breakpoint newbp( rowData.freqOrLabel, rowData.amp, rowData.noise, rowData.phase );
+		partialsVector[long(rowData.index)].insert( frameTime + rowData.timeOffset, newbp );
+	}
+//
+// Set partial label.
+//
+	else if (SDIF_Char4Eq(msig, lorisLabelsSignature)) 
+	{
+		partialsVector[long(rowData.index)].setLabel( (int) rowData.freqOrLabel );
+	}
+		
+}
+
+// ---------------------------------------------------------------------------
+//	processRow32
+// ---------------------------------------------------------------------------
+//	Add to existing Loris partials, or create new Loris partials for this data.
+//  This is for reading 32-bit float files.
+//
+static void
+processRow32( const sdif_signature msig, const RowOfLorisData32 & rowData, const double frameTime, 
+				  std::vector< Partial > & partialsVector )
+{	
+
+//
+// Skip this if the data point is not from the original data (7-column 1TRC format).
+//
+	if (rowData.resampledFlag)
+		return;
+	
+//
+// Make sure we have enough partials for this partial's index.
+//
+	if (partialsVector.size() <= rowData.index)
+	{
+		partialsVector.resize( long(rowData.index) + 500 );
+	}
+
+//
+// Create a new breakpoint and insert it.
+//	
+	if (SDIF_Char4Eq(msig, lorisEnhancedSignature) || SDIF_Char4Eq(msig, lorisSineOnlySignature)) 
+	{
+		Breakpoint newbp( rowData.freqOrLabel, rowData.amp, rowData.noise, rowData.phase );
+		partialsVector[long(rowData.index)].insert( frameTime + rowData.timeOffset, newbp );
+	}
+//
+// Set partial label.
+//
+	else if (SDIF_Char4Eq(msig, lorisLabelsSignature)) 
+	{
+		partialsVector[long(rowData.index)].setLabel( (int) rowData.freqOrLabel );
+	}
+		
+}
+
+// ---------------------------------------------------------------------------
+//	readMarkers
+// ---------------------------------------------------------------------------
+//
+static void
+readMarkers( FILE * file, SDIF_FrameHeader fh, SdifFile::markers_type & markersVector )
+{
+//
+// Read Loris markers from SDIF file in a RBEM frame.
+// This precedes the envelope data in the file.
+// Let exceptions propagate.
+//
+	SDIFresult ret;
+	int cols = 1;
+//
+// The frame must contain exactly two matrices.
+//
+	if (fh.matrixCount != 2)
+	{
+		Throw( FileIOException, "Markers frame has bad format." );
+	}
+
+//							
+// Read the numeric (marker times) matrix.
+//
+	{
+		SDIF_MatrixHeader mh;
+	    ret = SDIF_ReadMatrixHeader(&mh,file);
+		ThrowIfSdifError( ret, "Error reading SDIF file" );
+		
+		// Error if matrix has unexpected data type.
+		if ((mh.matrixDataType != SDIF_FLOAT32 && mh.matrixDataType != SDIF_FLOAT64) || mh.columnCount != cols) 
+		{
+			Throw( FileIOException, "Markers frame has bad format." );
+		}
+		
+		// Read each row of matrix data.
+		for (int row = 0; row < mh.rowCount; row++)
+		{
+			if (mh.matrixDataType == SDIF_FLOAT64)
+			{
+				sdif_float64 markerTime64;
+				SDIF_Read8(&markerTime64,1,file);
+				markersVector.push_back(Marker(markerTime64, ""));
+			}
+			else
+			{
+				sdif_float32 markerTime32;
+				SDIF_Read4(&markerTime32,1,file);
+				markersVector.push_back(Marker(markerTime32, ""));
+			}
+		}
+		
+		// Skip over padding, if any.
+		if ((mh.matrixDataType == SDIF_FLOAT32) && ((mh.rowCount * mh.columnCount) & 0x1)) 
+		{
+		    sdif_float32 pad;
+		    SDIF_Read4(&pad,1,file);
+		}
+	}
+	
+//							
+// Read the string (marker names) matrix.
+//
+	{
+		SDIF_MatrixHeader mh;
+	    ret = SDIF_ReadMatrixHeader(&mh,file);
+		ThrowIfSdifError( ret, "Error reading SDIF file" );
+		
+		// Error if matrix has unexpected data type.
+		if (mh.matrixDataType != SDIF_UTF8 || mh.columnCount != cols) 
+		{
+			Throw( FileIOException, "Markers frame has bad format." );
+		}
+		
+		// Read strings.
+		std::string markerName;
+		int markerNumber = 0;
+		for (int row = 0; row < mh.rowCount; row++)
+		{
+			char ch;
+			SDIF_Read1(&ch,1,file);
+			
+			// If we have reached the end of a name, assign it to a marker.
+			if (ch == '\0')
+			{
+				// Save the name of the marker.
+				markersVector[markerNumber].setName(markerName);
+				
+				// Prepare to get name of next marker.
+				markerNumber++;
+				if (markerNumber > markersVector.size()) 
+				{
+					Throw( FileIOException, "Markers frame has bad format." );
+				}
+				markerName.erase();
+			}
+			else
+			{
+				markerName += ch;
+			}
+		}
+			
+		// There should be one marker name for each marker time.
+		if (markerNumber != markersVector.size()) 
+		{
+			Throw( FileIOException, "Markers frame has bad format." );
+		}
+		
+		// Skip padding.
+		ret = SkipBytes(file, SDIF_PaddingRequired(&mh));
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	readLorisMatrices
+// ---------------------------------------------------------------------------
+// Let exceptions propagate.
+//
+static void
+readLorisMatrices( FILE *file, std::vector< Partial > & partialsVector, SdifFile::markers_type & markersVector )
+{
+	SDIFresult ret;
+
+//
+// Read all frames matching the file selection.
+//
+	SDIF_FrameHeader fh;
+	while (!(ret = SDIF_ReadFrameHeader(&fh, file)))
+	{	
+
+		// Check for Loris Markers frame.
+		if (SDIF_Char4Eq(fh.frameType, lorisMarkersSignature))
+		{
+			readMarkers( file, fh, markersVector );
+			continue;		
+		}
+			
+		// Skip frames until we find one we are interested in.
+		if (!SDIF_Char4Eq(fh.frameType, lorisEnhancedSignature) 
+					&& !SDIF_Char4Eq(fh.frameType, lorisSineOnlySignature) 
+					&& !SDIF_Char4Eq(fh.frameType, lorisLabelsSignature))
+		{
+			ret = SDIF_SkipFrame(&fh, file);	
+			ThrowIfSdifError( ret, "Error reading SDIF file" );
+			continue;		
+		}
+		
+
+		// Read all matrices in this frame.
+		for (int m = 0; m < fh.matrixCount; m++)
+		{
+			SDIF_MatrixHeader mh;
+		    ret = SDIF_ReadMatrixHeader(&mh,file);
+			ThrowIfSdifError( ret, "Error reading SDIF file" );
+			
+			// Skip matrix if it has unexpected data type.
+			if ((mh.matrixDataType != SDIF_FLOAT32 && mh.matrixDataType != SDIF_FLOAT64) 
+							|| mh.columnCount > lorisRowMaxElements) 
+			{
+				ret = SDIF_SkipMatrix(&mh, file);	
+				ThrowIfSdifError( ret, "Error reading SDIF file" );
+				continue;		
+			}
+			
+			// Read each row of matrix data.
+			for (int row = 0; row < mh.rowCount; row++)
+			{
+			
+				if (mh.matrixDataType == SDIF_FLOAT64)
+				{
+					// Fill a rowData structure with one row from the matrix.
+					RowOfLorisData64 rowData64 = { 0.0 };
+					sdif_float64 *rowDataPtr = &rowData64.index;
+					for (int col = 1; col <= mh.columnCount; col++)
+					{
+						SDIF_Read8(rowDataPtr++,1,file);
+					}
+					
+					// Add rowData as a new breakpoint in a partial, or,
+					// if its a RBEL matrix, read label mapping.
+					processRow64(mh.matrixType, rowData64, fh.time, partialsVector);
+				}
+				else
+				{
+					// Fill a rowData structure with one row from the matrix.
+					RowOfLorisData32 rowData32 = { 0.0 };
+					sdif_float32 *rowDataPtr = &rowData32.index;
+					for (int col = 1; col <= mh.columnCount; col++)
+					{
+						SDIF_Read4(rowDataPtr++,1,file);
+					}
+					
+					// Add rowData as a new breakpoint in a partial, or,
+					// if its a RBEL matrix, read label mapping.
+					processRow32(mh.matrixType, rowData32, fh.time, partialsVector);
+				}
+			}
+			
+			// Skip over padding, if any.
+			if ((mh.matrixDataType == SDIF_FLOAT32) && ((mh.rowCount * mh.columnCount) & 0x1)) 
+			{
+			    sdif_float32 pad;
+			    SDIF_Read4(&pad,1,file);
+			}
+		}
+	} 
+	
+	// At this point, ret should be ESDIF_END_OF_DATA.
+	if (ret != ESDIF_END_OF_DATA)
+		ThrowIfSdifError( ret, "Error reading SDIF file" );
+}
+
+// ---------------------------------------------------------------------------
+//	read
+// ---------------------------------------------------------------------------
+// Let exceptions propagate.
+//
+static void import_sdif( const std::string &infilename, 
+						 SdifFile::partials_type & partials, 
+						 SdifFile::markers_type & markers)
+{
+
+//
+// Initialize CNMSAT SDIF routines.
+//
+	SDIFresult ret = SDIF_Init();
+	if (ret)
+	{
+		Throw( FileIOException, "Could not initialize SDIF routines." );
+	}
+
+//
+// Open SDIF file for reading.
+// Note: Currently we do not specify any selection criterion in this call.
+//
+	FILE *file;
+	ret = SDIF_OpenRead(infilename.c_str(), &file);
+	if (ret)
+	{
+		Throw( FileIOException, "Could not open SDIF file for reading." );
+	}
+
+//
+// Read SDIF data.
+//	
+	try 
+	{
+	
+		// Build up partialsVector.
+		std::vector< Partial > partialsVector;
+		SdifFile::markers_type markersVector;
+		readLorisMatrices( file, partialsVector, markersVector );
+		
+		// Copy partialsVector to partials list.
+		for (int i = 0; i < partialsVector.size(); ++i)
+		{
+			if (partialsVector[i].numBreakpoints() > 0)
+			{
+				partials.push_back( partialsVector[i] );
+			}
+		}
+		
+		// Copy markersVector to markers list.
+		for (int i = 0; i < markersVector.size(); ++i)
+		{
+			markers.push_back( markersVector[i] );
+		}
+	}
+	catch ( Exception & ex ) 
+	{
+		partials.clear();
+		markers.clear();
+		ex.append(" Failed to read SDIF file.");
+		SDIF_CloseRead(file);
+		throw;
+	}
+
+//
+// Close SDIF input file.
+//
+	SDIF_CloseRead(file);
+	
+//
+// Complain if no Partials were imported:
+//
+	if ( partials.size() == 0 )
+	{
+		notifier << "No Partials were imported from " << infilename 
+				 << ", no (non-empty) SDIF frames found." << endl;
+	}
+	
+}
+
+// -- SDIF writing helpers --
+// ---------------------------------------------------------------------------
+//	makeSortedBreakpointTimes
+// ---------------------------------------------------------------------------
+//	Collect the times of all breakpoints in the analysis, and sort by time.
+//  Sorted breakpoints are used in finding frame start times in SDIF writing.
+//
+struct BreakpointTime
+{
+	long index;			// index identifying which partial has the breakpoint
+	double time;        // time of the breakpoint
+};
+
+struct earlier_time
+{
+	bool operator()( const BreakpointTime & lhs, const BreakpointTime & rhs ) const
+		{ return lhs.time < rhs.time; }
+};
+
+static void
+makeSortedBreakpointTimes( const ConstPartialPtrs & partialsVector, 
+						   std::list< BreakpointTime > & allBreakpoints ) 
+{
+
+// Make list of all breakpoint times from all partials.
+	for (int i = 0; i < partialsVector.size(); i++) 
+	{
+		for ( Partial::const_iterator it = partialsVector[i]->begin(); 
+			  it != partialsVector[i]->end();
+			  ++it ) 
+		{
+			BreakpointTime bpt;
+			bpt.index = i;
+			bpt.time = it.time();
+			allBreakpoints.push_back( bpt );
+		}
+	}
+
+// Sort list of all breakpoint times.
+	allBreakpoints.sort( earlier_time() );
+}
+
+// ---------------------------------------------------------------------------
+//	getNextFrameTime
+// ---------------------------------------------------------------------------
+//	Get time of next frame.
+//  This helps make SDIF files with exact timing (7-column 1TRC format).
+//  This uses the previously sorted allBreakpoints list.
+//
+//	All Breakpoints should be const, but for some reason, gcc (on SGI at 
+//	least) makes trouble converting and comparing iterators and const_iterators.
+//
+static double getNextFrameTime( const double frameTime,
+								std::list< BreakpointTime > & allBreakpoints,
+								std::list< BreakpointTime >::iterator & bpTimeIter)
+{
+//
+// Build up vector of partials that have a breakpoint in this frame, update the vector
+// as we increase the frame duration.  Return when a partial gets a second breakpoint.
+//
+// This vector is only used locally. We search this vector of indices to determine
+// whether or not a Partial has already contributed a Breakpoint to the current 
+// frame.
+//
+	double nextFrameTime = frameTime;
+	std::vector< long > partialsWithBreakpointsInFrame;
+	
+	// const std::list< BreakpointTime >::iterator & first = bpTimeIter;
+	
+	//	invariant:
+	//	Breakpoints in allBreakpoints before the position
+	//	of bpTimeIter have be added to a SDIF frame, either
+	//	the current one or an earlier one. If it is not
+	//	equal to bpTimeIter, then all Breakpoints between
+	// 	those two positions have the same time.
+	std::list< BreakpointTime >::iterator it = bpTimeIter;
+	while ( it != allBreakpoints.end() && 
+			( std::find( partialsWithBreakpointsInFrame.begin(),
+		                 partialsWithBreakpointsInFrame.end(),
+		                 it->index ) == 
+              partialsWithBreakpointsInFrame.end() ) )
+	{		
+		// Add breakpoint to list of potential breakpoints for frame, 
+		// then iterate to soonest breakpoint on any partial.  The final decision
+		// to add this breakpoint to the frame is made below, if bpTimeIter is 
+		// updated.
+		partialsWithBreakpointsInFrame.push_back( it->index );
+		
+		
+		//  If the new breakpoint is at a new time, it could potentially be the
+		//	first breakpoint in the next frame. If there are several breakpoints at
+		//	the exact same time (could happen if these envelopes came from a spc
+		//	file or from resampled envelopes), always start the frame at the first
+		//  of these.  Set bpTimeIter if this is a good start of a new frame.
+		//
+		//	Don't want to increment bpTimeIter until we are certain that all 
+		//	coincident Breakpoints can be added to the current frame (that is,
+		//	that none of them are from Partials that already have a Breakpoint
+		//	in this frame).
+        //
+        //  epsilon controls how close together in time two breakpoints can be.        
+        //  Keep this large enough that double-precision floating point math
+        //  can find a time between two breakpoints close in time. One nanosecond
+        //  ought to be plenty close.
+		++it;
+        const double epsilon = 1e-9;
+		if ( ( it == allBreakpoints.end() ) || ( (it->time - bpTimeIter->time) > epsilon ) )
+		{
+			bpTimeIter = it;
+		}
+	}
+
+	if ( bpTimeIter == allBreakpoints.end() )
+	{
+		//	We are at the end of the sound; no "next frame" there,
+		//	set the next frame time to something later than the last
+		//	Breakpoint and the current frame time (the current frame
+		//	might be empty, so have to check both).
+		nextFrameTime = std::max( (double)allBreakpoints.back().time, frameTime ) + 1;
+	}
+	else
+	{
+		Assert( bpTimeIter != allBreakpoints.begin() );
+		
+		//	Compute the next frame time:
+		//	If possible, round it to the nearest millisecond before
+		//	the first Breakpoint in the next frame, otherwise just
+		//	pick a time between the last Breakpoint in the current
+		//	frame and the first Breakpoint in the next.
+		std::list< BreakpointTime >::iterator prev = bpTimeIter;
+		--prev;
+
+		//	prev and bpTimeIter cannot have the same time, because
+		//	if there are several Breakpoints at the same time, bpTimeIter
+		//	will be the first of them in the list:
+		Assert( bpTimeIter->time > prev->time );
+		
+		//	This seems to be sensitive to floating point error,
+		//	probably because times are stored in 32 bit floats.
+		//	We need the error to round toward the later time.
+        //
+        //  Note: times are no longer stored in 32 bit floats, 
+        //  why is this still so flakey?
+		nextFrameTime = bpTimeIter->time - ( 0.5 * ( bpTimeIter->time - prev->time ) );
+        /*
+        notifier << "next frame time " << nextFrameTime << endl;
+        notifier << " bp time " << bpTimeIter->time << endl;
+        notifier << " prev time " << prev->time << endl;
+        notifier << " diff = " << bpTimeIter->time - prev->time << endl;
+        */
+		Assert( bpTimeIter->time >= nextFrameTime );
+		Assert( nextFrameTime > prev->time );
+		
+		//	Try to make frame times whole milliseconds.
+		//	MUST use 32-bit floats for time, or else floating
+		//	point rounding errors cause us to drop breakpoints!
+		double nextFramePrevRnd = 0.001 * std::floor( 1000. * nextFrameTime );
+		if ( ( nextFramePrevRnd < nextFrameTime ) && ( nextFramePrevRnd > prev->time ) )
+		{
+			nextFrameTime = nextFramePrevRnd;
+		}
+		else
+		{
+			//	Try tenth-milliseconds, otherwise give up.
+			nextFramePrevRnd = 0.0001 * std::floor( 10000. * nextFrameTime );
+			if ( ( nextFramePrevRnd < nextFrameTime ) && ( nextFramePrevRnd > prev->time ) )
+			{
+				nextFrameTime = nextFramePrevRnd;
+			}
+		}			
+	}
+    
+    // notifier << "   returning next frame time " << nextFrameTime << endl;
+
+#if Debug_Loris		
+	if ( ! ( nextFrameTime > frameTime ) )
+	{
+		if ( bpTimeIter != allBreakpoints.end() )
+		{
+			std::cout << bpTimeIter->time << std::endl;
+		}
+		else
+		{
+			std::cout << "end" << std::endl;
+		}
+		// std::cout << first->time << ", index " << first->index << std::endl;
+		std::cout << nextFrameTime << std::endl;
+		std::cout << frameTime << std::endl;
+		std::cout << partialsWithBreakpointsInFrame.size() << std::endl;
+	}	
+	Assert( nextFrameTime > frameTime );
+#endif
+	return nextFrameTime;
+}		
+
+
+// ---------------------------------------------------------------------------
+//	indexPartials
+// ---------------------------------------------------------------------------
+//	Make a vector of partial pointers. 
+//  The vector index will be the sdif 1TRC index for the partial. 
+//
+static void
+indexPartials( const PartialList & partials, ConstPartialPtrs & partialsVector )
+{
+	for ( PartialList::const_iterator it = partials.begin(); it != partials.end(); ++it )
+	{
+		if ( it->size() != 0 )
+		{
+			partialsVector.push_back( (Partial *)&(*it) );	//@@@ Kluge Here  (Partial *)
+	//		partialsVector.push_back( &(*it) );	
+		}
+	}
+}
+
+
+// ---------------------------------------------------------------------------
+//	collectActiveIndices
+// ---------------------------------------------------------------------------
+//	Collect all partials active in a particular frame. 
+//
+//  Return true if frameTime is beyond end of all the partials.
+//	Don't need to return this, can just check frame time against
+//	the time of the last BreakpointTime in the allBreakpoints vector.
+//
+static void
+collectActiveIndices( const ConstPartialPtrs & partialsVector, 
+                      const bool enhanced,
+                      const double frameTime, 
+                      const double nextFrameTime,
+                      std::vector< int > & activeIndices )
+{
+#if 1 //Debug_Loris		
+	if ( ! ( nextFrameTime > frameTime ) ) 
+	{
+		std::cout << nextFrameTime << " <= " << frameTime << std:: endl;
+		//std::cout << "amp 128 : " << partialsVector[128]->amplitudeAt( frameTime ) << std::endl;
+		
+	} 
+#endif
+	Assert( nextFrameTime > frameTime );
+		
+	for ( int i = 0; i < partialsVector.size(); i++ ) 
+	{
+		Assert( partialsVector[ i ] != 0 );
+		
+		const Partial & mightBeActive = *( partialsVector[ i ] );
+		
+		// Is there a breakpoint within the frame?
+		// Skip the partial if there is no breakpoint and either:
+		//		(1) we are writing enhanced format, 
+		// 	 or (2) the partial has zero amplitude.
+		//
+		//	Include this Partial if:
+		//	(1) it has a Breakpoint in the frame, or 
+		//	(2A) we are not writing enhanced data, and
+		//	(2B) the Partial has non-zero amplitude at the time of
+		//		 this frame.
+		//
+		Partial::const_iterator it = mightBeActive.findAfter( frameTime );
+		if ( it != mightBeActive.end() )
+		{
+#if Debug_Loris
+			//	DEBUGGING
+			//	if this one is in this frame, then 
+			//	the one before it had better be in the previous frame!
+			if ( ( it != mightBeActive.begin() ) && ( it.time() < nextFrameTime ) )
+			{
+				Partial::const_iterator prev = it;
+				--prev;
+				Assert( prev.time() < frameTime );
+			}
+			Assert( it != mightBeActive.end() );
+#endif			
+			
+			//	mightBeActive is active in this frame if the Breakpoint
+			//	at it is earlier than the next frame time.
+			//
+			//	1TRC (non-enhanced) contains data for every non-silent
+			//	active Partial at the time of the frame.
+			if ( ( it.time() < nextFrameTime ) ||
+				 ( !enhanced && mightBeActive.amplitudeAt( frameTime ) != 0.0 ) ) 
+			{
+				activeIndices.push_back( i );	
+			}			
+		}
+
+	}
+}
+
+// ---------------------------------------------------------------------------
+//	writeEnvelopeLabels
+// ---------------------------------------------------------------------------
+//
+static void
+writeEnvelopeLabels( FILE * out, const ConstPartialPtrs & partialsVector )
+{
+//
+// Write Loris labels to SDIF file in a RBEL matrix.
+// This precedes the 1TRC data in the file.
+// Let exceptions propagate.
+//
+
+	int streamID = 2; 				// stream id different from envelope's stream id
+	double frameTime = 0.0;
+
+//
+// Allocate RBEL matrix data.
+//
+	int cols = 2;
+	sdif_float64 *data = new sdif_float64[ partialsVector.size() * cols ];
+
+//
+// For each partial index, specify the partial label.
+//
+	sdif_float64 *dp = data;
+	int anyLabel = false;
+	for (int i = 0; i < partialsVector.size(); i++) 
+	{
+		int labl = partialsVector[i]->label();
+		anyLabel |= (labl != 0);
+		*dp++ = i;					// column 1: index
+		*dp++ = labl;				// column 2: label
+	}	
+
+//							
+// Write out matrix data, if there were any labels.
+//
+	if (anyLabel)
+	{
+		// Write the frame header.
+		SDIF_FrameHeader fh;
+		SDIF_Copy4Bytes(fh.frameType, lorisLabelsSignature);
+		fh.size = 
+				// size of remaining frame header
+				  sizeof(sdif_float64) + 2 * sizeof(sdif_int32) 		
+				// size of matrix header
+				+ sizeof(SDIF_MatrixHeader) 							
+				// size of matrix data plus any padding
+				+ 8 * ((partialsVector.size() * cols * sizeof(sdif_float64) + 7) / 8);	
+		fh.time = frameTime;
+		fh.streamID = streamID;
+		fh.matrixCount = 1;
+		SDIFresult ret = SDIF_WriteFrameHeader(&fh, out);
+		
+		// Write the matrix header.
+		SDIF_MatrixHeader mh;
+		SDIF_Copy4Bytes(mh.matrixType, lorisLabelsSignature);
+		mh.matrixDataType = SDIF_FLOAT64;
+		mh.rowCount = partialsVector.size();
+		mh.columnCount = cols;
+		ret = SDIF_WriteMatrixHeader(&mh, out);
+		
+		// Write the matrix data, and any necessary padding.
+		ret = SDIF_WriteMatrixData(out, &mh, data);
+	}
+
+//	
+// Free RBEL matrix space.
+//
+	delete [] data;
+}
+
+// ---------------------------------------------------------------------------
+//	writeMarkers
+// ---------------------------------------------------------------------------
+//
+static void
+writeMarkers( FILE * out, const SdifFile::markers_type &markers )
+{
+//
+// Write Loris markers to SDIF file in a RBEM frame.
+// This precedes the envelope data in the file.
+// Let exceptions propagate.
+//
+
+//
+// Exit if there are no markers.
+//
+	if ( markers.empty() )
+	{
+		return;
+	}
+
+	int streamID = 2; 				// stream id different from envelope's stream id
+	double frameTime = 0.0;
+
+//
+// We will need two matrices: one numeric (marker times) matrix data and character (marker names) matrix.
+//
+	std::vector<sdif_float64> markerTimes;
+	std::string markerNames;
+
+//
+// Get matrix data from each marker.
+//
+	for (int marker = 0; marker < markers.size(); marker++)
+	{
+		markerTimes.push_back( markers[marker].time() );
+		markerNames += markers[marker].name() + '\0';
+	}
+
+//							
+// Write out frame with two marker matrices.
+//
+    // Write the frame header.
+    int cols = 1;
+    {
+            SDIF_FrameHeader fh;
+            SDIF_Copy4Bytes( fh.frameType, lorisMarkersSignature );
+            fh.size =
+                            // size of remaining frame header
+                              sizeof( sdif_float64 ) + 2 * sizeof( sdif_int32 )
+                            // size of matrix headers
+                            + 2 * sizeof( SDIF_MatrixHeader )
+                            // size of numeric (time) matrix data
+                            + markerTimes.size() * sizeof( sdif_float64 )
+                            // size of marker names data plus padding
+                            + 8 * ( ( markerNames.size() + 7 ) / 8 );
+            fh.time = frameTime;
+            fh.streamID = streamID;
+            fh.matrixCount = 2;
+            // SDIFresult ret = return value never checked!
+				SDIF_WriteFrameHeader(&fh, out);
+    }
+	
+	// Write the numeric (marker times) matrix.
+	{
+		// Write the numeric (time) matrix header.
+		SDIF_MatrixHeader mh;
+		SDIF_Copy4Bytes( mh.matrixType, lorisMarkersSignature );
+		mh.matrixDataType = SDIF_FLOAT64;
+		mh.rowCount = markerTimes.size();
+		mh.columnCount = cols;
+		SDIFresult ret = SDIF_WriteMatrixHeader( &mh, out );
+		
+		// Write the numeric (time) matrix data, and any necessary padding.
+		ret = SDIF_WriteMatrixData( out, &mh, &markerTimes[0] );
+	}
+	
+	// Write the string (marker names) matrix.
+	{
+		// Write the string (names) matrix header.
+		SDIF_MatrixHeader mh;
+		SDIF_Copy4Bytes( mh.matrixType, lorisMarkersSignature );
+		mh.matrixDataType = SDIF_UTF8;
+		mh.rowCount = markerNames.size();
+		mh.columnCount = cols;
+		SDIFresult ret = SDIF_WriteMatrixHeader( &mh, out );
+		
+		// Write the string (names) matrix data, and any necessary padding.
+		ret = SDIF_WriteMatrixData( out, &mh, &markerNames[0] );
+	}
+}
+
+
+// ---------------------------------------------------------------------------
+//	assembleMatrixData
+// ---------------------------------------------------------------------------
+//	The activeIndices vector contains indices for partials that have data at this time.
+//	Assemble SDIF matrix data for these partials.
+//
+static void
+assembleMatrixData( sdif_float64 *data, const bool enhanced,
+					const ConstPartialPtrs & partialsVector, 
+					const std::vector< int > & activeIndices, 
+					const double frameTime )
+{	
+	// The array matrix data is row-major order at "data".
+	sdif_float64 *rowDataPtr = data;
+	
+	for ( int i = 0; i < activeIndices.size(); i++ ) 
+	{
+		
+		int index = activeIndices[ i ];
+		const Partial * par = partialsVector[ index ];
+		
+		// For enhanced format we use exact timing; the activeIndices only includes
+		// partials that have breakpoints in this frame.
+		// For sine-only format we resample at frame times, for enhanced, use
+		// the Breakpoints themselves.
+		Assert( par->endTime() >= frameTime );
+		double tim = frameTime;		
+		Breakpoint params;
+		if ( enhanced )
+		{
+		    Partial::const_iterator pos = par->findAfter( frameTime );
+		    tim = pos.time();
+		    params = pos.breakpoint();
+		}
+		else
+		{
+		    params = par->parametersAt( frameTime );
+		}
+				
+		// Must have phase between 0 and 2*Pi.
+		double phas = params.phase(); 
+		if (phas < 0)
+		{
+			phas += 2. * Pi; 
+		}
+		
+		// Fill in values for this row of matrix data.
+		*rowDataPtr++ = index;							// first row of matrix   (standard)
+		*rowDataPtr++ = params.frequency(); 		    // second row of matrix  (standard)
+		*rowDataPtr++ = params.amplitude();		        // third row of matrix   (standard)
+		*rowDataPtr++ = phas;							// fourth row of matrix  (standard)
+		if (enhanced)
+		{
+			*rowDataPtr++ = params.bandwidth();	        // fifth row of matrix   (loris)
+			*rowDataPtr++ = tim - frameTime;			// sixth row of matrix   (loris)
+		}
+	}
+}
+
+
+// ---------------------------------------------------------------------------
+//	writeEnvelopeData
+// ---------------------------------------------------------------------------
+//
+static void
+writeEnvelopeData( FILE * out,
+				   const ConstPartialPtrs & partialsVector,
+				   const bool enhanced )
+{
+//
+// Export SDIF file from Loris data.
+// Let exceptions propagate.
+//
+
+	int streamID = 1; 						// one stream id for all SDIF frames
+
+//
+// Make a sorted list of all breakpoints in all partials, and initialize the list iterater.
+// This stuff does nothing if we are writing 5-column 1TRC format.
+//
+	std::list< BreakpointTime > allBreakpoints;
+	makeSortedBreakpointTimes( partialsVector, allBreakpoints );
+	std::list< BreakpointTime >::iterator bpTimeIter = allBreakpoints.begin();
+	
+#if Debug_Loris	
+	const std::list< BreakpointTime >::size_type DEBUG_allBreakpointsSize = allBreakpoints.size();
+	std::list< BreakpointTime >::size_type DEBUG_cumNumTracks = 0;
+#endif
+
+//
+// Output Loris envelope data in SDIF frame format.
+// First frame starts at millisecond of first breakpoint.
+//
+	double nextFrameTime = allBreakpoints.front().time;
+	if ( 1000. * nextFrameTime - int( 1000. * nextFrameTime ) != 0. )
+	{
+		// HEY! Looks like this could give negative frame times, 
+		// is that allowed?
+		nextFrameTime = std::floor( 1000. * nextFrameTime - .001 ) / 1000.0;
+	}
+	
+	do 
+	{
+
+//
+// Go to next frame.
+//
+		double frameTime = nextFrameTime;
+		nextFrameTime = getNextFrameTime( frameTime, allBreakpoints, bpTimeIter );
+
+//
+// Make a vector of partial indices that includes all partials active at this time.
+//
+		std::vector< int > activeIndices;
+		collectActiveIndices( partialsVector, enhanced, frameTime, 
+							  nextFrameTime, activeIndices );
+
+//
+// Write frame header, matrix header, and matrix data.
+// We always have one matrix per frame.
+// The matrix size depends on the number of partials active at this time.
+//
+		int numTracks = activeIndices.size();
+		
+#if Debug_Loris	
+		DEBUG_cumNumTracks += numTracks;
+#endif
+		
+		if ( numTracks > 0 ) 	//	could activeIndices ever be empty?
+		{
+		
+			// Allocate matrix data.
+			int cols = ( enhanced ? lorisRowEnhancedElements : lorisRowSineOnlyElements );
+
+			//	I think this will go a lot faster if we aren't doing so much
+			//	dynamic memory allocation for each frame. if I use a vector, 
+			//	then we only need to allocate more memory when a frame has more
+			//	columns than any previous frame. Construct the vector once,
+			//	resize it for each frame, and clear it when done (doesn't 
+			//	deallocate memory).
+			// sdif_float64 *data = new sdif_float64[numTracks * cols];
+			static std::vector< sdif_float64 > dataVector;
+			dataVector.resize( numTracks * cols );
+
+			// Fill in matrix data.
+			sdif_float64 *data = &dataVector[ 0 ];
+			assembleMatrixData( data, enhanced, partialsVector, activeIndices, frameTime );
+					
+			// Write the frame header.
+			SDIF_FrameHeader fh;
+			SDIF_Copy4Bytes( fh.frameType, enhanced ? lorisEnhancedSignature : lorisSineOnlySignature );
+			fh.size = 		
+					// size of remaining frame header
+					  sizeof(sdif_float64) + 2 * sizeof(sdif_int32) 
+					// size of matrix header
+					+ sizeof(SDIF_MatrixHeader) 							
+					// size of matrix data plus any padding
+					+ 8*((numTracks * cols * sizeof(sdif_int32) + 7)/8);	
+			fh.streamID = streamID;
+			fh.time = frameTime;
+			fh.matrixCount = 1;
+			SDIFresult ret = SDIF_WriteFrameHeader(&fh, out);
+			
+			// Write the matrix header.
+			SDIF_MatrixHeader mh;
+			SDIF_Copy4Bytes( mh.matrixType, enhanced ? lorisEnhancedSignature : lorisSineOnlySignature );
+			mh.matrixDataType = SDIF_FLOAT64;
+			mh.rowCount = numTracks;
+			mh.columnCount = cols;
+			ret = SDIF_WriteMatrixHeader( &mh, out );
+			
+			// Write the matrix data, and any necessary padding.
+			ret = SDIF_WriteMatrixData( out, &mh, data );
+			
+			// Free matrix space.
+			// delete [] data;
+			//	Instead of deallocating, just clear the static 
+			//	vector, setting its logical size to zero.
+			dataVector.clear();
+		}
+	}
+	while ( nextFrameTime < allBreakpoints.back().time );
+	
+#if Debug_Loris	
+	std::cout << "SDIF export found " << DEBUG_allBreakpointsSize << " Breakpoints" << std::endl;
+	std::cout << "and exported " << DEBUG_cumNumTracks << std::endl;
+#endif
+}
+
+// ---------------------------------------------------------------------------
+//	Export
+// ---------------------------------------------------------------------------
+// Export SDIF file.
+//
+static void export_sdif( const std::string & filename, 
+						 const SdifFile::partials_type & partials, 
+						 const SdifFile::markers_type &markers, const bool enhanced )
+{
+//
+// Initialize CNMAT SDIF routines.
+//
+	SDIFresult ret = SDIF_Init();
+	if (ret)
+	{
+		Throw( FileIOException, "Could not initialize SDIF routines." );
+	}
+//
+// Open SDIF file for writing.
+//
+	FILE *out;
+	ret = SDIF_OpenWrite(filename.c_str(), &out);
+	if (ret)
+	{
+		Throw( FileIOException, "Could not open SDIF file for writing: " + filename );
+	}
+	
+	// We are no longer defining frame types.
+
+	//		// Define RBEP matrix and frame type for enhanced partials.
+	//		if (enhanced)
+	//		{
+	//			SdifMatrixTypeT *parsMatrixType = SdifCreateMatrixType(lorisEnhancedSignature,NULL);
+	//			SdifMatrixTypeInsertTailColumnDef(parsMatrixType,"Index");  
+	//			SdifMatrixTypeInsertTailColumnDef(parsMatrixType,"Frequency");  
+	//			SdifMatrixTypeInsertTailColumnDef(parsMatrixType,"Amplitude");  
+	//			SdifMatrixTypeInsertTailColumnDef(parsMatrixType,"Phase");  
+	//			SdifMatrixTypeInsertTailColumnDef(parsMatrixType,"Noise");  
+	//			SdifMatrixTypeInsertTailColumnDef(parsMatrixType,"TimeOffset");  
+	//			SdifPutMatrixType(out->MatrixTypesTable, parsMatrixType);//
+	//
+	//			SdifFrameTypeT *parsFrameType = SdifCreateFrameType(lorisEnhancedSignature,NULL);
+	//			SdifFrameTypePutComponent(parsFrameType, lorisEnhancedSignature, "RABWE_Partials");
+	//			SdifPutFrameType(out->FrameTypesTable, parsFrameType);
+	//		}
+	//
+	//		// Define RBEL matrix and frame type for labels.
+	//		SdifMatrixTypeT *labelsMatrixType = SdifCreateMatrixType(lorisLabelsSignature,NULL);
+	//		SdifMatrixTypeInsertTailColumnDef(labelsMatrixType,"Index");  
+	//		SdifMatrixTypeInsertTailColumnDef(labelsMatrixType,"Label");  
+	//		SdifPutMatrixType(out->MatrixTypesTable, labelsMatrixType);
+	//
+	//		SdifFrameTypeT *labelsFrameType = SdifCreateFrameType(lorisLabelsSignature,NULL);
+	//		SdifFrameTypePutComponent(labelsFrameType, lorisLabelsSignature, "RABWE_Labels");
+	//		SdifPutFrameType(out->FrameTypesTable, labelsFrameType);
+	//
+	//		// Write file header information 
+	//		SdifFWriteGeneralHeader( out );    
+	//		
+	//		// Write ASCII header information 
+	//		SdifFWriteAllASCIIChunks( out );    
+	
+//
+// Write SDIF data.
+//	
+	try 
+	{
+		// Make vector of pointers to partials.
+		ConstPartialPtrs partialsVector;
+		indexPartials( partials, partialsVector );
+
+		// Write labels.
+		writeEnvelopeLabels( out, partialsVector );
+		
+		// Write markers.
+		writeMarkers(out, markers);
+		
+		// Write partials to SDIF file.
+		writeEnvelopeData( out, partialsVector, enhanced );
+	}
+	catch ( Exception & ex ) 
+	{
+		ex.append( " Failed to write SDIF file." );
+		SDIF_CloseWrite( out );
+		throw;
+	}
+
+//
+// Close SDIF input file.
+//
+	SDIF_CloseWrite( out );
+}
+
+// ---------------------------------------------------------------------------
+//	Export
+// ---------------------------------------------------------------------------
+// Legacy static export member. 
+//
+void
+SdifFile::Export( const std::string & filename, const PartialList & partials, 
+				  const bool enhanced )
+{
+	SdifFile fout( partials.begin(), partials.end() );
+	if ( enhanced )
+		fout.write( filename );
+	else
+		fout.write1TRC( filename );
+}
+
+
+}	//	end of namespace Loris
+
+
diff --git a/src/loris/SdifFile.h b/src/loris/SdifFile.h
new file mode 100644
index 0000000..8408c28
--- /dev/null
+++ b/src/loris/SdifFile.h
@@ -0,0 +1,245 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * SdifFile.h
+ *
+ * Definition of SdifFile class for Partial import and export in Loris.
+ *
+ * Kelly Fitz, 8 Jan 2003 
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "Marker.h"
+#include "Partial.h"
+#include "PartialList.h"
+ 
+#include <string>
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	class SdifFile
+//
+//!	Class SdifFile represents reassigned bandwidth-enhanced Partial 
+//!	data in a SDIF-format data file. Construction of an SdifFile 
+//!	from a stream or filename automatically imports the Partial
+//!	data. 
+//!
+//!	Loris stores partials in SDIF RBEP and RBEL frames. The RBEP and RBEL
+//!	frame and matrix definitions are included in the SDIF file's header.
+//!	Each RBEP frame contains one RBEP matrix, and each row in a RBEP matrix
+//!	describes one breakpoint in a Loris partial. The data in RBEP matrices
+//!	are SDIF 32-bit floats.
+//!	
+//!	The six columns in an RBEP matrix are: partialIndex, frequency,
+//!	amplitude, phase, noise, timeOffset. The partialIndex uniquely
+//!	identifies a partial. When Loris exports SDIF data, each partial is
+//!	assigned a unique partialIndex. The frequency (Hz), amplitude (0..1),
+//!	phase (radians), and noise (bandwidth) are encoded the same as Loris
+//!	breakpoints. The timeOffset is an offset from the RBEP frame time,
+//!	specifying the exact time of the breakpoint. Loris always specifies
+//!	positive timeOffsets, and the breakpoint's exact time is always be
+//!	earlier than the next RBEP frame's time.
+//!	
+//!	Since reassigned bandwidth-enhanced partial breakpoints are
+//!	non-uniformly spaced in time, the RBEP frame times are also
+//!	non-uniformly spaced. Each RBEP frame will contain at most one
+//!	breakpoint for any given partial. A partial may extend over a RBEP frame
+//!	and have no breakpoint specified by the RBEP frame, as happens when one
+//!	active partial has a lower temporal density of breakpoints than other
+//!	active partials.
+//!	
+//!	If partials have nonzero labels in Loris, then a RBEL frame describing
+//!	the labeling of the partials will precede the first RBEP frame in the
+//!	SDIF file. The RBEL frame contains a single, two-column RBEL matrix The
+//!	first column is the partialIndex, and the second column specifies the
+//!	label for the partial.
+//!
+//!	If markers are associated with the partials in Loris, then a RBEM frame
+//!	describing the markers will precede the first RBEP frame in the SDIF
+//!	file. The RBEM frame contains two single-column RBEM matrices. The
+//!	first matrix contains 32-bit floats indicating the time (in seconds)
+//!	for each marker. The second matrix contains UTF-8 data, the names of
+//!	each of the markers separated by the ASCII character 0.
+//!	
+//!	In addition to RBEP frames, Loris can also read and write SDIF 1TRC
+//!	frames (refer to IRCAM's SDIF web site, www.ircam.fr/sdif/, for
+//!	definitions of standard SDIF description types). Since 1TRC frames do
+//!	not represent bandwidth-enhancement or the exact timing of Loris
+//!	breakpoints, their use is not recommended. 1TRC capabilities are
+//!	provided in Loris to allow interchange with programs that are unable to
+//!	interpret RBEP frames.
+//
+class SdifFile
+{
+//	-- public interface --
+public:
+
+//	-- types --
+
+	//! The type of marker storage in an SdifFile.
+	typedef std::vector< Marker > markers_type;
+
+	//!	The type of the Partial storage in an AiffFile.
+	typedef PartialList partials_type;
+	
+//	-- construction --
+
+    //! Initialize an instance of SdifFile by importing Partial data from
+    //! the file having the specified filename or path.
+ 	explicit SdifFile( const std::string & filename );
+ 
+    //! Initialize an instance of SdifFile with copies of the Partials
+    //! on the specified half-open (STL-style) range.
+    //! 
+    //! If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+    //! only PartialList::const_iterator arguments.
+#if !defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+	SdifFile( Iter begin_partials, Iter end_partials  );
+#else
+	SdifFile( PartialList::const_iterator begin_partials, 
+			  PartialList::const_iterator end_partials  );
+#endif
+ 
+    //! Initialize an empty instance of SdifFile having no Partials.
+	SdifFile( void );
+	
+	//	copy, assign, and delete are compiler-generated
+	
+//	-- access --
+
+    //! Return a reference to the Markers (see Marker.h) 
+    //! for this SdifFile. 
+	markers_type & markers( void );
+
+    //! Return a reference to the Markers (see Marker.h) 
+    //! for this SdifFile. 
+	const markers_type & markers( void ) const;
+	 
+    //!	Return a reference to the bandwidth-enhanced
+    //! Partials represented by this SdifFile.
+	partials_type & partials( void );
+
+    //!	Return a reference to the bandwidth-enhanced
+    //! Partials represented by this SdifFile.
+	const partials_type & partials( void ) const;
+//	-- mutation --
+
+	//! Add a copy of the specified Partial to this SdifFile.
+	void addPartial( const Loris::Partial & p );
+	 
+    //! Add a copy of each Partial on the specified half-open (STL-style) 
+    //! range to this SdifFile.
+    //! 
+    //! If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+    //! only PartialList::const_iterator arguments.
+#if !defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+	void addPartials( Iter begin_partials, Iter end_partials  );
+#else
+	void addPartials( PartialList::const_iterator begin_partials, 
+					  PartialList::const_iterator end_partials  );
+#endif
+	 
+//	-- export --
+
+    //! Export the envelope Partials represented by this SdifFile to
+    //! the file having the specified filename or path.
+	void write( const std::string & path );
+
+    //! Export the envelope Partials represented by this SdifFile to
+    //! the file having the specified filename or path in the 1TRC
+    //! format, resampled, and without phase or bandwidth information.
+	void write1TRC( const std::string & path );
+	
+//	-- legacy export --
+
+    //! Export the Partials in the specified PartialList to a SDIF file having
+    //! the specified file name or path. If enhanced is true (the default),
+    //! reassigned bandwidth-enhanced Partial data are exported in the
+    //! six-column RBEP format. Otherwise, the Partial data is exported as
+    //! resampled sinusoidal analysis data in the 1TRC format.
+    //! Provided for backwards compatability.
+    //! 
+    //! \deprecated This function is included only for legacy support
+    //!             and may be removed at any time.
+	static void Export( const std::string & filename, 
+						const PartialList & plist, 
+						const bool enhanced = true );
+
+private:
+//	-- implementation --
+	partials_type partials_;		//	Partials to store in SDIF format
+	markers_type markers_;		// 	AIFF Markers
+	
+};	//	end of class SdifFile
+
+// -- template members --
+
+// ---------------------------------------------------------------------------
+//	constructor from Partial range
+// ---------------------------------------------------------------------------
+//	Initialize an instance of SdifFile with copies of the Partials
+//	on the specified half-open (STL-style) range.
+//
+//	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+//	only PartialList::const_iterator arguments.
+//
+#if !defined(NO_TEMPLATE_MEMBERS)
+template< typename Iter >
+SdifFile::SdifFile( Iter begin_partials, Iter end_partials  )
+#else
+SdifFile::SdifFile( PartialList::const_iterator begin_partials, 
+					PartialList::const_iterator end_partials )
+#endif
+{
+	addPartials( begin_partials, end_partials );
+}
+
+// ---------------------------------------------------------------------------
+//	addPartials 
+// ---------------------------------------------------------------------------
+//	Add a copy of each Partial on the specified half-open (STL-style) 
+//	range to this SdifFile.
+//	
+//	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+//	only PartialList::const_iterator arguments.
+//
+#if !defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void SdifFile::addPartials( Iter begin_partials, Iter end_partials  )
+#else
+void SdifFile::addPartials( PartialList::const_iterator begin_partials, 
+							PartialList::const_iterator end_partials  )
+#endif
+{
+	partials_.insert( partials_.end(), begin_partials, end_partials );
+}
+
+}	//	end of namespace Loris
+
diff --git a/src/loris/Sieve.C b/src/loris/Sieve.C
new file mode 100644
index 0000000..dc25992
--- /dev/null
+++ b/src/loris/Sieve.C
@@ -0,0 +1,235 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Sieve.C
+ *
+ * Implementation of class Sieve.
+ *
+ * Lippold Haken, 20 Jan 2001
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "Sieve.h"
+#include "Breakpoint.h"
+#include "LorisExceptions.h"
+#include "Notifier.h"
+#include "Partial.h"
+#include "PartialList.h"
+#include "PartialUtils.h"
+
+#include <algorithm>
+
+//	begin namespace
+namespace Loris {
+
+
+// ---------------------------------------------------------------------------
+//	Sieve constructor
+// ---------------------------------------------------------------------------
+//! Construct a new Sieve using the specified partial fade
+//! time. If unspecified, the default fade time (same as the   
+//! default fade time for the Distiller) is used.
+//!
+//!   \param   partialFadeTime is the extra time (in seconds)  
+//!            added to each end of a Partial to accomodate 
+//!            the fade to and from zero amplitude. Fade time
+//!            must be non-negative. A default value is used
+//!			   if unspecified.
+//!   \throw  InvalidArgument if partialFadeTime is negative.
+//
+Sieve::Sieve( double partialFadeTime ) :
+	_fadeTime( partialFadeTime )
+{
+	if ( _fadeTime < 0.0 )
+	{
+	   Throw( InvalidArgument, "the Partial fade time must be non-negative" );
+	}
+}
+
+//	Definition of a comparitor for sorting a collection of pointers
+//	to Partials by label (increasing) and duration (decreasing), so
+//	that Partial ptrs are arranged by label, with the lowest labels
+//	first, and then with the longest Partials having each label
+//	before the shorter ones.
+struct SortPartialPtrs :
+	public std::binary_function< const Partial *, const Partial *, bool >
+{
+	bool operator()( const Partial * lhs, const Partial * rhs ) const 
+		{ 
+			return 	( lhs->label() != rhs->label() ) ?
+					( lhs->label() < rhs->label() ) :
+					( lhs->duration() > rhs->duration() );
+		}
+};
+
+//	Definition of predicate for finding the end of a Patial *
+//	range having a common label.
+struct PartialPtrLabelNE :
+	public std::unary_function< const Partial *, bool >
+{
+	int label;
+	PartialPtrLabelNE( int l ) : label(l) {}
+
+	bool operator()( const Partial * p ) const
+		{ return p->label() != label; }
+};
+
+
+// ---------------------------------------------------------------------------
+//	find_overlapping (template function)
+// ---------------------------------------------------------------------------
+//	Iterate over a range of Partials (presumably) with same labeling.
+//	The range is specified by iterators over a collection of pointers
+//	to Partials (not Partials themselves). Return the first position
+//	in the specified range corresponding to a Partial that overlaps
+//	(in time) the specified Partial, p, or the end of the range if
+//	no Partials in the range overlap.
+//
+//	Overlap is defined by the minimum time gap between Partials
+//	(minGapTime), so Partials that have less then minGapTime
+//	between them are considered overlapping.
+//
+template <typename Iter>	//	Iter is the position of a Partial *
+Iter
+find_overlapping( Partial & p, double minGapTime, Iter start, Iter end)
+{
+	for ( Iter it = start; it != end; ++it ) 
+	{
+		//	skip if other partial is already sifted out.
+		if ( (*it)->label() == 0 )
+			continue;
+		
+		//	skip the source Partial:
+		//	(identity test: compare addresses)
+		//	(this is a sanity check, should not happen since
+		//	src should be at position end)
+		Assert( (*it) != &p );
+
+		//  test for overlap:
+		if ( p.startTime() < (*it)->endTime() + minGapTime &&
+			 p.endTime() + minGapTime > (*it)->startTime() )
+		{
+			//  Does the overlapping Partial have longer duration?
+			//	(this should never be true, since the Partials
+			//	are sorted by duration)
+			Assert( p.duration() <= (*it)->duration() );
+			
+#if Debug_Loris
+			debugger << "Partial starting " << p.startTime() << ", " 
+					 << p.begin().breakpoint().frequency() << " ending " 
+					 << p.endTime()  << ", " << (--p.end()).breakpoint().frequency() 
+					 << " zapped by overlapping Partial starting " 
+					 << (*it)->startTime() << ", " << (*it)->begin().breakpoint().frequency()
+					 << " ending " << (*it)->endTime() << ", " 
+					 << (--(*it)->end()).breakpoint().frequency()  << endl;
+#endif
+			return it;
+		}
+	}
+	
+	//	no overlapping Partial found:
+	return end;
+}
+
+// ---------------------------------------------------------------------------
+//	sift_ptrs (private helper)
+// ---------------------------------------------------------------------------
+//!   Sift labeled Partials. If any two Partials having the same (non-zero)
+//!   label overlap in time (where overlap includes the fade time at both 
+//!   ends of each Partial), then set the label of the Partial having the
+//!   shorter duration to zero. Sifting is performed on a collection of 
+//!   pointers to Partials so that the it can be performed without changing 
+//!   the order of the Partials in the sequence.
+//!
+//!   \param   ptrs is a collection of pointers to the Partials in the
+//!            sequence to be sifted.
+void 
+Sieve::sift_ptrs( PartialPtrs & ptrs  )
+{
+	//	the minimum gap between Partials is twice the 
+	//	specified fadeTime:
+	double minGapTime = _fadeTime * 2.;
+	
+	//	sort the collection of pointers to Partials:
+	//	(sort is by increasing label, then
+	//	decreasing duration)
+	std::sort( ptrs.begin(), ptrs.end(), SortPartialPtrs() );
+	
+	PartialPtrs::iterator sift_begin = ptrs.begin();
+	PartialPtrs::iterator sift_end = ptrs.end();
+
+	int zapped = 0;
+	
+	// 	iterate over labels and sift each one:
+	PartialPtrs::iterator lowerbound = sift_begin;
+	while ( lowerbound != sift_end )
+	{
+		int label = (*lowerbound)->label();
+		
+		//	first the first element in l after sieve_begin
+		//	having a label not equal to 'label':
+		PartialPtrs::iterator upperbound = 
+			std::find_if( lowerbound, sift_end, PartialPtrLabelNE(label) );
+
+#ifdef Debug_Loris
+		//	don't want to compute this iterator distance unless debugging:
+		debugger << "sifting Partials labeled " << label << endl;
+		debugger << "Sieve found " << std::distance( lowerbound, upperbound ) << 
+					" Partials labeled " << label << endl;
+#endif
+		//  sift all partials with this label, unless the
+		//	label is 0:
+		if ( label != 0 )
+		{
+			PartialPtrs::iterator it;
+			for ( it = lowerbound; it != upperbound; ++it ) 
+			{
+				//	find_overlapping only needs to consider Partials on the
+				//	half-open range [lowerbound, it), because all 
+				//	Partials after it are shorter, thanks to the
+				//	sorting of the sift_set:
+				if( it != find_overlapping( **it, minGapTime, lowerbound, it ) )
+				{
+					(*it)->setLabel(0);
+					++zapped;
+				}
+			} 
+		}
+		
+		//	advance Partial set iterator:
+		lowerbound = upperbound;
+	}
+
+#ifdef Debug_Loris
+	debugger << "Sifted out (relabeled) " << zapped << " of " << ptrs.size() << "." << endl;
+#endif
+}
+
+}	//	end of namespace Loris
+
diff --git a/src/loris/Sieve.h b/src/loris/Sieve.h
new file mode 100644
index 0000000..aff3f16
--- /dev/null
+++ b/src/loris/Sieve.h
@@ -0,0 +1,269 @@
+#ifndef INCLUDE_SIEVE_H
+#define INCLUDE_SIEVE_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Sieve.h
+ *
+ * Definition of class Sieve.
+ *
+ * Lippold Haken, 20 Jan 2001
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+ 
+#include "Distiller.h"	//	for default fade time and silent time
+ 
+#if defined(NO_TEMPLATE_MEMBERS)
+#include "PartialList.h"
+#endif
+
+#include "PartialPtrs.h"
+
+//  begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//  class Sieve
+//
+//! A Sieve eliminating temporal overlap among Partials.
+//!
+//! Class Sieve represents an algorithm for identifying channelized (see also 
+//! Channelizer) Partials that overlap in time, and selecting the longer
+//! one to represent the channel. The identification of overlap includes 
+//! the time needed for Partials to fade to and from zero amplitude in 
+//!  synthesis (see also  Synthesizer) or distillation. (see also Distiller)
+//! 
+//! In some cases, the energy redistribution effected by the distiller
+//! (see also Distiller) is undesirable. In such cases, the partials can be
+//! sifted before distillation. The sifting process in Loris identifies
+//! all the partials that would be rejected (and converted to noise
+//! energy) by the distiller and assigns them a label of 0. These sifted
+//! partials can then be identified and treated sepearately or removed
+//! altogether, or they can be passed through the distiller unlabeled, and
+//! crossfaded in the morphing process (see also Morpher).
+//!
+//!   \sa Channelizer, Distiller, Morpher, Synthesizer
+//
+class Sieve
+{
+//  -- instance variables --
+
+    double _fadeTime; //! extra time (in seconds) added to each end of 
+                      //! a Partial when determining overlap, to accomodate 
+                      //! the fade to and from zero amplitude.
+    
+//  -- public interface --
+public:
+
+//  -- global defaults and constants --
+
+	enum 
+	{
+	
+		//! Default time in milliseconds over which Partials joined by
+		//! distillation fade to and from zero amplitude. Divide by 
+		//!	1000 to use as a member function parameter. This parameter
+		//!	should be the same in Distiller, Sieve, and Collator.
+		DefaultFadeTimeMs = Distiller::DefaultFadeTimeMs,
+		
+		//! Default minimum duration in milliseconds of the silent 
+		//! (zero-amplitude) gap between two Partials joined by 
+		//!	distillation. Divide by 1000 to use as a member function 
+		//!	parameter. This parameter should be the same in Distiller, 
+		//!	Sieve, and Collator.
+		DefaultSilentTimeMs = Distiller::DefaultSilentTimeMs
+    };
+    
+//  -- construction --
+
+    //! Construct a new Sieve using the specified partial fade
+    //! time. If unspecified, the default fade time (same as the   
+    //! default fade time for the Distiller) is used.
+    //!
+    //!   \param   partialFadeTime is the extra time (in seconds)  
+    //!            added to each end of a Partial to accomodate 
+    //!            the fade to and from zero amplitude. Fade time
+    //!            must be non-negative. A default value is used
+    //!			   if unspecified.
+    //!   \throw  InvalidArgument if partialFadeTime is negative.
+    explicit Sieve( double partialFadeTime = Sieve::DefaultFadeTimeMs/1000.0 );
+     
+    //  Use compiler-generated copy, assign, and destroy.
+    
+//  -- sifting --
+
+    //! Sift labeled Partials on the specified half-open (STL-style)
+    //! range. If any two Partials having same label overlap in time, keep
+    //! only the longer of the two Partials. Set the label of the shorter
+    //! duration partial to zero. No Partials are removed from the
+    //! sequence and the sequence order is unaltered. 
+    //!
+    //! \param sift_begin is the beginning of the range of Partials to sift
+    //! \param sift_end is (one-past) the end of the range of Partials to sift
+    //! 
+    //! If compiled with NO_TEMPLATE_MEMBERS defined, then sift_begin and 
+    //! sift_end must be PartialList::iterators, otherwise they can be any type
+    //! of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    template<typename Iter>
+    void sift( Iter sift_begin, Iter sift_end  );
+#else
+   inline
+    void sift( PartialList::iterator sift_begin, PartialList::iterator sift_end  );
+#endif
+
+    //! Sift labeled Partials in the specified container
+    //! If any two Partials having same label overlap in time, keep
+    //! only the longer of the two Partials. Set the label of the shorter
+    //! duration partial to zero. No Partials are removed from the
+    //! container and the container order is unaltered. 
+    //!
+    //! \param  partials is the collection of Partials to sift in-place
+    //! 
+    //! If compiled with NO_TEMPLATE_MEMBERS defined, then partials
+    //! must be a PartialList, otherwise it can be any container type
+    //! storing Partials that supports at least bidirectional iterators.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    template< typename Container >
+    void sift( Container & partials  )
+#else
+   inline
+    void sift( PartialList & partials )
+#endif
+    {
+        sift( partials.begin(), partials.end() );
+    }
+         
+// -- static members --
+
+    //! Static member that constructs an instance and applies
+    //! it to a sequence of Partials. 
+    //! Construct a Sieve using the specified Partial
+    //! fade time (in seconds), and use it to sift a
+    //! sequence of Partials. 
+    //!
+    //! \param  sift_begin is the beginning of the range of Partials to sift
+    //! \param  sift_end is (one-past) the end of the range of Partials to sift
+    //! \param  partialFadeTime is the extra time (in seconds)  
+    //!         added to each end of a Partial to accomodate 
+    //!         the fade to and from zero amplitude. The Partial fade time
+    //!         must be non-negative.
+    //! \throw  InvalidArgument if partialFadeTime is negative.
+    //! 
+    //! If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+    //! must be PartialList::iterators, otherwise they can be any type
+    //! of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+    template< typename Iter >
+    static 
+    void sift( Iter sift_begin, Iter sift_end, 
+              double partialFadeTime );
+#else
+    static inline 
+    void sift( PartialList::iterator sift_begin, PartialList::iterator sift_end,
+              double partialFadeTime );
+#endif   
+
+//  -- helper --
+private:
+
+   //!   Sift labeled Partials. If any two Partials having the same (non-zero)
+   //!   label overlap in time (where overlap includes the fade time at both 
+   //!   ends of each Partial), then set the label of the Partial having the
+   //!   shorter duration to zero. Sifting is performed on a collection of 
+   //!   pointers to Partials so that the it can be performed without changing 
+   //!   the order of the Partials in the sequence.
+   //!
+   //!   \param   ptrs is a collection of pointers to the Partials in the
+   //!            sequence to be sifted.
+    void sift_ptrs( PartialPtrs & ptrs );
+
+};  //  end of class Sieve
+
+// ---------------------------------------------------------------------------
+//  sift
+// ---------------------------------------------------------------------------
+//! Sift labeled Partials on the specified half-open (STL-style)
+//! range. If any two Partials having same label overlap in time, keep
+//! only the longer of the two Partials. Set the label of the shorter
+//! duration partial to zero. No Partials are removed from the
+//! sequence and the sequence order is unaltered. 
+//!
+//! \param sift_begin is the beginning of the range of Partials to sift
+//! \param sift_end is (one-past) the end of the range of Partials to sift
+//! 
+//! If compiled with NO_TEMPLATE_MEMBERS defined, then sift_begin and 
+//! sift_end must be PartialList::iterators, otherwise they can be any type
+//! of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename Iter >
+void Sieve::sift( Iter sift_begin, Iter sift_end  )
+#else
+inline
+void Sieve::sift( PartialList::iterator sift_begin, PartialList::iterator sift_end  )
+#endif
+{
+    PartialPtrs ptrs;
+    fillPartialPtrs( sift_begin, sift_end, ptrs );
+    sift_ptrs( ptrs );
+}
+
+// ---------------------------------------------------------------------------
+//  sift (static)
+// ---------------------------------------------------------------------------
+//! Static member that constructs an instance and applies
+//! it to a sequence of Partials. 
+//! Construct a Sieve using the specified Partial
+//! fade time (in seconds), and use it to sift a
+//! sequence of Partials. 
+//!
+//! \param  sift_begin is the beginning of the range of Partials to sift
+//! \param  sift_end is (one-past) the end of the range of Partials to sift
+//! \param  partialFadeTime is the extra time (in seconds)  
+//!         added to each end of a Partial to accomodate 
+//!         the fade to and from zero amplitude. The Partial fade time
+//!         must be non-negative.
+//! \throw  InvalidArgument if partialFadeTime is negative.
+//! 
+//! If compiled with NO_TEMPLATE_MEMBERS defined, then begin and end
+//! must be PartialList::iterators, otherwise they can be any type
+//! of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template< typename Iter >
+void Sieve::sift( Iter sift_begin, Iter sift_end, 
+                  double partialFadeTime )
+#else
+inline 
+void Sieve::sift( PartialList::iterator sift_begin, PartialList::iterator sift_end,
+                  double partialFadeTime )
+#endif   
+{
+   Sieve instance( partialFadeTime );
+   instance.sift( sift_begin, sift_end );
+}
+
+}   //  end of namespace Loris
+
+#endif /* ndef INCLUDE_SIEVE_H */
diff --git a/src/loris/SpcFile.C b/src/loris/SpcFile.C
new file mode 100644
index 0000000..66a7a17
--- /dev/null
+++ b/src/loris/SpcFile.C
@@ -0,0 +1,1311 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * SpcFile.C
+ *
+ * Implementation of SpcFile class for Partial import and export for
+ * real-time synthesis in Kyma.
+ *
+ * Spc files always represent a number of Partials that is a power of
+ * two. This is not necessary for purely-sinusoidal files, but might be
+ * (not clear) for enhanced data to be properly processed in Kyma. 
+ *
+ * All of this is kind of disgusting right now. This code has evolved 
+ * somewhat randomly, and we are awaiting full support for bandwidth-
+ * enhanced data in Kyma..
+ *
+ * Kelly Fitz, 8 Jan 2003 
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+    #include "config.h"
+#endif
+
+#include "SpcFile.h"
+
+#include "AiffData.h"
+#include "Breakpoint.h"
+#include "BigEndian.h"
+#include "LorisExceptions.h"
+#include "Marker.h"
+#include "Notifier.h"
+#include "PartialUtils.h"
+
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+    const double Pi = M_PI;
+#else
+    const double Pi = 3.14159265358979324;
+#endif
+
+
+//  Define this if SpcFiles should always have a number of 
+//  Partials that is a power of two. Cannot decide whether 
+//  or not they should. Lip?
+#define PO2
+
+
+using std::exp;
+using std::log;
+using std::sqrt;
+
+//  begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//  constants, can, or should, these be made variable?
+// ---------------------------------------------------------------------------
+
+//  can't we change this? Seems like we could, but 
+//  its part of the size of the magic junk in the 
+//  Sose chunk.
+const int LargestLabel = 256;   // max number of partials for SPC file
+
+    //  1 Mar 05
+    //  Found that this cannot actually be 512 for enhanced
+    //  Partials, it crashes with a segmentation fault above 256. 
+    //  Unfortunately, whatever is causing the problem is not
+    //  using this constant, but some other hardcoded thing.
+    //  if I change this to 256, then I can still export
+    //  256 enhanced Partials, but I don't know what to change
+    //  to allow 512! Ugh!
+    //  -kel
+
+
+//  this used to be hard coded into Partial, don't know
+//  whether it is needed to make spc files work.
+const double Fade = 0.001;
+
+//  this always has to be 24 bits, 1 channel
+const int Bps = 24;
+const int Nchans = 1;
+
+
+// ---------------------------------------------------------------------------
+//  static helper prototypes, defined at bottom
+// ---------------------------------------------------------------------------
+static void 
+configureEnvelopeDataCk( SoundDataCk & ck, const SpcFile::partials_type & partials );
+
+static void 
+configureSosMarkerCk( MarkerCk & ck, const std::vector< Marker > & markers  );
+
+static void
+configureSosEnvelopesCk( SosEnvelopesCk & ck );
+
+static std::ostream & 
+writeSosEnvelopesChunk( std::ostream & s, const SosEnvelopesCk & ck );
+
+static void
+configureExportStruct( const SpcFile::partials_type & partials, double midipitch,
+                       double endApproachTime, int enhanced );
+
+static unsigned long getNumSampleFrames( void );
+
+const int SpcFile::MinNumPartials = 32;
+const double SpcFile::DefaultRate = 44100.;
+
+// -- construction --
+// ---------------------------------------------------------------------------
+//  SpcFile constructor from filename
+// ---------------------------------------------------------------------------
+//  Initialize an instance of SpcFile by importing envelope parameter 
+//  streams from the file having the specified filename or path.
+//
+SpcFile::SpcFile( const std::string & filename ) :
+    notenum_( 60 ),
+    rate_( DefaultRate )
+{
+    readSpcData( filename );
+}
+
+// ---------------------------------------------------------------------------
+//  SpcFile constructor, empty.
+// ---------------------------------------------------------------------------
+//  Initialize an instance of SpcFile having the specified fractional
+//  MIDI note number, and no Partials (or envelope parameter streams). 
+//
+SpcFile::SpcFile( double midiNoteNum ) :
+    notenum_( midiNoteNum ),
+    rate_( DefaultRate )
+{
+    growPartials( MinNumPartials );
+}
+
+// ---------------------------------------------------------------------------
+//  write 
+// ---------------------------------------------------------------------------
+//  Export the phase-correct bandwidth-enhanced envelope parameter 
+//  streams represented by this SpcFile to the file having the specified 
+//  filename or path. 
+//  
+//  A nonzero endApproachTime indicates that the Partials do not include a
+//  release or decay, but rather end in a static spectrum corresponding to the
+//  final Breakpoint values of the partials. The endApproachTime specifies how
+//  long before the end of the sound the amplitude, frequency, and bandwidth
+//  values are to be modified to make a gradual transition to the static spectrum.
+//  
+//  If the endApproachTime is not specified, it is assumed to be zero, 
+//  corresponding to Partials that decay or release normally.
+//
+void 
+SpcFile::write( const std::string & filename, double endApproachTime )
+{
+    write( filename, true, endApproachTime );
+}
+
+// ---------------------------------------------------------------------------
+//  write 
+// ---------------------------------------------------------------------------
+//  Export the pure sinsoidal (omitting phase and bandwidth data) envelope 
+//  parameter streams represented by this SpcFile to the file having the 
+//  specified filename or path. 
+//  
+//  A nonzero endApproachTime indicates that the Partials do not include a
+//  release or decay, but rather end in a static spectrum corresponding to the
+//  final Breakpoint values of the partials. The endApproachTime specifies how
+//  long before the end of the sound the amplitude, frequency, and bandwidth
+//  values are to be modified to make a gradual transition to the static spectrum.
+//  
+//  If the endApproachTime is not specified, it is assumed to be zero, 
+//  corresponding to Partials that decay or release normally.
+//
+void 
+SpcFile::writeSinusoidal( const std::string & filename, double endApproachTime )
+{
+    write( filename, false, endApproachTime );
+}
+
+// ---------------------------------------------------------------------------
+//  write 
+// ---------------------------------------------------------------------------
+//  Export the envelope parameter streams represented by this SpcFile to
+//  the file having the specified filename or path. Export phase-correct 
+//  bandwidth-enhanced envelope parameter streams if enhanced is true 
+//  (the default), or pure sinsoidal streams otherwise.
+//
+//  
+//  A nonzero endApproachTime indicates that the Partials do not include a
+//  release or decay, but rather end in a static spectrum corresponding to the
+//  final Breakpoint values of the partials. The endApproachTime specifies how
+//  long before the end of the sound the amplitude, frequency, and bandwidth
+//  values are to be modified to make a gradual transition to the static spectrum.
+//  
+//  If the endApproachTime is not specified, it is assumed to be zero, 
+//  corresponding to Partials that decay or release normally.
+//
+//  This version of write is deprecated, but is handy for internal use,
+//  called by the above write and writeSiunsoidal members.
+//
+void
+SpcFile::write( const std::string & filename, bool enhanced, double endApproachTime )
+{
+    if ( endApproachTime < 0 )
+    {
+        Throw( InvalidArgument, "End Approach Time may not be negative." );
+    }
+    
+    std::ofstream s( filename.c_str(), std::ofstream::binary );
+    if ( ! s )
+    {
+        std::string s = "Could not create file \"";
+        s += filename;
+        s += "\". Failed to write Spc file.";
+        Throw( FileIOException, s );
+    }
+    
+    //  have to do this before trying to do anything else:
+    configureExportStruct( partials_, notenum_, endApproachTime, enhanced );
+    
+    unsigned long dataSize = 0;
+
+    CommonCk commonChunk;
+    configureCommonCk( commonChunk, getNumSampleFrames(), Nchans, Bps, rate_ );
+    dataSize += commonChunk.header.size + sizeof(CkHeader);
+    
+    SoundDataCk soundDataChunk;
+    configureEnvelopeDataCk( soundDataChunk, partials_ );
+    dataSize += soundDataChunk.header.size + sizeof(CkHeader);
+    
+    InstrumentCk instrumentChunk;
+    configureInstrumentCk( instrumentChunk, notenum_ );
+    dataSize += instrumentChunk.header.size + sizeof(CkHeader);
+
+    MarkerCk markerChunk;
+    if ( ! markers_.empty() )
+    {
+        configureSosMarkerCk( markerChunk, markers_ );
+        dataSize += markerChunk.header.size + sizeof(CkHeader);
+    }
+    
+    SosEnvelopesCk soseChunk;
+    configureSosEnvelopesCk( soseChunk );
+    dataSize += soseChunk.header.size + sizeof(CkHeader);
+    
+    ContainerCk containerChunk;
+    configureContainer( containerChunk, dataSize );
+    
+    try 
+    {
+        writeContainer( s, containerChunk );
+        writeCommonData( s, commonChunk );
+        if ( ! markers_.empty() )
+            writeMarkerData( s, markerChunk );
+        writeInstrumentData( s, instrumentChunk );
+        writeSosEnvelopesChunk( s, soseChunk );
+        writeSampleData( s, soundDataChunk );
+        
+        s.close();
+    }
+    catch ( Exception & ex ) 
+    {
+        ex.append( " Failed to write Spc file." );
+        throw;
+    }
+}
+
+// -- access --
+
+// ---------------------------------------------------------------------------
+//  markers 
+// ---------------------------------------------------------------------------
+//  Return a reference to the Marker (see Marker.h) container 
+//  for this SpcFile. 
+//
+SpcFile::markers_type & 
+SpcFile::markers( void )
+{
+    return markers_;
+}
+
+const SpcFile::markers_type & 
+SpcFile::markers( void ) const
+{
+    return markers_;
+}
+
+// ---------------------------------------------------------------------------
+//  midiNoteNumber 
+// ---------------------------------------------------------------------------
+//  Return the fractional MIDI note number assigned to this SpcFile. 
+//  If the sound has no definable pitch, note number 60.0 is used.
+//
+double 
+SpcFile::midiNoteNumber( void ) const
+{
+    return notenum_;
+}
+
+// ---------------------------------------------------------------------------
+//  partials 
+// ---------------------------------------------------------------------------
+//  Return a read-only (const) reference to the bandwidth-enhanced
+//  Partials represented by the envelope parameter streams in this SpcFile.
+//
+const SpcFile::partials_type & 
+SpcFile::partials( void ) const
+{
+    return partials_;
+}
+
+// ---------------------------------------------------------------------------
+//  sampleRate 
+// ---------------------------------------------------------------------------
+//  Return the sampling freqency in Hz for the spc data in this
+//  SpcFile. This is the rate at which Kyma must be running to ensure
+//  proper playback of bandwidth-enhanced Spc data.
+//
+double 
+SpcFile::sampleRate( void ) const
+{
+    return rate_;
+}
+
+// -- mutation --
+
+// ---------------------------------------------------------------------------
+//  addPartial 
+// ---------------------------------------------------------------------------
+//  Add the specified Partial to the enevelope parameter streams
+//  represented by this SpcFile. 
+//  
+//  A SpcFile can contain only one Partial having any given (non-zero) 
+//  label, so an added Partial will replace a Partial having the 
+//  same label, if such a Partial exists.
+//
+//  This may throw an InvalidArgument exception if an attempt is made
+//  to add unlabeled Partials, or Partials labeled higher than the
+//  allowable maximum.
+//
+void 
+SpcFile::addPartial( const Partial & p )
+{
+    addPartial( p, p.label() );
+}
+
+// ---------------------------------------------------------------------------
+//  addPartial 
+// ---------------------------------------------------------------------------
+//  Add a Partial, assigning it the specified label (and position in the
+//  Spc data). 
+//
+//  A SpcFile can contain only one Partial having any given (non-zero) 
+//  label, so an added Partial will replace a Partial having the 
+//  same label, if such a Partial exists.
+//
+//  This may throw an InvalidArgument exception if an attempt is made
+//  to add unlabeled Partials, or Partials labeled higher than the
+//  allowable maximum.
+//
+void 
+SpcFile::addPartial( const Partial & p, int label  )
+{
+    if ( p.label() == 0 )
+    {
+        Throw( InvalidArgument, "Spc Partials must be labeled." );
+    }
+    if ( label < 1 )
+    {
+        Throw( InvalidArgument, "Spc Partials must have positive labels." );
+    }
+    if ( label > LargestLabel )
+    {
+        Throw( InvalidArgument, "Spc Partial label is too large, cannot have more than 256." );
+    }
+
+    if ( label > partials_.size() )
+    {
+        growPartials( label );
+    }
+        
+    partials_[label - 1] = p;
+    partials_[label - 1].setLabel( label );
+}
+
+// ---------------------------------------------------------------------------
+//  setMidiNoteNumber 
+// ---------------------------------------------------------------------------
+//  Set the fractional MIDI note number assigned to this SpcFile. 
+//  If the sound has no definable pitch, use note number 60.0 (the default).
+//
+void 
+SpcFile::setMidiNoteNumber( double nn )
+{
+    if ( nn < 0 || nn > 128 )
+    {
+        Throw( InvalidArgument, "MIDI note number outside of the valid range [1,128]" );
+    }
+    notenum_ = nn;
+}
+
+// ---------------------------------------------------------------------------
+//  setSampleRate 
+// ---------------------------------------------------------------------------
+//  Set the sampling freqency in Hz for the spc data in this
+//  SpcFile. This is the rate at which Kyma must be running to ensure
+//  proper playback of bandwidth-enhanced Spc data.
+//
+void 
+SpcFile::setSampleRate( double rate )
+{
+    if ( rate <= 0 )
+    {
+        Throw( InvalidArgument, "Sample rate must be positive." );
+    }
+    rate_ = rate;
+}
+
+// -- helpers --
+
+// ---------------------------------------------------------------------------
+//  growPartials 
+// ---------------------------------------------------------------------------
+//
+void 
+SpcFile::growPartials( partials_type::size_type sz )
+{
+    if ( partials_.size() < sz )
+    {
+#ifdef PO2
+        partials_type::size_type po2sz = MinNumPartials;
+        while ( po2sz < sz )
+        {
+            po2sz *= 2;
+        }
+        partials_.resize( po2sz );
+#else
+        partials_.resize( sz );
+#endif
+        for ( partials_type::size_type j = 0; j < partials_.size(); ++j )
+        {
+            partials_[j].setLabel( j+1 );
+        }
+    }
+}
+
+// -- export structures --
+
+// ---------------------------------------------------------------------------
+//  Export Structures
+// ---------------------------------------------------------------------------
+//
+
+//  structure for export information
+struct SpcExportInfo
+{
+    double midipitch;       //  note number (69.00 = A440) for spc file;
+                            //  this is the core parameter, others are, by default,
+                            //  computed from this one
+    double endApproachTime; //  in seconds, this indicates how long before the end of the sound the
+                            //  amplitude, frequency, and bandwidth values are to be modified to
+                            //  make a gradual transition to the spectral content at the end,
+                            //  0.0 indicates no such modifications are to be done
+    int numPartials;        //  number of partials in spc file
+    int fileNumPartials;    //  the actual number of partials plus padding to make a 2**n value
+    int enhanced;           //  true for bandwidth-enhanced spc file, false for pure sines
+    double startTime;       //  in seconds, time of first frame in spc file
+    double endTime;         //  in seconds, this indicates the time at which to truncate the end
+                            //  of the spc file, 0.0 indicates no truncation
+    double markerTime;      //  in seconds, this indicates time at which a marker is inserted in the
+                            //  spc file, 0.0 indicates no marker is desired
+    double sampleRate;      //  in hertz, intended sample rate for synthesis of spc file
+    double hop;             //  hop size, based on numPartials and sampleRate
+    double ampEpsilon;      //  small amplitude value (related to lsb value in spc file log-amp)
+};
+
+static struct SpcExportInfo spcEI;      // yikky global spc Export information
+
+
+// -- export helpers by Lippold --
+
+// ---------------------------------------------------------------------------
+//  fileNumPartials
+// ---------------------------------------------------------------------------
+//  Find number of partials in SOS file.  This is the actual number of partials,
+//  plus padding to make a 2**n value. 
+//
+static int fileNumPartials( int partials )
+{
+    if ( partials <= 32 )   
+        return 32;
+    if ( partials <= 64 )   
+        return 64;
+    if ( partials <= 128 )  
+        return 128;
+    else if ( partials <= 256 )
+        return 256;
+    else if ( partials <= LargestLabel )
+        return LargestLabel;
+
+    Throw( FileIOException, "Too many SPC partials!" );
+    return LargestLabel;
+}
+
+// ---------------------------------------------------------------------------
+//  envLog( )
+// ---------------------------------------------------------------------------
+//  For a range 0 to 1, this returns a log value, 0x0000 to 0xFFFF.
+//
+static unsigned long envLog( double floatingValue )
+{
+    static double coeff = 65535.0 / log( 32768. );
+
+    return (unsigned long)( coeff * log( 32768.0 * floatingValue + 1.0 ) );
+
+}   //  end of envLog( )
+
+// ---------------------------------------------------------------------------
+//  envExp( )
+// ---------------------------------------------------------------------------
+//  For a range 0x0000 to 0xFFFF, this returns an exponentiated value in the range 0..1.
+//  This is the counterpart of SpcFile::envLog().
+//
+static double envExp( long intValue )
+{
+    static double coeff = 65535.0 / log( 32768. );
+
+    return ( exp( intValue / coeff ) - 1.0 ) / 32768.0;
+
+}   //  end of envExp( )
+
+// ---------------------------------------------------------------------------
+//  getPhaseRefTime
+// ---------------------------------------------------------------------------
+//  Find the time at which to reference phase.
+//  The time will be shortly after amplitude onset, if we are before the onset.
+//
+static double getPhaseRefTime( int label, const Partial & p, double time  )
+{
+// Keep array of previous values to optimize spc export.
+// This depends on this routine being called in increasing-time order.
+    static double prevPRT[LargestLabel + 1];
+    if ( prevPRT[label] > time && time > spcEI.startTime )
+        return prevPRT[ label ]; 
+            
+// Go forward to nonzero amplitude.
+    while ( p.amplitudeAt( time, Fade ) < spcEI.ampEpsilon && time < spcEI.endTime + spcEI.hop)
+    {
+        time += spcEI.hop;
+    }
+
+    prevPRT[ label ] = time;
+
+// Use phase value at initial onset time.
+    return time;
+        
+}
+
+// ---------------------------------------------------------------------------
+//  afbp
+// ---------------------------------------------------------------------------
+//  Find amplitude, frequency, bandwidth, phase value.  
+//
+static void afbp( const Partial & p, double time, double phaseRefTime,
+                  double magMult, double freqMult, 
+                  double & amp, double & freq, double & bw, double & phase)
+{   
+    
+// Optional endApproachTime processing:
+// Approach amp, freq, and bw values at endTime, and stick at endTime amplitude.
+// We avoid a sudden transition when using stick-at-end-frame sustains.
+// Compute weighting factor between "normal" envelope point and static point.
+    if ( spcEI.endApproachTime && time > spcEI.endTime - spcEI.endApproachTime )
+    {
+        if ( time > p.endTime() && p.endTime() > spcEI.endTime - 2 * spcEI.hop)
+            time = p.endTime();
+        double wt = ( spcEI.endTime - time ) / spcEI.endApproachTime;
+        amp   = magMult  * ( wt * p.amplitudeAt( time, Fade ) + 
+                             (1.0 - wt) * p.amplitudeAt( spcEI.endTime, Fade )  );
+        freq  = freqMult * ( wt * p.frequencyAt( time ) + (1.0 - wt) * p.frequencyAt( spcEI.endTime )  );
+        bw    =            ( wt * p.bandwidthAt( time ) + (1.0 - wt) * p.bandwidthAt( spcEI.endTime )  );
+        phase = p.phaseAt( time );
+    }
+    
+// If we are before the phase reference time, or on the final frame,
+// use zero amp and offset phase.
+    else if ( time < phaseRefTime - spcEI.hop / 2 || time > spcEI.endTime - spcEI.hop / 2 )
+    {
+        amp = 0.;
+        freq = freqMult * p.frequencyAt( phaseRefTime );
+        bw = 0.;
+        phase = p.phaseAt( phaseRefTime ) - 2. * Pi * (phaseRefTime - time) * freq;
+    }
+    
+// Use envelope values at "time".
+    else
+    {
+        amp = magMult * p.amplitudeAt( time, Fade );
+        freq = freqMult * p.frequencyAt( time );
+        bw = p.bandwidthAt( time );
+        phase = p.phaseAt( time );
+    }
+}
+
+// ---------------------------------------------------------------------------
+//  pack
+// ---------------------------------------------------------------------------
+//  Pack envelope breakpoint value for interpretation by Envelope Reader sounds
+//  in Kyma.  The packed result is two 24-bit quantities, lval and rval.
+//
+//  In lval, the log of the sine magnitude occupies the top 8 bits, the log of the
+//  frequency occupies the bottom 16 bits.
+//
+//  In rval, the log of the noise magnitude occupies the top 8 bits, the scaled
+//  linear phase occupies the bottom 16 bits. 
+//
+//  lval and rval are pointers to 3-bytes each, filled in by this function.
+//
+static void pack( double amp, double freq, double bw, double phase,
+                  Byte * lbytes, Byte * rbytes )
+{   
+
+// Set phase for one hop earlier, so that Kyma synthesis target phase is correct.
+// Add offset to phase for difference between Kyma and Loris representation.
+    phase -= 2. * Pi * spcEI.hop * freq; 
+    phase += Pi / 2;
+
+// Make phase into range 0..1.  
+    phase = std::fmod( phase, 2. * Pi );
+    while ( phase < 0. ) 	// used to be if, I think it should be while
+    {						// -kel 12 May 2006
+        phase += 2. * Pi; 
+    }
+    double zeroToOnePhase = phase / (2. * Pi);
+
+// Make frequency into range 0..1.
+    double zeroToOneFreq = freq / 22050.0;      // 0..1 , 1 is 22.050 kHz
+
+// Compute sine magnitude and noise magnitude from amp and bw.  
+    double theSineMag = amp * sqrt( 1. - bw );
+    double theNoiseMag = 64.0 * amp * sqrt( bw );
+    if (theNoiseMag > 1.0)
+        theNoiseMag = 1.0;
+
+// Pack amp and freq into 24 least-significant bits of lval:    
+// 7 bits of log-sine-amplitude with 16 bits of zero to right.
+// 16 bits of log-frequency with 0 bits of zero to right.
+    unsigned long lval;
+    lval = ( envLog( theSineMag ) & 0xFE00 ) << 7;
+    lval |= ( envLog( zeroToOneFreq ) & 0xFFFF );
+    
+//  store in lbytes:
+//  store the sample bytes in big endian order, 
+//  most significant byte first:
+    const int BytesPerSample = 3;
+    for ( int j = BytesPerSample; j > 0; --j )
+    {
+        //  mask the lowest byte after shifting:
+        *(lbytes++) = 0xFF & (lval >> (8*(j-1)));
+    }
+
+// Pack noise amp and phase into 24 least-significant bits of rval:
+// 7 bits of log-noise-amplitude with 16 bits of zero to right.
+// 16 bits of phase with 0 bits of zero to right.
+    unsigned long rval;
+    rval = ( envLog( theNoiseMag ) & 0xFE00 ) << 7;
+    rval  |= ( (unsigned long) ( zeroToOnePhase * 0xFFFF ) );
+
+//  store in rbytes:
+//  store the sample bytes in big endian order, 
+//  most significant byte first:
+    for ( int j = BytesPerSample; j > 0; --j )
+    {
+        //  mask the lowest byte after shifting:
+        *(rbytes++) = 0xFF & (rval >> (8*(j-1)));
+    }
+}
+
+// ---------------------------------------------------------------------------
+//  packEnvelopes
+// ---------------------------------------------------------------------------
+//  The partials should be labeled and distilled before this is called.
+//
+static bool notEmpty( const Partial & p )  { return p.size() > 0; }
+
+static void packEnvelopes( const SpcFile::partials_type & partials, 
+                           std::vector< Byte > & bytes )
+{   
+//  Assert( partials.size() == spcEI.fileNumPartials );
+
+    int frames = int( ( spcEI.endTime - spcEI.startTime ) / spcEI.hop ) + 1;
+    unsigned long dataSize = 
+        frames * spcEI.fileNumPartials * ( 24 / 8 ) * (spcEI.enhanced ? 2 : 1);
+    bytes.clear();
+    bytes.reserve( dataSize );
+    
+    // get the reference partial; the lowest-nonzero-labeled partial with any breakpoints
+    SpcFile::partials_type::const_iterator pos = 
+        std::find_if( partials.begin(), partials.end(), notEmpty );
+    Assert( pos != partials.end() );
+    const Partial & refPar = *pos;
+    int refLabel = refPar.label();
+    Assert( (refLabel - 1) == (pos - partials.begin()) );
+    
+    // write out one frame at a time:
+    for (double tim = spcEI.startTime; tim <= spcEI.endTime; tim += spcEI.hop ) 
+    {
+        //  for each frame, write one value for every partial:
+        //  (this loop extends to the pad partials)
+        for (unsigned int label = 1; label <= spcEI.fileNumPartials; ++label ) 
+        {
+            double amp, freq, bw, phase;
+            //  find partial with the correct label
+            //  if partial with the correct is empty, 
+            //  frequency-multiply the reference partial
+#ifndef PO2
+            if ( label > partials.size() || partials[ label - 1 ].size() == 0 )
+#else
+            if ( partials[ label - 1 ].size() == 0 )
+#endif
+            {
+                //  find the reference time for the phase
+                double phaseRefTime = getPhaseRefTime( label, refPar, tim );
+                
+                //  find amplitude, frequency, bandwidth, phase value
+                double freqMult = (double) label / (double) refLabel; 
+                double magMult = 0.0;
+                afbp( refPar, tim, phaseRefTime, magMult, freqMult, amp, freq, bw, phase );
+            }
+            else
+            {
+                //  find the reference time for the phase
+                double phaseRefTime = getPhaseRefTime( label, partials[ label - 1 ], tim );
+                
+                //  find amplitude, frequency, bandwidth, phase value
+                afbp( partials[ label - 1 ], tim, phaseRefTime, 1, 1, amp, freq, bw, phase );
+            }
+            
+            //  pack log amplitude and log frequency into 24-bit lval,
+            //  log bandwidth and phase into 24-bit rval:
+            Byte leftbytes[3], rightbytes[3];
+            pack( amp, freq, bw, phase, leftbytes, rightbytes);
+    
+            //  pack integer samples into the Byte vector without 
+            //  byte swapping, they are already correctly packed
+            //  (see pack above): 
+            bytes.insert( bytes.end(), leftbytes, leftbytes + 3 );
+            if ( spcEI.enhanced )
+            {
+                bytes.insert( bytes.end(), rightbytes, rightbytes + 3 );
+            }               
+        }
+    }
+    
+    Assert( bytes.size() == dataSize );
+}
+
+// ---------------------------------------------------------------------------
+//  configureEnvelopeDataCk
+// ---------------------------------------------------------------------------
+//  Configure a special SoundDataCk for exporting Spc envelopes.
+//
+static void 
+configureEnvelopeDataCk( SoundDataCk & ck, const SpcFile::partials_type & partials  )
+{
+    packEnvelopes( partials, ck.sampleBytes );
+    
+    ck.header.id = SoundDataId;
+
+    //  size is everything after the header:
+    ck.header.size = sizeof(Uint_32) +      //  offset
+                     sizeof(Uint_32) +      //  block size
+                     ck.sampleBytes.size(); //  sample data
+
+    //  no block alignment: 
+    ck.offset = 0;
+    ck.blockSize = 0;
+}
+
+// ---------------------------------------------------------------------------
+//  configureSosMarkerCk
+// ---------------------------------------------------------------------------
+//  Spc needs a special version of this, because Marker times have to be
+//  rounded to the nearest frame.
+//
+void 
+configureSosMarkerCk( MarkerCk & ck, const std::vector< Marker > & markers  )
+{
+    ck.header.id = MarkerId;
+
+    //  accumulate data size
+    Uint_32 dataSize = sizeof(Uint_16); //  num markers
+    
+    ck.numMarkers = markers.size();
+    ck.markers.resize( markers.size() );
+    for ( int j = 0; j < markers.size(); ++j )
+    {
+        MarkerCk::Marker & m = ck.markers[j];
+        m.markerID = j+1;
+        //m.position = Uint_32((markers[j].time() * srate) + 0.5);
+        
+        //  align marker with nearest frame time:
+        m.position = Uint_32( markers[j].time() / spcEI.hop ) 
+                     * spcEI.fileNumPartials 
+                     * ( spcEI.enhanced ? 2 : 1 ); 
+
+        m.markerName = markers[j].name();
+        
+        #define MAX_PSTRING_CHARS 254
+        if ( m.markerName.size() > MAX_PSTRING_CHARS )
+            m.markerName.resize( MAX_PSTRING_CHARS );
+        
+        //  the size of a pascal string is the number of 
+        //  characters plus the size byte, plus the terminal '\0':
+        //  
+        //  Actualy, at least one web source indicates that Pascal
+        //  strings are not null-terminated, but that they _are_
+        //  padded with an extra (not part of the count) byte
+        //  if necessary to ensure that the total length (including
+        //  count) is even, and this seems to work better with other
+        //  programs (e.g. Kyma)
+        if ( m.markerName.size()%2 == 0 )
+                m.markerName += '\0';
+        dataSize += sizeof(Uint_16) + sizeof(Uint_32) + (m.markerName.size() + 1);
+    }
+
+    //  must be an even number of bytes
+    if ( dataSize%2 )
+        ++dataSize;
+
+    ck.header.size = dataSize;
+}
+
+
+// ---------------------------------------------------------------------------
+//  configureSosEnvelopesCk
+// ---------------------------------------------------------------------------
+//  Configure a the application-specific chunk for exporting Spc envelopes.
+//
+static void
+configureSosEnvelopesCk( SosEnvelopesCk & ck )
+{
+    ck.header.id = ApplicationSpecificId;
+
+    //  size is everything after the header:
+    ck.header.size = sizeof(Uint_32) +                  // signature
+                     sizeof(Uint_32) +                  // enhanced
+                     sizeof(Uint_32) +                  // validPartials
+                     // this last bit is a big, obsolete array, that
+                     // we now use two positions in, an they aren't
+                     // even the first two! Truly nasty.
+                     4*LargestLabel + 8 * sizeof(Int_32);// initPhase[] et al
+    
+    ck.signature = SosEnvelopesId;
+
+    ck.enhanced = spcEI.enhanced;
+    
+    //  the number of partials is doubled in bandwidth-enhanced spc files
+    ck.validPartials = spcEI.numPartials * ( spcEI.enhanced ? 2 : 1 );
+    
+    //  resolution in microseconds
+    ck.resolution = long( 1000000.0 * spcEI.hop );
+    
+    //  all partials quasiharmonic
+    //  the number of partials is doubled in bandwidth-enhanced spc files
+    ck.quasiHarmonic =  spcEI.numPartials * ( spcEI.enhanced ? 2 : 1); 
+
+}
+
+// ---------------------------------------------------------------------------
+//  writeSosEnvelopesChunk
+// ---------------------------------------------------------------------------
+//
+std::ostream & 
+writeSosEnvelopesChunk( std::ostream & s, const SosEnvelopesCk & ck )
+{
+    //  write it out:
+    try 
+    {
+        BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.header.id );
+        BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.header.size );
+        BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.signature );
+        BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.enhanced );
+        BigEndian::write( s, 1, sizeof(Int_32), (char *)&ck.validPartials );
+        
+        // The SOSresultion and SOSquasiHarmonic fields are in the phase table memory.
+        //BigEndian::write( s, initPhaseLth, sizeof(Int_32), (char *)&ck.initPhase[0] );
+        static const int InitPhaseLth = ( LargestLabel + 8 );
+        Int_32 bogus[ InitPhaseLth ]; // obsolete initial phase array
+        std::fill( bogus, bogus + InitPhaseLth, 0 );
+        bogus[ ck.validPartials ] = ck.resolution;
+        bogus[ ck.validPartials + 1 ] = ck.quasiHarmonic;
+        BigEndian::write( s, InitPhaseLth, sizeof(Int_32), (char *)bogus );
+    }
+    catch( FileIOException & ex ) 
+    {
+        ex.append( "Failed to write AIFF file Container chunk." );
+        throw;
+    }
+    
+    return s;
+
+}
+
+// ---------------------------------------------------------------------------
+//  computeHop
+// ---------------------------------------------------------------------------
+//  Find the hop size, based on number of partials and sample rate. 
+//
+static double computeHop( int numPartials, double sampleRate )
+{
+    return 2 * numPartials / sampleRate;
+}
+
+
+// ---------------------------------------------------------------------------
+//  computeStartTime
+// ---------------------------------------------------------------------------
+//  Find the start time: the earliest time of any labeled partial.
+//
+static double computeStartTime( const SpcFile::partials_type & pars )
+{
+    double startTime = 1000.;
+    for ( SpcFile::partials_type::const_iterator pIter = pars.begin(); pIter != pars.end(); ++pIter )
+        if ( pIter->size() > 0 && startTime > pIter->startTime() && pIter->label() > 0 )
+            startTime = pIter->startTime();
+    return startTime;
+}
+
+
+// ---------------------------------------------------------------------------
+//  computeEndTime
+// ---------------------------------------------------------------------------
+//  Find the end time: the latest time of any labeled partial.
+//
+static double computeEndTime( const SpcFile::partials_type & pars )
+{
+    double endTime = -1000.;
+    for ( SpcFile::partials_type::const_iterator pIter = pars.begin(); pIter != pars.end(); ++pIter )
+        if ( pIter->size() > 0 && endTime < pIter->endTime()  && pIter->label() > 0 )
+            endTime = pIter->endTime();
+    return endTime;
+}
+
+
+// ---------------------------------------------------------------------------
+//  computeNumPartials
+// ---------------------------------------------------------------------------
+//  Find the number of partials.
+//
+static long computeNumPartials( const SpcFile::partials_type & pars )
+{
+
+// We purposely consider partials with no breakpoints, to allow
+// a larger number of partials than actually have data.
+    int numPartials = 0;
+    for ( SpcFile::partials_type::const_iterator pIter = pars.begin(); pIter != pars.end(); ++pIter )
+        if ( numPartials < pIter->label() )
+            numPartials = pIter->label();
+
+// To ensure a reasonable hop time, make at least 32 partials.
+    return numPartials ? std::max( 32, numPartials ) : 0;
+}
+
+// ---------------------------------------------------------------------------
+//  configureExportStruct
+// ---------------------------------------------------------------------------
+static void
+configureExportStruct( const SpcFile::partials_type & plist, double midipitch,
+                       double endApproachTime, int enhanced )
+{   
+    //  note number (69.00 = A440) for spc file
+    spcEI.midipitch = midipitch;
+    
+    //  enhanced indicates a bandwidth-enhanced spc file; by default it is true.
+    //  if enhanced is false, no bandwidth or noise information is exported.
+    spcEI.enhanced = enhanced;
+    
+    //  endApproachTime is in seconds; by default it is zero (and has no effect).
+    //  a nonzero endApproachTime indicates that the plist does not include a
+    //  release, but rather ends in a static spectrum corresponding to the final
+    //  breakpoint values of the partials.  the endApproachTime specifies how
+    //  long before the end of the sound the amplitude, frequency, and bandwidth
+    //  values are to be modified to make a gradual transition to the static spectrum.
+    spcEI.endApproachTime = endApproachTime;
+    
+    //  number of partials in spc file
+    spcEI.numPartials = computeNumPartials( plist );
+    spcEI.fileNumPartials = fileNumPartials( spcEI.numPartials );
+    
+    //  start and end time of spc file
+    spcEI.startTime = computeStartTime( plist );
+    spcEI.endTime = computeEndTime( plist );
+
+    //  in seconds, this indicates time at which a marker is inserted 
+    //  in the spc file, 0.0 indicates no marker.  this is not being used currently.
+    spcEI.markerTime = 0.;
+        
+    //  in hertz, intended sample rate for synthesis of spc file
+    spcEI.sampleRate = 44100.;      
+    
+    //  compute hop size
+    spcEI.hop = computeHop( spcEI.numPartials, spcEI.sampleRate );
+
+    //  compute ampEpsilon, a small amplitude value twice the lsb value 
+    //  of log amp in packed spc format. 
+    spcEI.ampEpsilon = 2. * envExp( 0x200 );
+
+    // Max number of partials is due to (arbitrary) size of initPhase[].
+    if ( spcEI.numPartials < 1 || spcEI.numPartials > LargestLabel )
+        Throw( FileIOException, "Partials must be distilled and labeled between 1 and 512." );
+
+    debugger << "startTime = " << spcEI.startTime << " endTime = " << spcEI.endTime 
+             << " hop = " << spcEI.hop << " partials = " << spcEI.numPartials << endl;
+}
+
+// ---------------------------------------------------------------------------
+//  getNumSampleFrames
+// ---------------------------------------------------------------------------
+//  The number of exported sample frames is computed from data stored in
+//  the icky global export struct.
+//
+static unsigned long getNumSampleFrames( void )
+{
+    int frames = int( ( spcEI.endTime - spcEI.startTime ) / spcEI.hop ) + 1;
+    return frames * spcEI.fileNumPartials * ( spcEI.enhanced ? 2 : 1 );
+}
+
+// -- import helpers by Lippold --
+// ---------------------------------------------------------------------------
+//  processEnhancedPoint
+// ---------------------------------------------------------------------------
+//  Add ehanced-spc breakpoint to existing Loris partials.
+//
+static void
+processEnhancedPoint( Byte * leftbytes, Byte * rightbytes, 
+                      const double frameTime, 
+                      Partial & par )
+{
+//  represent bytes as 24 bit integers:
+    const int BytesPerSample = 3;   
+
+    //  assign the leading byte, so that the sign
+    //  is preserved:
+    long left = static_cast<char>(*(leftbytes++));
+    for ( int j = 1; j < BytesPerSample; ++j )
+    {
+        //  OR bytes after the most significant, so
+        //  that their sign is ignored:
+        left = (left << 8) + (unsigned char)*(leftbytes++);
+    }
+    
+    long right = static_cast<char>(*(rightbytes++));
+    for ( int j = 1; j < BytesPerSample; ++j )
+    {
+        //  OR bytes after the most significant, so
+        //  that their sign is ignored:
+        right = (right << 8) + (unsigned char)*(rightbytes++);
+    }
+//
+// Unpack values.  
+//
+    double freq = envExp( left & 0xffff ) * 22050.0;
+    double sineMag =     envExp( (left >> 7)  & 0xfe00 );
+    double noiseMag = envExp( (right >> 7) & 0xfe00 ) / 64.;
+    double phase = ( right & 0xffff ) * ( 2. * Pi / 0xffff );
+    
+    double total = sineMag * sineMag + noiseMag * noiseMag;
+
+    double amp = sqrt( total );
+    
+    double noise = 0.;
+    if (total != 0.)
+        noise = noiseMag * noiseMag / total;
+    if (noise > 1.)
+        noise = 1.;
+    
+    phase -= Pi / 2.;
+    if (phase < 0.)
+        phase += 2. * Pi;
+
+//
+// Create a new breakpoint and insert it.
+//  
+    Breakpoint newbp( freq, amp, noise, phase );
+    par.insert( frameTime, newbp );
+}
+
+// ---------------------------------------------------------------------------
+//  processSineOnlyPoint
+// ---------------------------------------------------------------------------
+//  Add sine-only spc breakpoint to existing Loris partials.
+//
+static void
+processSineOnlyPoint( Byte * bytes, 
+                      const double frameTime, 
+                      Partial & par )
+{
+//  represent bytes as 24 bit integers:
+    const int BytesPerSample = 3;   
+
+    //  assign the leading byte, so that the sign
+    //  is preserved:
+    long packed = static_cast<char>(*(bytes++));
+    for ( int j = 1; j < BytesPerSample; ++j )
+    {
+        //  OR bytes after the most significant, so
+        //  that their sign is ignored:
+        packed = (packed << 8) + (unsigned char)*(bytes++);
+    }
+
+//
+// Unpack values.  
+//
+    double freq = envExp( packed & 0xffff ) * 22050.0;
+    double amp =     envExp( (packed >> 7)  & 0xfe00 );
+    double noise = 0.;
+    double phase = 0.;
+
+//
+// Create a new breakpoint and insert it.
+//  
+    Breakpoint newbp( freq, amp, noise, phase );
+    par.insert( frameTime, newbp );
+}
+
+// ---------------------------------------------------------------------------
+//  readSpcData
+// ---------------------------------------------------------------------------
+//
+void 
+SpcFile::readSpcData( const std::string & filename )
+{
+    ContainerCk containerChunk;
+    CommonCk commonChunk;
+    SoundDataCk soundDataChunk;
+    InstrumentCk instrumentChunk;
+    MarkerCk markerChunk;
+    SosEnvelopesCk soseChunk;
+
+    try 
+    {
+        std::ifstream s( filename.c_str(), std::ifstream::binary );
+    
+        //  the Container chunk must be first, read it:
+        readChunkHeader( s, containerChunk.header );
+        if( containerChunk.header.id != ContainerId )
+            Throw( FileIOException, "Found no Container chunk." );
+        readContainer( s, containerChunk, containerChunk.header.size );
+        
+        //  read other chunks, we are only interested in
+        //  the Common chunk, the Sound Data chunk, the Markers: 
+        CkHeader h;
+        while ( readChunkHeader( s, h ) )
+        {           
+            switch (h.id)
+            {
+                case CommonId:
+                    readCommonData( s, commonChunk, h.size );
+                    if ( commonChunk.channels != 1 )
+                    {
+                        Throw( FileIOException, 
+                               "Loris only processes single-channel AIFF samples files." );
+                    }                   
+                    if ( commonChunk.bitsPerSample != 8 &&
+                         commonChunk.bitsPerSample != 16 &&
+                         commonChunk.bitsPerSample != 24 &&
+                         commonChunk.bitsPerSample != 32 )
+                    {
+                        Throw( FileIOException, "Unrecognized sample size." );
+                    }                                       
+                    break;
+                case SoundDataId:
+                    readSampleData( s, soundDataChunk, h.size );
+                    break;
+                case InstrumentId:
+                    readInstrumentData( s, instrumentChunk, h.size );
+                    break;
+                case MarkerId:
+                    readMarkerData( s, markerChunk, h.size );
+                    break;
+                case ApplicationSpecificId:
+                    readApplicationSpecifcData( s, soseChunk, h.size );
+                    break;
+                default:
+                    s.ignore( h.size );
+            }
+        }
+    
+        if ( ! commonChunk.header.id || ! soundDataChunk.header.id )
+        {
+            Throw( FileIOException, 
+                   "Reached end of file before finding both a Common chunk and a Sound Data chunk." );
+        }
+        if ( soseChunk.signature != SosEnvelopesId )
+        {
+            Throw( FileIOException, 
+                   "Reached end of file before finding a Spc Envelope Data chunk, this must not be a Spc file." );
+        }
+    }
+    catch ( Exception & ex ) 
+    {
+        ex.append( " Failed to read Spc file." );
+        throw;
+    }
+    
+    //  all the chunks have been read, use them to initialize
+    //  the SpcFile members:
+    rate_ = commonChunk.srate;
+
+    // why was this like this:
+    // double rate  = commonChunk.srate;
+    
+    if ( instrumentChunk.header.id )
+    {
+        notenum_ = instrumentChunk.baseNote;
+        notenum_ -= 0.01 * instrumentChunk.detune;
+    }
+    
+    //  extract information from SOSe chunk:
+    //  enhanced file format has number of partials doubled
+    //  sine-only file format has proper number of partials
+    bool enhanced = soseChunk.enhanced != 0;
+    int numPartials = enhanced ? soseChunk.validPartials / 2 : soseChunk.validPartials;
+    int numFrames = commonChunk.sampleFrames / ( fileNumPartials( numPartials ) * ( enhanced ? 2 : 1 ) );
+    double hop = soseChunk.resolution * 0.000001;   // resolution is in microseconds
+    
+    //  read markers, need to compute times corresponding to
+    //  spc frames:
+    if ( markerChunk.header.id )
+    {
+        for ( int j = 0; j < markerChunk.numMarkers; ++j )
+        {
+            MarkerCk::Marker & m = markerChunk.markers[j];
+            double markerTime = m.position * hop / ( fileNumPartials( numPartials ) * ( enhanced ? 2 : 1 ) );
+            markers_.push_back( Marker( markerTime, m.markerName ) );
+        }       
+    }
+
+
+    //  check for valid file
+    if ( numPartials == 0 || commonChunk.bitsPerSample != 24 )
+            Throw( FileIOException, "Not an SPC file." );
+    if ( numPartials < MinNumPartials || numPartials > LargestLabel )
+            Throw( FileIOException, "Bad number of partials in SPC file." );
+
+    //  check the number of bytes of Spc data:  
+    const int BytesPerSample = 3;
+    const int PredictedNumBytes = 
+        BytesPerSample * numFrames * fileNumPartials( numPartials ) * ( enhanced ? 2 : 1 );
+    if ( soundDataChunk.sampleBytes.size() != PredictedNumBytes )
+    {
+        notifier << "Found " << soundDataChunk.sampleBytes.size() << " bytes of "
+                 << commonChunk.bitsPerSample << "-bit sample data." << endl;
+        notifier << "Header says there should be " << PredictedNumBytes
+                 << "." << endl;
+    }
+
+    //  process SPC data points
+    partials_.clear();
+    growPartials( numPartials );
+    Byte * bytes = &soundDataChunk.sampleBytes.front();
+    for ( int frame = 0; frame < numFrames; ++frame ) 
+    {
+        for ( int partial = 0; partial < fileNumPartials( numPartials ); ++partial )
+        {
+            if (enhanced)
+            {
+                Byte * lbytes = bytes;
+                bytes += BytesPerSample;
+                Byte * rbytes = bytes;
+                bytes += BytesPerSample;
+                if ( partial < partials_.size() )
+                    processEnhancedPoint( lbytes, rbytes, frame * hop, partials_[partial] );
+            }
+            else
+            {
+                if ( partial < partials_.size() )
+                    processSineOnlyPoint( bytes, frame * hop, partials_[partial] );
+                bytes += BytesPerSample;
+            }
+        }
+    }
+}
+
+}   //  end of namespace Loris
diff --git a/src/loris/SpcFile.h b/src/loris/SpcFile.h
new file mode 100644
index 0000000..118b30d
--- /dev/null
+++ b/src/loris/SpcFile.h
@@ -0,0 +1,368 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * SpcFile.h
+ *
+ * Definition of SpcFile class for Partial import and export for
+ * real-time synthesis in Kyma.
+ *
+ * Spc files always represent a number of Partials that is a power of
+ * two. This is not necessary for purely-sinusoidal files, but might be
+ * (not clear) for enhanced data to be properly processed in Kyma. 
+ *
+ * All of this is kind of disgusting right now. This code has evolved 
+ * somewhat randomly, and we are awaiting full support for bandwidth-
+ * enhanced data in Kyma..
+ *
+ * Kelly Fitz, 8 Jan 2003 
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#include "Marker.h"
+#include "Partial.h"
+
+#if defined(NO_TEMPLATE_MEMBERS)
+#include "PartialList.h"
+#endif
+ 
+#include <string>
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	class SpcFile
+//
+//!	Class SpcFile represents a collection of reassigned bandwidth-enhanced
+//!	Partial data in a SPC-format envelope stream data file, used by the
+//!	real-time bandwidth-enhanced additive synthesizer implemented on the
+//!	Symbolic Sound Kyma Sound Design Workstation. Class SpcFile manages 
+//!	file I/O and conversion between Partials and envelope parameter streams.
+//	
+class SpcFile
+{
+//	-- public interface --
+public:
+
+//	-- types --
+
+	//! the type of the container of Markers
+	//! stored with an SpcFile
+	typedef std::vector< Marker > markers_type;		
+	
+	//! the type of the container of Partials
+	//! stored with an SpcFile
+	typedef std::vector< Partial > partials_type;	
+
+//	-- construction --
+
+	//!	Initialize an instance of SpcFile by importing envelope parameter 
+	//!	streams from the file having the specified filename or path.
+	//!
+	//! \param	filename the name of the file to import
+ 	explicit SpcFile( const std::string & filename );
+
+	//!	Initialize an instance of SpcFile with copies of the Partials
+	//!	on the specified half-open (STL-style) range.
+	//!
+	//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+	//!	only PartialList::const_iterator arguments.
+	//!
+	//! \param	begin_partials the beginning of a range of Partials to prepare
+	//!			for Spc export
+	//! \param	end_partials the end of a range of Partials to prepare
+	//!			for Spc export
+	//!	\param	midiNoteNum the fractional MIDI note number, if specified
+	//!			(default is 60)
+#if !defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+	SpcFile( Iter begin_partials, Iter end_partials, double midiNoteNum = 60  );
+#else
+	SpcFile( PartialList::const_iterator begin_partials, 
+			 PartialList::const_iterator end_partials,
+			 double midiNoteNum = 60  );
+#endif
+
+	//!	Initialize an instance of SpcFile having the specified fractional
+	//!	MIDI note number, and no Partials (or envelope parameter streams). 
+	//!
+	//!	\param	midiNoteNum the fractional MIDI note number, if specified
+	//!			(default is 60)
+	explicit SpcFile( double midiNoteNum = 60 );
+	 
+	//	copy, assign, and delete are compiler-generated
+	
+//	-- access --
+
+	//!	Return a reference to the MarkerContainer (see Marker.h) for this SpcFile. 
+	markers_type & markers( void );
+	
+	//!	Return a reference to the MarkerContainer (see Marker.h) for this SpcFile. 
+	const markers_type & markers( void ) const;
+	 
+	//!	Return the fractional MIDI note number assigned to this SpcFile. 
+	//!	If the sound has no definable pitch, note number 60.0 is used.
+	double midiNoteNumber( void ) const;
+	
+	//!	Return a read-only (const) reference to the bandwidth-enhanced
+	//! Partials represented by the envelope parameter streams in this SpcFile.
+	const partials_type & partials( void ) const;
+	
+	//!	Return the sampling freqency in Hz for the spc data in this
+	//!	SpcFile. This is the rate at which Kyma must be running to ensure
+	//!	proper playback of bandwidth-enhanced Spc data.
+ 	double sampleRate( void ) const;
+	
+//	-- mutation --
+
+	//!	Add the specified Partial to the enevelope parameter streams
+	//!	represented by this SpcFile. 
+	//!	
+	//!	A SpcFile can contain only one Partial having any given (non-zero) 
+	//!	label, so an added Partial will replace a Partial having the 
+	//!	same label, if such a Partial exists.
+	//!
+	//!	This may throw an InvalidArgument exception if an attempt is made
+	//!	to add unlabeled Partials, or Partials labeled higher than the
+	//!	allowable maximum.
+	//!
+	//!	\param	p the Partial to add to this SpcFile
+	void addPartial( const Loris::Partial & p );
+	 
+	//!	Add a Partial, assigning it the specified label (and position in the
+	//!	Spc data).
+	//!	
+	//!	A SpcFile can contain only one Partial having any given (non-zero) 
+	//!	label, so an added Partial will replace a Partial having the 
+	//!	same label, if such a Partial exists.
+	//!
+	//!	This may throw an InvalidArgument exception if an attempt is made
+	//!	to add unlabeled Partials, or Partials labeled higher than the
+	//!	allowable maximum.
+	//!
+	//!	\param	p the Partial to add to this SpcFile
+	//! \param	label the label to associate with this Partial in 
+	//!			the Spc file (the Partial's own label is ignored).
+	void addPartial( const Loris::Partial & p, int label );
+	 
+	//!	Add all Partials on the specified half-open (STL-style) range
+	//!	to the enevelope parameter streams represented by this SpcFile. 
+	//!	
+	//!	A SpcFile can contain only one Partial having any given (non-zero) 
+	//!	label, so an added Partial will replace a Partial having the 
+	//!	same label, if such a Partial exists.
+	//!
+	//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+	//!	only PartialList::const_iterator arguments.
+	//!
+	//!	This may throw an InvalidArgument exception if an attempt is made
+	//!	to add unlabeled Partials, or Partials labeled higher than the
+	//!	allowable maximum.
+	//!
+	//! \param	begin_partials the beginning of a range of Partials
+	//!			to add to this Spc file
+	//! \param	end_partials the end of a range of Partials
+	//!			to add to this Spc file
+#if !defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+	void addPartials( Iter begin_partials, Iter end_partials  );
+#else
+	void addPartials( PartialList::const_iterator begin_partials, 
+					  PartialList::const_iterator end_partials  );
+#endif
+
+	//!	Set the fractional MIDI note number assigned to this SpcFile. 
+	//!	If the sound has no definable pitch, use note number 60.0 
+	//! (the default).
+	void setMidiNoteNumber( double nn );
+
+	//!	Set the sampling freqency in Hz for the spc data in this
+	//!	SpcFile. This is the rate at which Kyma must be running to ensure
+	//!	proper playback of bandwidth-enhanced Spc data.
+	//!	
+	//!	The default sample rate is 44100 Hz.
+	void setSampleRate( double rate );
+	 	
+//	-- export --
+
+	//!	Export the phase-correct bandwidth-enhanced envelope parameter 
+	//!	streams represented by this SpcFile to the file having the specified 
+	//!	filename or path. 
+	//!	
+	//!	A nonzero endApproachTime indicates that the Partials do not include a
+	//!	release or decay, but rather end in a static spectrum corresponding to the
+	//!	final Breakpoint values of the partials. The endApproachTime specifies how
+	//!	long before the end of the sound the amplitude, frequency, and bandwidth
+	//!	values are to be modified to make a gradual transition to the static spectrum.
+	//!	
+	//!	If the endApproachTime is not specified, it is assumed to be zero, 
+	//!	corresponding to Partials that decay or release normally.
+	//!
+	//! \param	filename the name of the file to create
+	//! \param	endApproachTime the duration in seconds of the gradual transition
+	//!			to a static spectrum at the end of the sound (default 0)
+	void write( const std::string & filename, double endApproachTime = 0 );
+
+	//!	Export the pure sinsoidal (omitting phase and bandwidth data) envelope 
+	//!	parameter streams represented by this SpcFile to the file having the 
+	//!	specified filename or path. 
+	//!	
+	//!	A nonzero endApproachTime indicates that the Partials do not include a
+	//!	release or decay, but rather end in a static spectrum corresponding to the
+	//!	final Breakpoint values of the partials. The endApproachTime specifies how
+	//!	long before the end of the sound the amplitude, frequency, and bandwidth
+	//!	values are to be modified to make a gradual transition to the static spectrum.
+	//!	
+	//!	If the endApproachTime is not specified, it is assumed to be zero, 
+	//!	corresponding to Partials that decay or release normally.
+	//!
+	//! \param	filename the name of the file to create
+	//! \param	endApproachTime the duration in seconds of the gradual transition
+	//!			to a static spectrum at the end of the sound (default 0)
+	void writeSinusoidal( const std::string & filename, double endApproachTime = 0 );
+
+	//!	Export the envelope parameter streams represented by this SpcFile to
+	//!	the file having the specified filename or path. Export phase-correct 
+	//!	bandwidth-enhanced envelope parameter streams if enhanced is true 
+	//!	(the default), or pure sinsoidal streams otherwise.
+	//!
+	//!	A nonzero endApproachTime indicates that the Partials do not include a
+	//!	release or decay, but rather end in a static spectrum corresponding to the
+	//!	final Breakpoint values of the partials. The endApproachTime specifies how
+	//!	long before the end of the sound the amplitude, frequency, and bandwidth
+	//!	values are to be modified to make a gradual transition to the static spectrum.
+	//!	
+	//!	If the endApproachTime is not specified, it is assumed to be zero, 
+	//!	corresponding to Partials that decay or release normally.
+	//!	
+	//!	\deprecated This version of write is deprecated, use the two-argument
+	//!	versions write and writeSinusoidal. 
+	//!
+	//! \param	filename the name of the file to create
+	//! \param	enhanced flag indicating whether to export enhanced (true)
+	//!			or sinusoidal (false) data
+	//! \param	endApproachTime the duration in seconds of the gradual transition
+	//!			to a static spectrum at the end of the sound (default 0)
+	void write( const std::string & filename, bool enhanced,
+				double endApproachTime = 0 );
+
+private:
+//	-- implementation --
+	partials_type partials_;	//!	Partials to store in Spc format
+	markers_type markers_;		//!	AIFF Markers
+
+	double notenum_;			//! fractional MIDI note number
+	double rate_;				//! sample rate in Hz at which the data plays at the
+								//! correction default pitch
+	
+	static const int MinNumPartials;	//!	the minimum number of Partials to export (32)
+										//!	(if necessary, extra empty (silent) Partials
+										//! will be exported to make up the difference between
+										//!	the size of partials_ and the next larger power
+										//! of two, not less than MinNumPartials
+	static const double DefaultRate;	//!	the default Spc export sample rate in Hz (44kHz)
+
+//	-- helpers --
+	void readSpcData( const std::string & filename );
+	void growPartials( partials_type::size_type sz );
+	
+};	//	end of class SpcFile
+
+
+// ---------------------------------------------------------------------------
+//	constructor from Partial range
+// ---------------------------------------------------------------------------
+//!	Initialize an instance of SpcFile with copies of the Partials
+//!	on the specified half-open (STL-style) range.
+//!
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+//!	only PartialList::const_iterator arguments.
+//!
+//! \param	begin_partials the beginning of a range of Partials to prepare
+//!			for Spc export
+//! \param	end_partials the end of a range of Partials to prepare
+//!			for Spc export
+//!	\param	midiNoteNum the fractional MIDI note number, if specified
+//!			(default is 60)
+#if !defined(NO_TEMPLATE_MEMBERS)
+template< typename Iter >
+SpcFile::SpcFile( Iter begin_partials, Iter end_partials, double midiNoteNum  ) :
+#else
+SpcFile::SpcFile( PartialList::const_iterator begin_partials, 
+				  PartialList::const_iterator end_partials,
+				  double midiNoteNum ) :
+#endif
+//	initializers:
+	notenum_( midiNoteNum ),
+	rate_( DefaultRate )
+{
+	growPartials( MinNumPartials );
+	addPartials( begin_partials, end_partials );
+}
+
+// ---------------------------------------------------------------------------
+//	addPartials 
+// ---------------------------------------------------------------------------
+//!	Add all Partials on the specified half-open (STL-style) range
+//!	to the enevelope parameter streams represented by this SpcFile. 
+//!	
+//!	A SpcFile can contain only one Partial having any given (non-zero) 
+//!	label, so an added Partial will replace a Partial having the 
+//!	same label, if such a Partial exists.
+//!
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, this member accepts
+//!	only PartialList::const_iterator arguments.
+//!
+//!	This may throw an InvalidArgument exception if an attempt is made
+//!	to add unlabeled Partials, or Partials labeled higher than the
+//!	allowable maximum.
+//!
+//! \param	begin_partials the beginning of a range of Partials
+//!			to add to this Spc file
+//! \param	end_partials the end of a range of Partials
+//!			to add to this Spc file
+#if !defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void SpcFile::addPartials( Iter begin_partials, Iter end_partials  )
+#else
+void SpcFile::addPartials( PartialList::const_iterator begin_partials, 
+						   PartialList::const_iterator end_partials  )
+#endif
+{
+	while ( begin_partials != end_partials )
+	{
+	    // do not try to add unlabeled Partials, or 
+	    // Partials labeled beyond 256:
+	    if ( 0 != begin_partials->label() && 257 > begin_partials->label() )
+	    {
+		    addPartial( *begin_partials );
+		}
+		++begin_partials;
+	}
+}
+
+}	//	end of namespace Loris
+
+
diff --git a/src/loris/SpectralPeakSelector.C b/src/loris/SpectralPeakSelector.C
new file mode 100644
index 0000000..a6cbc15
--- /dev/null
+++ b/src/loris/SpectralPeakSelector.C
@@ -0,0 +1,248 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * SpectralPeakSelector.C
+ *
+ * Implementation of a class representing a policy for selecting energy
+ * peaks in a reassigned spectrum to be used in Partial formation.
+ *
+ * Kelly Fitz, 28 May 2003
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "SpectralPeakSelector.h"
+
+
+#include "Breakpoint.h"
+#include "Notifier.h"
+#include "ReassignedSpectrum.h"
+
+
+#include <cmath>    //  for abs and fabs
+
+
+// define this to use local minima in frequency
+// reassignment to detect "peaks", otherwise 
+// magnitude peaks are used.
+#define USE_REASSIGNMENT_MINS 1
+//#undef USE_REASSIGNMENT_MINS
+
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	construction - constant resolution
+// ---------------------------------------------------------------------------
+SpectralPeakSelector::SpectralPeakSelector( double srate, double maxTimeCorrection ) :
+	mSampleRate( srate ),
+    mMaxTimeOffset( maxTimeCorrection )
+{
+}
+
+// ---------------------------------------------------------------------------
+//	selectPeaks
+// ---------------------------------------------------------------------------
+//	Collect and return magnitude peaks in the lower half of the spectrum, 
+//	ignoring those having frequencies below the specified minimum, and
+//	those having large time corrections.
+//
+//  If the minimumFrequency is unspecified, 0 Hz is used.
+//
+//  There are two strategies for doing. Probably each one should be a 
+//  separate class, but for now, they are just separate functions.
+
+Peaks
+SpectralPeakSelector::selectPeaks( ReassignedSpectrum & spectrum, 
+                                   double minFrequency )
+{
+#if defined(USE_REASSIGNMENT_MINS) && USE_REASSIGNMENT_MINS
+
+    return selectReassignmentMinima( spectrum, minFrequency );
+    
+#else
+
+    return selectMagnitudePeaks( spectrum, minFrequency );
+    
+#endif
+}
+
+// ---------------------------------------------------------------------------
+//	selectReassignmentMinima (private)
+// ---------------------------------------------------------------------------
+Peaks
+SpectralPeakSelector::selectReassignmentMinima( ReassignedSpectrum & spectrum, 
+                                                double minFrequency )
+{
+	using namespace std; // for abs and fabs
+
+	const double sampsToHz = mSampleRate / spectrum.size();
+	const double oneOverSR = 1. / mSampleRate;
+	const double minFreqSample = minFrequency / sampsToHz;
+	const double maxCorrectionSamples = mMaxTimeOffset * mSampleRate;
+	
+	Peaks peaks;
+	
+	int start_j = 1, end_j = (spectrum.size() / 2) - 2;
+	
+	double fsample = start_j;
+	do 
+	{
+	    fsample = spectrum.reassignedFrequency( start_j++ );
+	} while( fsample < minFreqSample );
+	
+	for ( int j = start_j; j < end_j; ++j ) 
+	{	 
+
+	    // look for changes in the frequency reassignment,
+	    // from positive to negative correction, indicating
+	    // a concentration of energy in the spectrum:
+	    double next_fsample = spectrum.reassignedFrequency( j+1 );
+	    if ( fsample > j && next_fsample < j + 1 )
+	    {
+	        //  choose the smaller correction of fsample or next_fsample:
+	        // (could also choose the larger magnitude?)
+	        double freq;
+	        int peakidx;
+	        if ( (fsample-j) < (j+1-next_fsample) )
+	        {
+	            freq = fsample * sampsToHz;
+	            peakidx = j;
+	        }
+	        else
+	        {
+	            freq = next_fsample * sampsToHz;
+	            peakidx = j+1;
+	        }
+            
+            //  still possible that the frequency winds up being
+            //  below the specified minimum
+            if ( freq >= minFrequency )
+            {            	         
+                //	keep only peaks with small time corrections:
+                double timeCorrectionSamps = spectrum.reassignedTime( peakidx );
+                if ( fabs(timeCorrectionSamps) < maxCorrectionSamples )
+                {
+                    double mag = spectrum.reassignedMagnitude( peakidx );
+                    double phase = spectrum.reassignedPhase( peakidx );    			
+
+                    //	this will be overwritten later in analysis, 
+                    //	might be ignored altogether, only used if the
+                    //	mixed derivative convergence indicator is stored
+                    //	as bandwidth in Analyzer:
+                    double bw = spectrum.convergence( j );
+
+
+                    //	also store the corrected peak time in seconds, won't
+                    //	be able to compute it later:
+                    double time = timeCorrectionSamps * oneOverSR;
+                    Breakpoint bp( freq, mag, bw, phase );
+                    peaks.push_back( SpectralPeak( time, bp ) );
+                }
+            }
+                	        
+	    }
+	    fsample = next_fsample;
+	}
+    
+	/*
+	debugger << "SpectralPeakSelector::selectReassignmentMinima: found " 
+             << peaks.size() << " peaks" << endl;
+	*/
+    	
+	return peaks;
+
+}
+
+// ---------------------------------------------------------------------------
+//	selectMagnitudePeaks (private)
+// ---------------------------------------------------------------------------
+Peaks
+SpectralPeakSelector::selectMagnitudePeaks( ReassignedSpectrum & spectrum,
+                                            double minFrequency )
+{
+	using namespace std; // for abs and fabs
+
+	const double sampsToHz = mSampleRate / spectrum.size();
+	const double oneOverSR = 1. / mSampleRate;
+	const double minFreqSample = minFrequency / sampsToHz;
+	const double maxCorrectionSamples = mMaxTimeOffset * mSampleRate;
+	
+	Peaks peaks;
+	
+	int start_j = 1, end_j = (spectrum.size() / 2) - 2;
+	
+	double fsample = start_j;
+	do 
+	{
+	    fsample = spectrum.reassignedFrequency( start_j++ );
+	} while( fsample < minFreqSample );
+	
+	for ( int j = start_j; j < end_j; ++j ) 
+	{	 
+		if ( spectrum.reassignedMagnitude(j) > spectrum.reassignedMagnitude(j-1) && 
+			 spectrum.reassignedMagnitude(j) > spectrum.reassignedMagnitude(j+1) ) 
+		{				
+			//	skip low-frequency peaks:
+			double fsample = spectrum.reassignedFrequency( j );
+			if ( fsample < minFreqSample )
+				continue;
+
+			//	skip peaks with large time corrections:
+			double timeCorrectionSamps = spectrum.reassignedTime( j );
+			if ( fabs(timeCorrectionSamps) > maxCorrectionSamples )
+				continue;
+				
+			double mag = spectrum.reassignedMagnitude( j );
+			double phase = spectrum.reassignedPhase( j );
+			
+			//	this will be overwritten later in analysis, 
+			//	might be ignored altogether, only used if the
+			//	mixed derivative convergence indicator is stored
+			//	as bandwidth in Analyzer:
+			double bw = spectrum.convergence( j );
+			
+			//	also store the corrected peak time in seconds, won't
+			//	be able to compute it later:
+			double time = timeCorrectionSamps * oneOverSR;
+			Breakpoint bp ( fsample * sampsToHz, mag, bw, phase );
+			peaks.push_back( SpectralPeak( time, bp ) );
+						
+		}	//	end if itsa peak
+	}
+	
+    /*
+	debugger << "SpectralPeakSelector::selectMagnitudePeaks: found " 
+             << peaks.size() << " peaks" << endl;
+    */         		
+	return peaks;
+}
+
+
+}	//	end of namespace Loris
diff --git a/src/loris/SpectralPeakSelector.h b/src/loris/SpectralPeakSelector.h
new file mode 100644
index 0000000..c55056e
--- /dev/null
+++ b/src/loris/SpectralPeakSelector.h
@@ -0,0 +1,90 @@
+#ifndef INCLUDE_SPECTRALPEAKSELECTOR_H
+#define INCLUDE_SPECTRALPEAKSELECTOR_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * SpectralPeakSelector.h
+ *
+ * Definition of a class representing a policy for selecting energy
+ * peaks in a reassigned spectrum to be used in Partial formation.
+ *
+ * Kelly Fitz, 28 May 2003
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+ 
+#include "SpectralPeaks.h"
+
+//	begin namespace
+namespace Loris {
+
+class ReassignedSpectrum;
+
+// ---------------------------------------------------------------------------
+//	class SpectralPeakSelector
+//
+//	A class representing the process of selecting 
+//	peaks (ridges) on a reassigned time-frequency surface.
+//
+class SpectralPeakSelector
+{
+// --- interface ---
+public:
+	//	construction:
+	SpectralPeakSelector( double srate, double maxTimeCorrection );
+
+	//	Collect and return magnitude peaks in the lower half of the spectrum, 
+	//	ignoring those having frequencies below the specified minimum (in Hz), and
+	//	those having large time corrections.
+    //
+    //  If the minimumFrequency is unspecified, 0 Hz is used.
+	//
+    //  There are two strategies for doing. Probably each one should be a 
+    //  separate class, but for now, they are just separate functions.
+    Peaks selectPeaks( ReassignedSpectrum & spectrum, double minFrequency = 0 );
+    
+    	
+// --- implementation ---
+private:
+
+    //  There are two strategies for doing. Probably each one should be a 
+    //  separate class, but for now, they are just separate functions.
+    //
+    //  Currently, the reassignment minima are used.
+    
+    Peaks selectReassignmentMinima( ReassignedSpectrum & spectrum, double minFrequency );
+    Peaks selectMagnitudePeaks( ReassignedSpectrum & spectrum, double minFrequency );
+        
+
+// --- member data ---
+	
+	double mSampleRate;
+	double mMaxTimeOffset;
+
+	
+};	//	end of class SpectralPeakSelector
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_SPECTRALPEAKSELECTOR_H */
diff --git a/src/loris/SpectralPeaks.h b/src/loris/SpectralPeaks.h
new file mode 100644
index 0000000..e5103cf
--- /dev/null
+++ b/src/loris/SpectralPeaks.h
@@ -0,0 +1,111 @@
+#ifndef INCLUDE_SPECTRALPEAKS_H
+#define INCLUDE_SPECTRALPEAKS_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * SpectralPeaks.h
+ *
+ * Definition of a type representing a collection (vector) of 
+ * reassigned spectral peaks or ridges. Shared by analysis policies.
+ *
+ * Kelly Fitz, 29 May 2003
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+ 
+#include "Breakpoint.h"
+
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+//  define a spectral peak data structure
+//
+//  HEY
+//  Clean this mess up! Upgrade this struct into a class that can 
+//  store more kinds of information (like reassignment values), and 
+//  creates a Breakpoint when needed.
+
+class SpectralPeak
+{
+private:
+
+    double m_time;
+    Breakpoint m_breakpoint;
+
+public:
+
+    //  --- lifecycle ---
+    
+    SpectralPeak( double t, const Breakpoint & bp ) : m_time( t ), m_breakpoint( bp ) {}
+    
+    
+    //  --- access ---
+    
+    double time( void ) const { return m_time; }
+    
+    double amplitude( void ) const { return m_breakpoint.amplitude(); }
+    double frequency( void ) const { return m_breakpoint.frequency(); }
+    double bandwidth( void ) const { return m_breakpoint.bandwidth(); }
+    
+    //  --- mutation ---
+    
+    void setAmplitude( double x ) { m_breakpoint.setAmplitude(x); }
+    void setBandwidth( double x ) { m_breakpoint.setBandwidth(x); }
+    
+    //  this REALLY shouldn't be in here...
+    void addNoiseEnergy( double enoise ) { m_breakpoint.addNoiseEnergy(enoise); }
+    
+    //  --- Breakpoint creation ---
+    
+    Breakpoint createBreakpoint( void ) const { return m_breakpoint; }
+    
+    //  --- comparitors ---
+    
+    //	Comparitor for sorting spectral peaks in order of 
+    //	increasing frequency, or finding maximum frequency.
+
+    static bool sort_increasing_freq( const SpectralPeak & lhs, 
+                                      const SpectralPeak & rhs )
+    { 
+        return lhs.frequency()  < rhs.frequency(); 
+    }
+
+    //	predicate used for sorting peaks in order of decreasing amplitude:
+    static bool sort_greater_amplitude( const SpectralPeak & lhs, 
+                                        const SpectralPeak & rhs )
+    { 
+        return lhs.amplitude() > rhs.amplitude(); 
+    }
+};
+
+//	define the structure used to collect spectral peaks:
+typedef std::vector< SpectralPeak > Peaks;
+
+
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_SPECTRALPEAKS_H */
diff --git a/src/loris/SpectralSurface.C b/src/loris/SpectralSurface.C
new file mode 100644
index 0000000..69e7f5e
--- /dev/null
+++ b/src/loris/SpectralSurface.C
@@ -0,0 +1,376 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * SpectralSurface.C
+ *
+ * Implementation of class SpectralSurface, a class representing 
+ * a smoothed time-frequency surface that can be used to 
+ * perform cross-synthesis, the filtering of one sound by the
+ * time-varying spectrum of another.
+ *
+ * Kelly Fitz, 21 Dec 2005
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#include "SpectralSurface.h"
+
+#include "BreakpointUtils.h"
+#include "LorisExceptions.h"
+#include "Notifier.h"
+#include "Partial.h"
+
+#include <algorithm>
+#include <iterator>
+
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//    peakAmp - local helper for addPartialAux
+// ---------------------------------------------------------------------------
+static double peakAmp( const Partial & p ) 
+{	
+	if ( 0 == p.numBreakpoints() )
+	{
+		return 0;
+	}
+	return std::max_element( p.begin(), p.end(), 
+							 BreakpointUtils::compareAmplitudeLess()
+							 ).breakpoint().amplitude();
+}
+
+// ---------------------------------------------------------------------------
+//    findemfaster - local helper
+// ---------------------------------------------------------------------------
+static std::pair< const Partial *, const Partial * > 
+findemfaster( double freq, double time, const std::vector< Partial > & parray )
+{
+	static std::vector< Partial >::size_type cacheLastHit = 0;
+	
+	std::vector< Partial >::size_type i = cacheLastHit;
+	const Partial * p1 = 0;
+	const Partial * p2 = 0;
+	if ( parray[i].frequencyAt( time ) < freq )
+	{
+		// search up the list
+		while ( i < parray.size() && parray[i].frequencyAt( time ) < freq )
+		{
+			++i;
+		}
+		if ( i > 0 )
+		{
+			p1 = &parray[i-1];
+			cacheLastHit = i-1;
+		}
+		else
+		{
+			p1 = 0;
+			cacheLastHit = 0;
+		}
+		if ( i < parray.size() )
+		{
+			p2 = &parray[i];
+		}
+		else
+		{
+			p2 = 0;
+		}
+	}
+	else
+	{
+		// search down the list
+		while ( i > 0 && parray[i].frequencyAt( time ) > freq )
+		{
+			--i;
+		}
+		if ( i > 0 || parray[i].frequencyAt( time ) < freq )
+		{
+			p1 = &parray[i];
+			cacheLastHit = i;
+		}
+		else
+		{
+			p1 = 0;
+			cacheLastHit = 0;
+		}
+		if ( i + 1 < parray.size() )
+		{
+			p2 = &parray[i+1];
+		}
+		else
+		{
+			p2 = 0;
+		}
+	}
+	// debugger << "findemfaster caching " <<  cacheLastHit << endl;
+	return std::make_pair(p1, p2);
+}
+
+// ---------------------------------------------------------------------------
+//    smoothInTime - local helper
+// ---------------------------------------------------------------------------
+static double smoothInTime( const Partial & p, double t )
+{
+    const double spanT = 30; // ms
+    const int steps = 13;
+    const double incrT = (2 * spanT) / (steps - 1);
+    
+	double a = p.amplitudeAt( t );
+	if ( 0 == a )
+	{
+		for (double dehr = -spanT; dehr <= spanT; dehr += incrT )
+		{
+			a += p.amplitudeAt( t + ( .001*dehr ) );
+		}
+		a = a / steps;
+	}
+	return a;	
+}
+	
+// ---------------------------------------------------------------------------
+//    surfaceAt - local helper
+// ---------------------------------------------------------------------------
+static double surfaceAt( double f, double t, const std::vector< Partial > & parray )
+{
+	std::pair< const Partial *, const Partial * > both = findemfaster( f, t, parray );
+	const Partial * p1 = both.first;
+	const Partial * p2 = both.second;
+	
+	double moo1 = 0, moo2 = 0, interp = 0;
+	
+	if ( 0 != p1 && 0 != p2 )
+	{
+		interp = (f - p1->frequencyAt( t )) / ( p2->frequencyAt( t ) - p1->frequencyAt( t ) );
+		moo1 = smoothInTime( *p1, t );
+		moo2 = smoothInTime( *p2, t );
+	}
+	else if ( 0 != p2 )
+	{
+		interp = 1;
+		moo2 = smoothInTime( *p2, t );
+		moo1 = moo2;
+	}
+	else if ( 0 != p1 )
+	{
+		interp = 1. / (f - p1->frequencyAt( t ));
+		moo1 = smoothInTime( *p1, t );
+		moo2 = 0;
+	}
+	else
+	{
+		moo1 = moo2 = interp = 0;
+	}
+	return ((1-interp)*moo1 + interp*moo2);
+}
+
+// ---------------------------------------------------------------------------
+//    scaleAmplitudes
+// ---------------------------------------------------------------------------
+//! Scale the amplitude of every Breakpoint in a Partial
+//! according to the amplitude of the spectral surface
+//! at the corresponding time and frequency.
+//!
+//! \param  p the Partial to modify
+//
+void SpectralSurface::scaleAmplitudes( Partial & p )
+{
+	const double FreqScale = 1.0 / mStretchFreq;
+	const double TimeScale = 1.0 / mStretchTime;
+
+    Partial::iterator iter;
+    for ( iter = p.begin(); iter != p.end(); ++iter )
+    {
+        Breakpoint & bp = iter.breakpoint();	
+        double f = bp.frequency();
+        double t = iter.time();	
+            
+        double ampscale = surfaceAt( FreqScale * f, TimeScale * t, mPartials ) / mMaxSurfaceAmp;
+
+        double a = bp.amplitude() * ( (1.-mEffect) + (mEffect*ampscale) );
+        bp.setAmplitude( a );
+    }
+}
+
+// ---------------------------------------------------------------------------
+//    setAmplitudes
+// ---------------------------------------------------------------------------
+//! Set the amplitude of every Breakpoint in a Partial
+//! equal to the amplitude of the spectral surface
+//! at the corresponding time and frequency.
+//!
+//! \param  p the Partial to modify
+//
+void SpectralSurface::setAmplitudes( Partial & p )
+{
+	const double FreqScale = 1.0 / mStretchFreq;
+	const double TimeScale = 1.0 / mStretchTime;
+
+    Partial::iterator iter;
+    for ( iter = p.begin(); iter != p.end(); ++iter )
+    {
+        Breakpoint & bp = iter.breakpoint();	
+        if ( 0 != bp.amplitude() )
+        {
+            double f = bp.frequency();
+            double t = iter.time();	
+                
+            double surfaceAmp = surfaceAt( FreqScale * f, TimeScale * t, mPartials );
+            double a = ( bp.amplitude()*(1.-mEffect) ) + ( mEffect*surfaceAmp );
+            bp.setAmplitude( a );
+        }
+    }
+}
+
+// --- access/mutation ---
+
+// ---------------------------------------------------------------------------
+//    frequencyStretch
+// ---------------------------------------------------------------------------
+//! Return the amount of strecthing in the frequency dimension
+//! (default 1, no stretching). Values greater than 1 stretch
+//! the surface in the frequency dimension, values less than 1
+//! (but greater than 0) compress the surface in the frequency
+//! dimension.
+//
+double SpectralSurface::frequencyStretch( void ) const
+{
+	return mStretchFreq;
+}
+
+// ---------------------------------------------------------------------------
+//    timeStretch
+// ---------------------------------------------------------------------------
+//! Return the amount of strecthing in the time dimension
+//! (default 1, no stretching). Values greater than 1 stretch
+//! the surface in the time dimension, values less than 1
+//! (but greater than 0) compress the surface in the time
+//! dimension.
+//
+double SpectralSurface::timeStretch( void ) const
+{
+	return mStretchTime;
+}
+
+// ---------------------------------------------------------------------------
+//    effect
+// ---------------------------------------------------------------------------
+//! Return the amount of effect applied by scaleAmplitudes
+//! and setAmplitudes (default 1, full effect). Values
+//! less than 1 (but greater than 0) reduce the amount of
+//! amplitude modified performed by application of the
+//! surface. (This is rarely a good way of controlling the
+//! amount of the effect.)
+//
+double SpectralSurface::effect( void ) const
+{
+	return mEffect;
+}
+
+// ---------------------------------------------------------------------------
+//    setFrequencyStretch
+// ---------------------------------------------------------------------------
+//! Set the amount of strecthing in the frequency dimension
+//! (default 1, no stretching). Values greater than 1 stretch
+//! the surface in the frequency dimension, values less than 1
+//! (but greater than 0) compress the surface in the frequency
+//! dimension.
+//!
+//! \pre    stretch must be positive
+//! \param  stretch the new stretch factor for the frequency dimension
+//
+void SpectralSurface::setFrequencyStretch( double stretch )
+{
+	if ( 0 > stretch )
+	{
+		Throw( InvalidArgument,     
+               "SpectralSurface frequency stretch must be non-negative." );
+	}
+	mStretchFreq = stretch;
+}
+
+// ---------------------------------------------------------------------------
+//    setTimeStretch
+// ---------------------------------------------------------------------------
+//! Set the amount of strecthing in the time dimension
+//! (default 1, no stretching). Values greater than 1 stretch
+//! the surface in the time dimension, values less than 1
+//! (but greater than 0) compress the surface in the time
+//! dimension.
+//!
+//! \pre    stretch must be positive
+//! \param  stretch the new stretch factor for the time dimension
+//
+void SpectralSurface::setTimeStretch( double stretch )
+{
+	if ( 0 > stretch )
+	{
+		Throw( InvalidArgument,     
+               "SpectralSurface time stretch must be non-negative." );
+	}
+	mStretchTime = stretch;
+}
+
+// ---------------------------------------------------------------------------
+//    setEffect
+// ---------------------------------------------------------------------------
+//! Set the amount of effect applied by scaleAmplitudes
+//! and setAmplitudes (default 1, full effect). Values
+//! less than 1 (but greater than 0) reduce the amount of
+//! amplitude modified performed by application of the
+//! surface. (This is rarely a good way of controlling the
+//! amount of the effect.)
+//!
+//! \pre    effect must be between 0 and 1, inclusive
+//! \param  effect the new factor controlling the amount of 
+//!         amplitude modification performed by scaleAmplitudes
+//!         and setAmplitudes
+//
+void SpectralSurface::setEffect( double effect )
+{
+	if ( 0 > effect || 1 < effect )
+	{
+		Throw( InvalidArgument,     
+               "SpectralSurface effect must be non-negative and not greater than 1." );
+	}
+	mEffect = effect;
+}
+
+// --- private helpers ---
+
+// ---------------------------------------------------------------------------
+//    addPartialAux
+// ---------------------------------------------------------------------------
+// Helper function used by constructor for adding Partials one
+// by one. Still have to sort after adding all the Partials
+// using this helper! This just adds the Partial and keeps track
+// of the largest amplitude seen so far.
+//
+void SpectralSurface::addPartialAux( const Partial & p )
+{
+    mPartials.push_back( p );
+    mMaxSurfaceAmp = std::max( mMaxSurfaceAmp, peakAmp( p ) );
+}
+
+
+}	//end namespace
+
diff --git a/src/loris/SpectralSurface.h b/src/loris/SpectralSurface.h
new file mode 100644
index 0000000..3291f3d
--- /dev/null
+++ b/src/loris/SpectralSurface.h
@@ -0,0 +1,370 @@
+#ifndef INCLUDE_SPECTRALSURFACE_H
+#define INCLUDE_SPECTRALSURFACE_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * SpectralSurface.h
+ *
+ * Definition of class SpectralSurface, a class representing 
+ * a smoothed time-frequency surface that can be used to 
+ * perform cross-synthesis, the filtering of one sound by the
+ * time-varying spectrum of another.
+ *
+ * Kelly Fitz, 21 Dec 2005
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#include "LorisExceptions.h"
+#include "Partial.h"
+#include "PartialList.h"
+#include "PartialUtils.h"   // for compareLabelLess
+
+#include <algorithm>        // for sort
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	Class SpectralSurface
+//
+//! SpectralSurface represents a smoothed time-frequency surface that 
+//! can be used to perform cross-synthesis, the filtering of one sound 
+//! by the time-varying spectrum of another.
+//
+class SpectralSurface
+{
+//	-- public interface --
+public:
+	
+//	-- lifecycle --
+
+    //! Contsruct a new SpectralSurface from a sequence of distilled
+    //! Partials. 
+    //! 
+    //! \pre    the specified Partials must be channelized and distilled.
+    //! \param  b the beginning of the sequence of Partials
+    //! \param  e the end of the sequence of Partials
+    //!
+    //!	If compiled with NO_TEMPLATE_MEMBERS defined, then b and e
+    //!	must be PartialList::iterators, otherwise they can be any type
+    //!	of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+    SpectralSurface( Iter b, Iter e );
+#else
+    inline
+    SpectralSurface( PartialList::iterator b, PartialList::iterator e );
+#endif    
+
+    //  use compiler-generated copy/assign/destroy
+
+// --- operations ---
+	
+	//! Scale the amplitude of every Breakpoint in a Partial
+    //! according to the amplitude of the spectral surface
+    //! at the corresponding time and frequency.
+    //!
+    //! \param  p the Partial to modify
+	void scaleAmplitudes( Partial & p );
+
+	//! Scale the amplitudes of a sequence of Partials
+    //! according to the amplitude of the spectral surface
+    //! at the corresponding times and frequencies, 
+    //! performing cross-synthesis, the filtering of one
+    //! sound (the sequence of Partials) by the time-varying
+    //! spectrum of another sound (the Partials used to
+    //! construct the surface). The surface is stretched
+    //! in time and frequency according to the values of
+    //! the two stretch factors (default 1, no stretching)
+    //! and the amount of the effect is governed by the
+    //! `effect' parameter (default 1, full effect).
+    //!
+    //! \param  b the beginning of the sequence of Partials
+    //! \param  e the end of the sequence of Partials
+    //!
+    //!	If compiled with NO_TEMPLATE_MEMBERS defined, then b and e
+    //!	must be PartialList::iterators, otherwise they can be any type
+    //!	of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+    void scaleAmplitudes( Iter b, Iter e );
+#else
+    inline
+	void scaleAmplitudes( PartialList::iterator b, PartialList::iterator e );
+#endif
+    
+	//! Set the amplitude of every Breakpoint in a Partial
+    //! equal to the amplitude of the spectral surface
+    //! at the corresponding time and frequency.
+    //!
+    //! \param  p the Partial to modify
+	void setAmplitudes( Partial & p );
+    
+	//! Set the amplitudes of a sequence of Partials
+    //! equal to the amplitude of the spectral surface
+    //! at the corresponding times and frequencies. 
+    //! This can be used to perform formant-corrected
+    //! pitch shifting of a sound: construct the surface
+    //! from the unmodified Partials, perform the pitch
+    //! shift on the Partials, then apply the surface 
+    //! to the shifted Partials using setAmplitudes.
+    //! The surface is stretched
+    //! in time and frequency according to the values of
+    //! the two stretch factors (default 1, no stretching)
+    //! and the amount of the effect is governed by the
+    //! `effect' parameter (default 1, full effect).
+    //!
+    //! \param  b the beginning of the sequence of Partials
+    //! \param  e the end of the sequence of Partials
+    //!
+    //!	If compiled with NO_TEMPLATE_MEMBERS defined, then b and e
+    //!	must be PartialList::iterators, otherwise they can be any type
+    //!	of iterators over a sequence of Partials.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template<typename Iter>
+    void setAmplitudes( Iter b, Iter e );
+#else
+    inline
+	void setAmplitudes( PartialList::iterator b, PartialList::iterator e );
+#endif
+	
+// --- access/mutation ---
+
+    //! Return the amount of strecthing in the frequency dimension
+    //! (default 1, no stretching). Values greater than 1 stretch
+    //! the surface in the frequency dimension, values less than 1
+    //! (but greater than 0) compress the surface in the frequency
+    //! dimension.
+	double frequencyStretch( void ) const;
+    
+    //! Return the amount of strecthing in the time dimension
+    //! (default 1, no stretching). Values greater than 1 stretch
+    //! the surface in the time dimension, values less than 1
+    //! (but greater than 0) compress the surface in the time
+    //! dimension.
+	double timeStretch( void ) const;
+    
+    //! Return the amount of effect applied by scaleAmplitudes
+    //! and setAmplitudes (default 1, full effect). Values
+    //! less than 1 (but greater than 0) reduce the amount of
+    //! amplitude modified performed by application of the
+    //! surface. (This is rarely a good way of controlling the
+    //! amount of the effect.)
+	double effect( void ) const;
+	
+    //! Set the amount of strecthing in the frequency dimension
+    //! (default 1, no stretching). Values greater than 1 stretch
+    //! the surface in the frequency dimension, values less than 1
+    //! (but greater than 0) compress the surface in the frequency
+    //! dimension.
+    //!
+    //! \pre    stretch must be positive
+    //! \param  stretch the new stretch factor for the frequency dimension
+	void setFrequencyStretch( double stretch );
+
+    //! Set the amount of strecthing in the time dimension
+    //! (default 1, no stretching). Values greater than 1 stretch
+    //! the surface in the time dimension, values less than 1
+    //! (but greater than 0) compress the surface in the time
+    //! dimension.
+    //!
+    //! \pre    stretch must be positive
+    //! \param  stretch the new stretch factor for the time dimension
+	void setTimeStretch( double stretch );
+    
+    //! Set the amount of effect applied by scaleAmplitudes
+    //! and setAmplitudes (default 1, full effect). Values
+    //! less than 1 (but greater than 0) reduce the amount of
+    //! amplitude modified performed by application of the
+    //! surface. (This is rarely a good way of controlling the
+    //! amount of the effect.)
+    //!
+    //! \pre    effect must be between 0 and 1, inclusive
+    //! \param  effect the new factor controlling the amount of 
+    //!         amplitude modification performed by scaleAmplitudes
+    //!         and setAmplitudes
+	void setEffect( double effect );
+	
+private:
+
+//	-- instance variables --
+
+	std::vector< Partial > mPartials;   //! the Partials comprising the surface are
+                                        //! stored in a vector for easy random access
+	double mStretchFreq;                //! stretch factor for the frequency dimension
+    double mStretchTime;                //! stretch factor for the time dimension
+    double mEffect;                     //! factor for controlling the amount of
+                                        //! of the effect applied in setAmplitudes and
+                                        //! scaleAmplitudes: 0 gives unmodified amplitudes
+                                        //! 1 gives fully modified amplitudes.
+    double mMaxSurfaceAmp;              //! the maximum amplitude of any Breakpoint on 
+                                        //! the surface, used for normalizing the surface
+                                        //! amplitude for scaleAmplitudes
+    
+// --- private helpers ---
+
+    //  helper used by constructor for adding Partials one by one
+    void addPartialAux( const Partial & p );
+    
+};
+
+// ---------------------------------------------------------------------------
+//    constructor
+// ---------------------------------------------------------------------------
+//! Contsruct a new SpectralSurface from a sequence of distilled
+//! Partials. 
+//! 
+//! \pre    the specified Partials must be channelized and distilled.
+//! \param  b the beginning of the sequence of Partials
+//! \param  e the end of the sequence of Partials
+//!
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, then b and e
+//!	must be PartialList::iterators, otherwise they can be any type
+//!	of iterators over a sequence of Partials.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+SpectralSurface::SpectralSurface( Iter b, Iter e ) :
+#else
+inline
+SpectralSurface::SpectralSurface( PartialList::iterator b, 
+                                  PartialList::iterator e ) :
+#endif    
+	mStretchFreq( 1.0 ),
+	mStretchTime( 1.0 ),
+	mEffect( 1.0 ),
+    mMaxSurfaceAmp( 0.0 )
+{
+    //  add only labeled Partials:
+    while ( b != e )
+    {
+        if ( b->label() != 0 )
+        {
+            addPartialAux( *b );
+        }
+        ++b;
+    }
+	
+	// complain if the Partials were not distilled
+	if ( mPartials.empty() )
+	{
+		Throw( InvalidArgument, "Partals need to be distilled to build a SpectralSurface" );
+	}
+
+	if ( 0 == mMaxSurfaceAmp )
+	{
+		Throw( InvalidArgument, "The SpectralSurface is zero amplitude everywhere!" );
+	}
+	
+	// sort by label
+	std::sort( mPartials.begin(), mPartials.end(), PartialUtils::compareLabelLess() );
+}
+
+
+// ---------------------------------------------------------------------------
+//    scaleAmplitudes
+// ---------------------------------------------------------------------------
+//! Scale the amplitudes of a sequence of Partials
+//! according to the amplitude of the spectral surface
+//! at the corresponding times and frequencies, 
+//! performing cross-synthesis, the filtering of one
+//! sound (the sequence of Partials) by the time-varying
+//! spectrum of another sound (the Partials used to
+//! construct the surface). The surface is stretched
+//! in time and frequency according to the values of
+//! the two stretch factors (default 1, no stretching)
+//! and the amount of the effect is governed by the
+//! `effect' parameter (default 1, full effect).
+//!
+//! \param  b the beginning of the sequence of Partials
+//! \param  e the end of the sequence of Partials
+//!
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, then b and e
+//!	must be PartialList::iterators, otherwise they can be any type
+//!	of iterators over a sequence of Partials.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void SpectralSurface::scaleAmplitudes( Iter b, Iter e )
+#else
+inline
+void SpectralSurface::scaleAmplitudes( PartialList::iterator b, 
+                                       PartialList::iterator e )
+#endif
+{	
+	while ( b != e )
+	{
+		// debugger << b->label() << endl;
+        scaleAmplitudes( *b );
+        ++b;
+	}	
+}
+
+// ---------------------------------------------------------------------------
+//    setAmplitudes
+// ---------------------------------------------------------------------------
+//! Set the amplitudes of a sequence of Partials
+//! equal to the amplitude of the spectral surface
+//! at the corresponding times and frequencies. 
+//! This can be used to perform formant-corrected
+//! pitch shifting of a sound: construct the surface
+//! from the unmodified Partials, perform the pitch
+//! shift on the Partials, then apply the surface 
+//! to the shifted Partials using setAmplitudes.
+//! The surface is stretched
+//! in time and frequency according to the values of
+//! the two stretch factors (default 1, no stretching)
+//! and the amount of the effect is governed by the
+//! `effect' parameter (default 1, full effect).
+//!
+//! \param  b the beginning of the sequence of Partials
+//! \param  e the end of the sequence of Partials
+//!
+//!	If compiled with NO_TEMPLATE_MEMBERS defined, then b and e
+//!	must be PartialList::iterators, otherwise they can be any type
+//!	of iterators over a sequence of Partials.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void SpectralSurface::setAmplitudes( Iter b, Iter e )
+#else
+inline
+void SpectralSurface::setAmplitudes( PartialList::iterator b, 
+                                     PartialList::iterator e )
+#endif
+{	
+	while ( b != e )
+	{
+		// debugger << b->label() << endl;
+        setAmplitudes( *b );
+        ++b;
+	}	
+}
+
+}	// namespace Loris
+
+#endif /* ndef INCLUDE_SPECTRALSURFACE_H */
+
diff --git a/src/loris/Synthesizer.C b/src/loris/Synthesizer.C
new file mode 100644
index 0000000..db102e4
--- /dev/null
+++ b/src/loris/Synthesizer.C
@@ -0,0 +1,518 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Synthesizer.C
+ *
+ * Implementation of class Loris::SynthesizerSynthesizer, a synthesizer of 
+ * bandwidth-enhanced Partials.
+ *
+ * Kelly Fitz, 16 Aug 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+    #include "config.h"
+#endif
+
+#include "Synthesizer.h"
+#include "Oscillator.h"
+#include "Breakpoint.h"
+#include "BreakpointUtils.h"
+#include "Envelope.h"
+#include "LorisExceptions.h"
+#include "Notifier.h"
+#include "Partial.h"
+#include "Resampler.h"
+#include "phasefix.h"
+
+#include <algorithm>
+#include <cmath>
+
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+    const double Pi = M_PI;
+#else
+    const double Pi = 3.14159265358979324;
+#endif
+
+//  begin namespace
+namespace Loris {
+
+
+// ---------------------------------------------------------------------------
+//  Synthesizer constructor
+// ---------------------------------------------------------------------------
+//!	Construct a Synthesizer using the default parameters and sample
+//!	buffer (a standard library vector). Since Partials generated by the 
+//! Loris Analyzer generally begin and end at non-zero amplitude, zero-amplitude
+//!	Breakpoints are inserted at either end of the Partial, at a temporal
+//!	distance equal to the fade time, to reduce turn-on and turn-off
+//!	artifacts.
+//!
+//! \sa Synthesizer::Parameters
+//!
+//!	\param	buffer The vector (of doubles) into which rendered samples
+//!			   should be accumulated.
+//!	\throw	InvalidArgument if any of the parameters is invalid.
+Synthesizer::Synthesizer( std::vector<double> & buffer ) :
+    m_sampleBuffer( & buffer ),
+    m_fadeTimeSec( DefaultParameters().fadeTime ),
+    m_srateHz( DefaultParameters().sampleRate )
+{
+}
+
+
+// ---------------------------------------------------------------------------
+//  Synthesizer constructor
+// ---------------------------------------------------------------------------
+//!	Construct a Synthesizer using the specified parameters and sample
+//!	buffer (a standard library vector). Since Partials generated by the 
+//! Loris Analyzer generally begin and end at non-zero amplitude, zero-amplitude
+//!	Breakpoints are inserted at either end of the Partial, at a temporal
+//!	distance equal to the fade time, to reduce turn-on and turn-off
+//!	artifacts. If the fade time is unspecified, the default value of one
+//!	millisecond (0.001 seconds) is used.
+//!
+//!	\param	params A Parameters struct storing the configuration of 
+//!             Synthesizer parameters.
+//!	\param	buffer The vector (of doubles) into which rendered samples
+//!			   should be accumulated.
+//!	\throw	InvalidArgument if any of the parameters is invalid.
+//
+Synthesizer::Synthesizer( Parameters params, std::vector<double> & buffer ) :
+    m_sampleBuffer( & buffer )
+{
+    //  make sure that the parameters are valid before proceeding
+    if ( IsValidParameters( params ) )
+    {
+        m_fadeTimeSec = params.fadeTime;
+        m_srateHz = params.sampleRate;
+        m_osc.filter() = params.filter;
+    }
+}
+
+// ---------------------------------------------------------------------------
+//  Synthesizer constructor
+// ---------------------------------------------------------------------------
+//!	Construct a Synthesizer using the specified sampling rate, sample
+//!	buffer (a standard library vector), and the default fade time 
+//!	stored in the DefaultParameters. Since Partials generated by the Loris 
+//!	Analyzer generally begin and end at non-zero amplitude, zero-amplitude
+//!	Breakpoints are inserted at either end of the Partial, at a temporal
+//!	distance equal to the fade time, to reduce turn-on and turn-off
+//!	artifacts.
+//!
+//!	\param	srate The rate (Hz) at which to synthesize samples
+//!			   (must be positive).
+//!	\param	buffer The vector (of doubles) into which rendered samples
+//!			   should be accumulated.
+//!	\throw	InvalidArgument if the specfied sample rate is non-positive.
+Synthesizer::Synthesizer( double samplerate, std::vector<double> & buffer ) :
+    m_sampleBuffer( & buffer ),
+    m_fadeTimeSec( DefaultParameters().fadeTime ),
+    m_srateHz( samplerate )
+{
+    //  check to make sure that the sample rate is valid:
+    if ( m_srateHz <= 0. ) 
+    {
+        Throw( InvalidArgument, "Synthesizer sample rate must be positive." );
+    }
+
+    //  assign the default bw enhancement filter to the Oscillator
+    m_osc.filter() = DefaultParameters().filter;
+    
+}
+
+// ---------------------------------------------------------------------------
+//  Synthesizer constructor
+// ---------------------------------------------------------------------------
+//! Construct a Synthesizer using the specified sampling rate, sample
+//! buffer (a standard library vector), and Partial
+//! fade time (in seconds). Since Partials generated by the Loris Analyzer
+//! generally begin and end at non-zero amplitude, zero-amplitude
+//! Breakpoints are inserted at either end of the Partial, at a temporal
+//! distance equal to the fade time, to reduce turn-on and turn-off
+//! artifacts. If the fade time is unspecified, the default value of one
+//! millisecond (0.001 seconds) is used.
+//!
+//! \param  samplerate The rate (Hz) at which to synthesize samples
+//!         (must be positive).
+//! \param  buffer The vector (of doubles) into which rendered samples
+//!         should be accumulated.
+//! \param  fade The Partial fade time in seconds (must be non-negative).
+//! \throw  InvalidArgument if the specfied sample rate is non-positive.
+//! \throw  InvalidArgument if the specified fade time is negative.
+Synthesizer::Synthesizer( double samplerate, std::vector<double> & buffer, 
+                          double fade ) :
+    m_sampleBuffer( & buffer ),
+    m_fadeTimeSec( fade ),
+    m_srateHz( samplerate )
+{
+    //  check to make sure that the sample rate is valid:
+    if ( m_srateHz <= 0. ) 
+    {
+        Throw( InvalidArgument, "Synthesizer sample rate must be positive." );
+    }
+
+    //  check to make sure that the specified fade time
+    //  is valid:
+    if ( m_fadeTimeSec < 0. )
+    {
+        Throw( InvalidArgument, 
+               "Synthesizer Partial fade time must be non-negative." );
+    }
+    
+    //  assign the default bw enhancement filter to the Oscillator
+    m_osc.filter() = DefaultParameters().filter;
+    
+}
+
+//	-- synthesis --
+
+// ---------------------------------------------------------------------------
+//  synthesize
+// ---------------------------------------------------------------------------
+//! Synthesize a bandwidth-enhanced sinusoidal Partial. Zero-amplitude
+//! Breakpoints are inserted at either end of the Partial to reduce
+//! turn-on and turn-off artifacts, as described above. The synthesizer
+//! will resize the buffer as necessary to accommodate all the samples,
+//! including the fade out. Previous contents of the buffer are not
+//! overwritten. Partials with start times earlier than the Partial fade
+//! time will have shorter onset fades. Partials are not rendered at
+//! frequencies above the half-sample rate. 
+//!
+//! \param  p The Partial to synthesize.
+//! \return Nothing.
+//! \pre    The partial must have non-negative start time.
+//! \post   This Synthesizer's sample buffer (vector) has been 
+//!         resized to accommodate the entire duration of the 
+//!         Partial, p, including fade out at the end.
+//! \throw  InvalidPartial if the Partial has negative start time.
+//  
+void
+Synthesizer::synthesize( Partial p ) 
+{
+    if ( p.numBreakpoints() == 0 )
+    {
+        debugger << "Synthesizer ignoring a partial that contains no Breakpoints" << endl;
+        return;
+    }
+    
+    if ( p.startTime() < 0 )
+    {
+        Throw( InvalidPartial, "Tried to synthesize a Partial having start time less than 0." );
+    }
+
+    debugger << "synthesizing Partial from " << p.startTime() * m_srateHz 
+             << " to " << p.endTime() * m_srateHz << " starting phase "
+             << p.initialPhase() << " starting frequency " 
+             << p.first().frequency() << endl;
+             
+    //  better to compute this only once:
+    const double OneOverSrate = 1. / m_srateHz;
+    
+             
+    //  use a Resampler to quantize the Breakpoint times and 
+    //  correct the phases:
+    Resampler quantizer( OneOverSrate );
+    quantizer.setPhaseCorrect( true );
+    quantizer.quantize( p );
+    
+
+    //  resize the sample buffer if necessary:
+    typedef unsigned long index_type;
+    index_type endSamp = index_type( ( p.endTime() + m_fadeTimeSec ) * m_srateHz );
+    if ( endSamp+1 > m_sampleBuffer->size() )
+    {
+        //  pad by one sample:
+        m_sampleBuffer->resize( endSamp+1 );
+    }
+    
+    //  compute the starting time for synthesis of this Partial,
+    //  m_fadeTimeSec before the Partial's startTime, but not before 0:
+    double itime = ( m_fadeTimeSec < p.startTime() ) ? ( p.startTime() - m_fadeTimeSec ) : 0.;
+    index_type currentSamp = index_type( (itime * m_srateHz) + 0.5 );   //  cheap rounding
+    
+    //  reset the oscillator:
+    //  all that really needs to happen here is setting the frequency
+    //  correctly, the phase will be reset again in the loop over 
+    //  Breakpoints below, and the amp and bw can start at 0.
+    m_osc.resetEnvelopes( BreakpointUtils::makeNullBefore( p.first(), p.startTime() - itime ), m_srateHz );
+
+    //  cache the previous frequency (in Hz) so that it
+    //  can be used to reset the phase when necessary
+    //  in the sample computation loop below (this saves
+    //  having to recompute from the oscillator's radian
+    //  frequency):
+    double prevFrequency = p.first().frequency();   
+    
+    //  synthesize linear-frequency segments until 
+    //  there aren't any more Breakpoints to make segments:
+    double * bufferBegin = &( m_sampleBuffer->front() );
+    for ( Partial::const_iterator it = p.begin(); it != p.end(); ++it )
+    {
+        index_type tgtSamp = index_type( (it.time() * m_srateHz) + 0.5 );   //  cheap rounding
+        Assert( tgtSamp >= currentSamp );
+        
+        //  if the current oscillator amplitude is
+        //  zero, and the target Breakpoint amplitude
+        //  is not, reset the oscillator phase so that
+        //  it matches exactly the target Breakpoint 
+        //  phase at tgtSamp:
+        if ( m_osc.amplitude() == 0. )
+        {
+            //  recompute the phase so that it is correct
+            //  at the target Breakpoint (need to do this
+            //  because the null Breakpoint phase was computed
+            //  from an interval in seconds, not samples, so
+            //  it might be inaccurate):
+            //
+            //  double favg = 0.5 * ( prevFrequency + it.breakpoint().frequency() );
+            //  double dphase = 2 * Pi * favg * ( tgtSamp - currentSamp ) / m_srateHz;
+            //
+            double dphase = Pi * ( prevFrequency + it.breakpoint().frequency() ) 
+                               * ( tgtSamp - currentSamp ) * OneOverSrate;
+            m_osc.setPhase( it.breakpoint().phase() - dphase );
+        }
+
+        m_osc.oscillate( bufferBegin + currentSamp, bufferBegin + tgtSamp,
+                         it.breakpoint(), m_srateHz );
+        
+        currentSamp = tgtSamp;
+        
+        //  remember the frequency, may need it to reset the 
+        //  phase if a Null Breakpoint is encountered:
+        prevFrequency = it.breakpoint().frequency();
+    }
+
+    //  render a fade out segment:  
+    m_osc.oscillate( bufferBegin + currentSamp, bufferBegin + endSamp,
+                     BreakpointUtils::makeNullAfter( p.last(), m_fadeTimeSec ), m_srateHz );
+    
+}
+    
+// -- sample access --
+
+// ---------------------------------------------------------------------------
+//  samples (const)
+// ---------------------------------------------------------------------------
+//! Return a const reference to the sample buffer used (not
+//! owned) by this Synthesizer.
+const std::vector<double> &
+Synthesizer::samples( void ) const 
+{
+    return *m_sampleBuffer;
+}
+
+// ---------------------------------------------------------------------------
+//  samples (non-const)
+// ---------------------------------------------------------------------------
+//! Return a reference to the sample buffer used (not
+//! owned) by this Synthesizer.
+std::vector<double> &
+Synthesizer::samples( void )  
+{
+    return *m_sampleBuffer;
+}
+
+// -- parameter access and mutation --
+
+// ---------------------------------------------------------------------------
+//  fadeTime
+// ---------------------------------------------------------------------------
+//! Return this Synthesizer's Partial fade time, in seconds.
+double 
+Synthesizer::fadeTime( void ) const 
+{
+    return m_fadeTimeSec;
+}
+
+// ---------------------------------------------------------------------------
+//  sampleRate
+// ---------------------------------------------------------------------------
+//! Return the sampling rate (in Hz) for this Synthesizer.
+double 
+Synthesizer::sampleRate( void ) const 
+{
+    return m_srateHz;
+}
+
+
+// ---------------------------------------------------------------------------
+//  setFadeTime
+// ---------------------------------------------------------------------------
+//! Set this Synthesizer's fade time to the specified value 
+//! (in seconds, must be non-negative).
+//!
+//! \param  t The new Partial fade time.
+//! \throw  InvalidArgument if the specified fade time is negative.
+void 
+Synthesizer::setFadeTime( double partialFadeTime )  
+{
+    //  check to make sure that the specified fade time
+    //  is valid:
+    if ( partialFadeTime < 0. )
+    {
+        Throw( InvalidArgument, "Synthesizer Partial fade time must be non-negative." );
+    }
+
+    m_fadeTimeSec = partialFadeTime;
+}
+
+// ---------------------------------------------------------------------------
+//  setSampleRate
+// ---------------------------------------------------------------------------
+//!	Set this Synthesizer's sample rate to the specified value 
+//!	(in Hz, must be positive).
+//!
+//!	\param	rate The new synthesis sample rate.
+//!	\throw	InvalidArgument if the specified rate is nonpositive.
+void 
+Synthesizer::setSampleRate( double rate )  
+{
+    //  check to make sure that the specified rate
+    //  is valid:
+    if ( rate <= 0. )
+    {
+        Throw( InvalidArgument, "Synthesizer sample rate must be positive." );
+    }
+
+    m_srateHz = rate;
+}
+
+// ---------------------------------------------------------------------------
+//  filter
+// ---------------------------------------------------------------------------
+//! Return access to the Filter used by this Synthesizer's 
+//! Oscillator to implement bandwidth-enhanced sinusoidal 
+//! synthesis. (Can use this access to make changes to the
+//! filter coefficients.)
+Filter & 
+Synthesizer::filter( void ) 
+{
+    return m_osc.filter(); 
+}
+
+//  -- parameters structure --
+
+// ---------------------------------------------------------------------------
+//  Synthesizer::Parameters default constructor
+// ---------------------------------------------------------------------------
+//! Assign default initial values to the Synthesizer parameters, Filter
+//! defaults are defined in Oscillator.C.
+    
+static const double Default_FadeTime_Ms = 1;
+static const double Default_SampleRate_Hz = 44100;
+//static const Synthesizer::EnhancementFlag Default_Enhancement_Flag = Synthesizer::BwEnhanced;
+
+
+Synthesizer::Parameters::Parameters( void ) :
+    fadeTime( Default_FadeTime_Ms * 0.001 ),
+    sampleRate( Default_SampleRate_Hz ),
+    // enhancement( Default_Enhancement_Flag ),
+    filter( Oscillator::prototype_filter() )
+{
+}
+
+// ---------------------------------------------------------------------------
+//  Synthesizer default Parameters local access only
+// ---------------------------------------------------------------------------
+
+static
+Synthesizer::Parameters & TheSynthesizerDefaultParameters( void ) 
+{
+    static Synthesizer::Parameters params;
+    return params;
+
+}
+
+// ---------------------------------------------------------------------------
+//  Synthesizer default Parameters access (static)
+// ---------------------------------------------------------------------------
+//! Default configuration of a Loris::Synthesizer. Modify the values 
+//! in this structure to alter the configuration of all Synthesizers, 
+//! including those used by the AiffFile class to render Partials.
+const Synthesizer::Parameters & 
+Synthesizer::DefaultParameters( void )
+{
+    return TheSynthesizerDefaultParameters();
+}    
+
+// ---------------------------------------------------------------------------
+//  Synthesizer default Parameters access (static)
+// ---------------------------------------------------------------------------
+//! Assign a new default configuration of a Loris::Synthesizer
+//! to alter the configuration of all Synthesizers, 
+//! including those used by the AiffFile class to render Partials.
+//!
+//! \param params A Parameters struct describing the new default 
+//!               configuration for Synthesizers.
+//!	\throw	InvalidArgument if any of the parameters is invalid.
+void Synthesizer::SetDefaultParameters( const Synthesizer::Parameters & params )
+{
+    if ( IsValidParameters( params ) )
+    {
+        TheSynthesizerDefaultParameters() = params;
+    }
+}
+
+// ---------------------------------------------------------------------------
+//  IsValidParameters (static)
+// ---------------------------------------------------------------------------
+//! Check the validty of a Parameters structure. Returns true if the
+//! struct represents a valid Synthesizer configuration, and false otherwise.
+//!
+//! \param params A Parameters struct describing a configuration for 
+//!               Synthesizers.
+bool Synthesizer::IsValidParameters( const Parameters & params )
+{    
+    //  check to make sure that the sample rate is valid:
+    if ( 0. >= params.sampleRate ) 
+    {
+        Throw( InvalidArgument, "Synthesizer sample rate must be positive." );
+    }
+
+    //  check to make sure that the specified fade time
+    //  is valid:
+    if ( 0. > params.fadeTime )
+    {
+        Throw( InvalidArgument, 
+               "Synthesizer Partial fade time must be non-negative." );
+    }
+    
+    //  check that the filter coefficients are valid -- pretty much 
+    //  any coefficients are valid as long as the zeroeth feedback 
+    //  coefficient is non-zero:
+    if ( 0. == params.filter.denominator()[0] )
+    {
+        Throw( InvalidArgument, 
+               "Synthesizer filter zeroeth feedback coefficient must be non-zero." );
+    }
+    
+    //  if no exception has been raised, return true indicating valid params
+    return true;
+
+}
+
+}   //  end of namespace Loris
diff --git a/src/loris/Synthesizer.h b/src/loris/Synthesizer.h
new file mode 100644
index 0000000..e0268ba
--- /dev/null
+++ b/src/loris/Synthesizer.h
@@ -0,0 +1,391 @@
+#ifndef INCLUDE_SYNTHESIZER_H
+#define INCLUDE_SYNTHESIZER_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Synthesizer.h
+ *
+ * Definition of class Loris::Synthesizer, a renderer of 
+ * bandwidth-enhanced Partials.
+ *
+ * Kelly Fitz, 16 Aug 1999
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+ 
+ 
+ //	TODO:
+ //	Passing the sample vector in to Synthesizer no longer makes any sense,
+ //	if the Synthesizer can (must) resize the buffer anyway, it may as well 
+ // own it. In a future version, the Synthesizer owns a vector (need to add
+ //	a method to clear it), and provides access to it (as it currently does). 
+ // When this change is made, it probably makes sense to remove the function
+ // call operators.
+ 
+
+#include "Oscillator.h"
+#include "PartialList.h"
+#include "PartialUtils.h"
+
+#include <vector>
+
+//	begin namespace
+namespace Loris {
+
+// ---------------------------------------------------------------------------
+//	class Synthesizer
+//
+//! A Synthesizer renders bandwidth-enhanced Partials into a buffer
+//! of samples. 
+//!	
+//!	Class Synthesizer represents an algorithm for rendering
+//!	bandwidth-enhanced Partials as floating point (double) samples at a
+//!	specified sampling rate, and accumulating them into a buffer. 
+//!
+//!	The Synthesizer does not own the sample buffer, the client is responsible
+//!	for its construction and destruction, and many Synthesizers may share
+//!	a buffer.
+//
+class Synthesizer
+{
+//	-- public interface --
+public:
+//	-- construction --
+
+    struct Parameters;  //  defined below
+
+	//!	Construct a Synthesizer using the default parameters and sample
+	//!	buffer (a standard library vector). Since Partials generated by 
+	//! the Loris Analyzer generally begin and end at non-zero amplitude,
+	//! zero-amplitude Breakpoints are inserted at either end of the Partial, 
+	//!	at a temporal distance equal to the fade time, to reduce turn-on and 
+	//!	turn-off artifacts.
+	//!
+	//! \sa Synthesizer::Parameters
+	//!
+	//!	\param	buffer The vector (of doubles) into which rendered samples
+	//!			   should be accumulated.
+	//!	\throw	InvalidArgument if any of the parameters is invalid.
+	Synthesizer( std::vector<double> & buffer );	
+
+
+	//!	Construct a Synthesizer using the specified parameters and sample
+	//!	buffer (a standard library vector). Since Partials generated by the 
+	//! Loris Analyzer generally begin and end at non-zero amplitude, zero-amplitude
+	//!	Breakpoints are inserted at either end of the Partial, at a temporal
+	//!	distance equal to the fade time, to reduce turn-on and turn-off
+	//!	artifacts.
+	//!
+	//!	\param	params A Parameters struct storing the configuration of 
+	//!             Synthesizer parameters.
+	//!	\param	buffer The vector (of doubles) into which rendered samples
+	//!			   should be accumulated.
+	//!	\throw	InvalidArgument if any of the parameters is invalid.
+	Synthesizer( Parameters params, std::vector<double> & buffer );	
+	
+	//!	Construct a Synthesizer using the specified sampling rate, sample
+	//!	buffer (a standard library vector), and the default fade time 
+	//!	stored in the DefaultParameters. Since Partials generated by the Loris 
+	//!	Analyzer generally begin and end at non-zero amplitude, zero-amplitude
+	//!	Breakpoints are inserted at either end of the Partial, at a temporal
+	//!	distance equal to the fade time, to reduce turn-on and turn-off
+	//!	artifacts.
+	//!
+	//!	\param	srate The rate (Hz) at which to synthesize samples
+	//!			   (must be positive).
+	//!	\param	buffer The vector (of doubles) into which rendered samples
+	//!			   should be accumulated.
+	//!	\throw	InvalidArgument if the specfied sample rate is non-positive.
+	Synthesizer( double srate, std::vector<double> & buffer );
+	             
+    //!	Construct a Synthesizer using the specified sampling rate, sample
+	//!	buffer (a standard library vector), and Partial fade time 
+	//!	(in seconds). Since Partials generated by the Loris Analyzer
+	//!	generally begin and end at non-zero amplitude, zero-amplitude
+	//!	Breakpoints are inserted at either end of the Partial, at a temporal
+	//!	distance equal to the fade time, to reduce turn-on and turn-off
+	//!	artifacts.
+	//!
+	//!	\param	srate The rate (Hz) at which to synthesize samples
+	//!			   (must be positive).
+	//!	\param	buffer The vector (of doubles) into which rendered samples
+	//!			   should be accumulated.
+	//!	\param	fadeTime The Partial fade time in seconds (must be non-negative).
+	//!	\throw	InvalidArgument if the specfied sample rate is non-positive.
+	//!	\throw	InvalidArgument if the specified fade time is negative.
+	Synthesizer( double srate, std::vector<double> & buffer, double fadeTime );
+	
+	// 	Compiler can generate copy, assign, and destroy.
+	//	Synthesizer( const Synthesizer & other );
+	//	~Synthesizer( void );
+	//	Synthesizer & operator= ( const Synthesizer & other );
+	 
+//	-- synthesis --
+
+	//!	Synthesize a bandwidth-enhanced sinusoidal Partial. Zero-amplitude
+	//!	Breakpoints are inserted at either end of the Partial to reduce
+	//!	turn-on and turn-off artifacts, as described above. The synthesizer
+	//!	will resize the buffer as necessary to accommodate all the samples,
+	//!	including the fade out. Previous contents of the buffer are not
+	//!	overwritten. Partials with start times earlier than the Partial fade
+	//!	time will have shorter onset fades. Partials are not rendered at
+	//!   frequencies above the half-sample rate. 
+	//!
+	//! \param  p The Partial to synthesize.
+	//! \return Nothing.
+	//!	\pre    The partial must have non-negative start time.
+	//! \post   This Synthesizer's sample buffer (vector) has been 
+	//!         resized to accommodate the entire duration of the 
+	//!         Partial, p, including fade out at the end.
+	//!	\throw	InvalidPartial if the Partial has negative start time.
+	void synthesize( Partial p );	
+	 
+	//!	Function call operator: same as synthesize( p ).
+	void operator() ( const Partial & p ) { synthesize( p ) ; }
+
+	 
+	//!	Synthesize all Partials on the specified half-open (STL-style) range.
+	//!	Null Breakpoints are inserted at either end of the Partial to reduce
+	//!	turn-on and turn-off artifacts, as described above. The synthesizer
+	//!	will resize the buffer as necessary to accommodate all the samples,
+	//!	including the fade outs. Previous contents of the buffer are not
+	//!	overwritten. Partials with start times earlier than the Partial fade
+	//!	time will have shorter onset fades.  Partials are not rendered at
+	//! frequencies above the half-sample rate. 
+	//!
+	//! \param  begin_partials The beginning of the range of Partials 
+	//!         to synthesize.
+	//! \param 	end_partials The end of the range of Partials 
+	//!         to synthesize.
+	//! \return Nothing.
+	//!	\pre    The partials must have non-negative start times.
+	//! \post   This Synthesizer's sample buffer (vector) has been 
+	//!         resized to accommodate the entire duration of all the 
+	//!         Partials including fade out at the ends.
+	//!	\throw	InvalidPartial if any Partial has negative start time.
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template< typename Iter >
+	void synthesize( Iter begin_partials, Iter end_partials );
+#else
+    inline
+	void synthesize( PartialList::iterator begin_partials, 
+					 PartialList::iterator end_partials );	
+#endif
+	 
+	//!	Function call operator: same as 
+	//!	synthesize( begin_partials, end_partials ).
+#if ! defined(NO_TEMPLATE_MEMBERS)
+	template< typename Iter >
+	void operator() ( Iter begin_partials, Iter end_partials );
+#else
+    inline
+	void operator() ( PartialList::iterator begin_partials, 
+					  PartialList::iterator end_partials );
+#endif
+	
+//	-- sample access --
+
+	//!	Return a const reference to the sample buffer used (not
+	//!	owned) by this Synthesizer.
+	const std::vector<double> & samples( void ) const;
+
+	//!	Return a reference to the sample buffer used (not
+	//!	owned) by this Synthesizer.
+	std::vector<double> & samples( void );
+	
+	
+//	-- parameter access and mutation --
+
+
+	//!	Return this Synthesizer's Partial fade time, in seconds.
+	double fadeTime( void ) const;
+	 
+	//!	Return the sampling rate (in Hz) for this Synthesizer.
+	double sampleRate( void ) const;
+
+	//!	Set this Synthesizer's fade time to the specified value 
+	//!	(in seconds, must be non-negative).
+	//!
+	//!	\param	partialFadeTime The new Partial fade time.
+	//!	\throw	InvalidArgument if the specified fade time is negative.
+	void setFadeTime( double partialFadeTime );
+
+	//!	Set this Synthesizer's sample rate to the specified value 
+	//!	(in Hz, must be positive).
+	//!
+	//!	\param	rate The new synthesis sample rate.
+	//!	\throw	InvalidArgument if the specified rate is nonpositive.
+	void setSampleRate( double rate );
+
+	//! Return access to the Filter used by this Synthesizer's 
+	//! Oscillator to implement bandwidth-enhanced sinusoidal 
+	//! synthesis. (Can use this access to make changes to the
+	//! filter coefficients.)
+	Filter & filter( void );
+	
+
+//	-- parameters structure --
+
+    enum
+    {
+        Default_FadeTime_Ms = 1,
+        Default_SampleRate_Hz = 44100
+    };
+    
+    // enum EnhancementFlag { Sinusoidal = 0,  BwEnhanced = 1 };
+
+    //!	Structure storing a configuration of Synthesizer parameters.
+    //! Elements in this struct can be freely modified, the configuration
+    //! is validated before it can be used to construct a Synthesizer.
+    //!
+    //! \sa IsValidParameters
+	struct Parameters
+	{
+		double fadeTime;
+		double sampleRate;
+		// EnhancementFlag enhancement;
+		
+		Filter filter;
+		
+		//  default constructor
+		//
+	 	//!	Assign default initial values to the Synthesizer parameters, Filter
+		//!	defaults are defined in Filter.C, others in Synthesizer.C.
+		Parameters( void );
+		
+		//	copy, assign, and destroy are free
+	}; 		
+	
+	//! Default configuration of a Loris::Synthesizer. Modify the values 
+	//! in this structure to alter the configuration of all Synthesizers, 
+	//! including those used by the AiffFile class to render Partials.
+	static const Parameters & DefaultParameters( void );
+
+	//! Assign a new default configuration of a Loris::Synthesizer
+	//! to alter the configuration of all Synthesizers, 
+	//! including those used by the AiffFile class to render Partials.
+	//!
+	//! \param params A Parameters struct describing the new default 
+	//!               configuration for Synthesizers.
+	//!	\throw	InvalidArgument if params reprsents an invalid configuration.
+	static void SetDefaultParameters( const Parameters & params );
+	
+	//! Check the validty of a Parameters structure. Returns true if the
+	//! struct represents a valid Synthesizer configuration, otherwise
+	//! raise InvalidArgument reporting the specific error.
+	//!
+	//! \param params A Parameters struct describing a configuration for 
+	//!               Synthesizers.
+	//!	\throw	InvalidArgument if params reprsents an invalid configuration.
+	static bool IsValidParameters( const Parameters & params );
+	
+
+//	-- implementation --
+private:
+
+	Oscillator m_osc; 	//  the Synthesizer has-a Oscillator that it uses to render
+                        //  all the Partials one by one. 
+    
+	std::vector< double > * m_sampleBuffer;	//	samples are computed and stored here, BUT
+	                                        //  Synthesizer does NOT own this buffer.
+	
+	double m_fadeTimeSec;               	//  Partial fade in/out time in seconds
+	double m_srateHz;                     	//	sample rate in Hz
+		
+};	//	end of class Synthesizer
+
+
+// ---------------------------------------------------------------------------
+//	synthesize 
+// ---------------------------------------------------------------------------
+//!	Synthesize all Partials on the specified half-open (STL-style) range.
+//!	Null Breakpoints are inserted at either end of the Partial to reduce
+//!	turn-on and turn-off artifacts, as described above. The synthesizer
+//!	will resize the buffer as necessary to accommodate all the samples,
+//!	including the fade outs. Previous contents of the buffer are not
+//!	overwritten. Partials with start times earlier than the Partial fade
+//!	time will have shorter onset fades.
+//!
+//! \param  begin_partials The beginning of the range of Partials 
+//!         to synthesize.
+//! \param 	end_partials The end of the range of Partials 
+//!         to synthesize.
+//! \return Nothing.
+//!	\pre    The partials must have non-negative start times.
+//! \post   This Synthesizer's sample buffer (vector) has been 
+//!         resized to accommodate the entire duration of all the 
+//!         Partials including fade out at the ends.
+//!	\throw	InvalidPartial if any Partial has negative start time.
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void 
+Synthesizer::synthesize( Iter begin_partials, Iter end_partials ) 
+#else
+inline void 
+Synthesizer::synthesize( PartialList::iterator begin_partials, 
+						 PartialList::iterator end_partials ) 
+#endif
+{ 
+    //	grow the sample buffer, if necessary, to accommodate the latest
+    //  Partial, with the fade time tacked on the end
+    double duration = 
+        PartialUtils::timeSpan( begin_partials, end_partials ).second + 
+        m_fadeTimeSec;
+    
+    typedef std::vector< double >::size_type Sz_Type;
+    Sz_Type Nsamps = 1 + Sz_Type( duration * m_srateHz );    
+    if ( m_sampleBuffer->size() < Nsamps )
+    {
+        m_sampleBuffer->resize( Nsamps );
+    }
+    
+    while ( begin_partials != end_partials ) 
+    {
+        synthesize( *(begin_partials++) ); 
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	operator() 
+// ---------------------------------------------------------------------------
+//!	Function call operator: same as 
+//!		synthesize( begin_partials, end_partials, timeShift ).
+//
+#if ! defined(NO_TEMPLATE_MEMBERS)
+template<typename Iter>
+void
+Synthesizer::operator() ( Iter begin_partials, Iter end_partials ) 
+#else
+inline void
+Synthesizer::operator() ( PartialList::iterator begin_partials, 
+                          PartialList::iterator end_partials ) 
+#endif
+{ 
+	synthesize( begin_partials, end_partials ); 
+}
+
+}	//	end of namespace Loris
+
+#endif /* ndef INCLUDE_SYNTHESIZER_H */
diff --git a/src/loris/fftsg.c b/src/loris/fftsg.c
new file mode 100644
index 0000000..dc3e237
--- /dev/null
+++ b/src/loris/fftsg.c
@@ -0,0 +1,3331 @@
+/*  
+    double-precision floating point transform functions
+    adapted from the tranform library of Ooura.
+    http://momonga.t.u-tokyo.ac.jp/~ooura/fft.html
+
+    Identical to fftsg.c, wrapped in extern "C"
+    to prevent name-mangling by a C++ compiler.
+
+    Kelly Fitz 21 July 2006
+    kfitz@cerlsoundgroup.org
+*/
+/*
+Fast Fourier/Cosine/Sine Transform
+    dimension   :one
+    data length :power of 2
+    decimation  :frequency
+    radix       :split-radix
+    data        :inplace
+    table       :use
+functions
+    cdft: Complex Discrete Fourier Transform
+    rdft: Real Discrete Fourier Transform
+    ddct: Discrete Cosine Transform
+    ddst: Discrete Sine Transform
+    dfct: Cosine Transform of RDFT (Real Symmetric DFT)
+    dfst: Sine Transform of RDFT (Real Anti-symmetric DFT)
+function prototypes
+    void cdft(int, int, double *, int *, double *);
+    void rdft(int, int, double *, int *, double *);
+    void ddct(int, int, double *, int *, double *);
+    void ddst(int, int, double *, int *, double *);
+    void dfct(int, double *, double *, int *, double *);
+    void dfst(int, double *, double *, int *, double *);
+macro definitions
+    USE_CDFT_PTHREADS : default=not defined
+        CDFT_THREADS_BEGIN_N  : must be >= 512, default=8192
+        CDFT_4THREADS_BEGIN_N : must be >= 512, default=65536
+    USE_CDFT_WINTHREADS : default=not defined
+        CDFT_THREADS_BEGIN_N  : must be >= 512, default=32768
+        CDFT_4THREADS_BEGIN_N : must be >= 512, default=524288
+
+
+-------- Complex DFT (Discrete Fourier Transform) --------
+    [definition]
+        <case1>
+            X[k] = sum_j=0^n-1 x[j]*exp(2*pi*i*j*k/n), 0<=k<n
+        <case2>
+            X[k] = sum_j=0^n-1 x[j]*exp(-2*pi*i*j*k/n), 0<=k<n
+        (notes: sum_j=0^n-1 is a summation from j=0 to n-1)
+    [usage]
+        <case1>
+            ip[0] = 0; // first time only
+            cdft(2*n, 1, a, ip, w);
+        <case2>
+            ip[0] = 0; // first time only
+            cdft(2*n, -1, a, ip, w);
+    [parameters]
+        2*n            :data length (int)
+                        n >= 1, n = power of 2
+        a[0...2*n-1]   :input/output data (double *)
+                        input data
+                            a[2*j] = Re(x[j]), 
+                            a[2*j+1] = Im(x[j]), 0<=j<n
+                        output data
+                            a[2*k] = Re(X[k]), 
+                            a[2*k+1] = Im(X[k]), 0<=k<n
+        ip[0...*]      :work area for bit reversal (int *)
+                        length of ip >= 2+sqrt(n)
+                        strictly, 
+                        length of ip >= 
+                            2+(1<<(int)(log(n+0.5)/log(2))/2).
+                        ip[0],ip[1] are pointers of the cos/sin table.
+        w[0...n/2-1]   :cos/sin table (double *)
+                        w[],ip[] are initialized if ip[0] == 0.
+    [remark]
+        Inverse of 
+            cdft(2*n, -1, a, ip, w);
+        is 
+            cdft(2*n, 1, a, ip, w);
+            for (j = 0; j <= 2 * n - 1; j++) {
+                a[j] *= 1.0 / n;
+            }
+        .
+
+
+-------- Real DFT / Inverse of Real DFT --------
+    [definition]
+        <case1> RDFT
+            R[k] = sum_j=0^n-1 a[j]*cos(2*pi*j*k/n), 0<=k<=n/2
+            I[k] = sum_j=0^n-1 a[j]*sin(2*pi*j*k/n), 0<k<n/2
+        <case2> IRDFT (excluding scale)
+            a[k] = (R[0] + R[n/2]*cos(pi*k))/2 + 
+                   sum_j=1^n/2-1 R[j]*cos(2*pi*j*k/n) + 
+                   sum_j=1^n/2-1 I[j]*sin(2*pi*j*k/n), 0<=k<n
+    [usage]
+        <case1>
+            ip[0] = 0; // first time only
+            rdft(n, 1, a, ip, w);
+        <case2>
+            ip[0] = 0; // first time only
+            rdft(n, -1, a, ip, w);
+    [parameters]
+        n              :data length (int)
+                        n >= 2, n = power of 2
+        a[0...n-1]     :input/output data (double *)
+                        <case1>
+                            output data
+                                a[2*k] = R[k], 0<=k<n/2
+                                a[2*k+1] = I[k], 0<k<n/2
+                                a[1] = R[n/2]
+                        <case2>
+                            input data
+                                a[2*j] = R[j], 0<=j<n/2
+                                a[2*j+1] = I[j], 0<j<n/2
+                                a[1] = R[n/2]
+        ip[0...*]      :work area for bit reversal (int *)
+                        length of ip >= 2+sqrt(n/2)
+                        strictly, 
+                        length of ip >= 
+                            2+(1<<(int)(log(n/2+0.5)/log(2))/2).
+                        ip[0],ip[1] are pointers of the cos/sin table.
+        w[0...n/2-1]   :cos/sin table (double *)
+                        w[],ip[] are initialized if ip[0] == 0.
+    [remark]
+        Inverse of 
+            rdft(n, 1, a, ip, w);
+        is 
+            rdft(n, -1, a, ip, w);
+            for (j = 0; j <= n - 1; j++) {
+                a[j] *= 2.0 / n;
+            }
+        .
+
+
+-------- DCT (Discrete Cosine Transform) / Inverse of DCT --------
+    [definition]
+        <case1> IDCT (excluding scale)
+            C[k] = sum_j=0^n-1 a[j]*cos(pi*j*(k+1/2)/n), 0<=k<n
+        <case2> DCT
+            C[k] = sum_j=0^n-1 a[j]*cos(pi*(j+1/2)*k/n), 0<=k<n
+    [usage]
+        <case1>
+            ip[0] = 0; // first time only
+            ddct(n, 1, a, ip, w);
+        <case2>
+            ip[0] = 0; // first time only
+            ddct(n, -1, a, ip, w);
+    [parameters]
+        n              :data length (int)
+                        n >= 2, n = power of 2
+        a[0...n-1]     :input/output data (double *)
+                        output data
+                            a[k] = C[k], 0<=k<n
+        ip[0...*]      :work area for bit reversal (int *)
+                        length of ip >= 2+sqrt(n/2)
+                        strictly, 
+                        length of ip >= 
+                            2+(1<<(int)(log(n/2+0.5)/log(2))/2).
+                        ip[0],ip[1] are pointers of the cos/sin table.
+        w[0...n*5/4-1] :cos/sin table (double *)
+                        w[],ip[] are initialized if ip[0] == 0.
+    [remark]
+        Inverse of 
+            ddct(n, -1, a, ip, w);
+        is 
+            a[0] *= 0.5;
+            ddct(n, 1, a, ip, w);
+            for (j = 0; j <= n - 1; j++) {
+                a[j] *= 2.0 / n;
+            }
+        .
+
+
+-------- DST (Discrete Sine Transform) / Inverse of DST --------
+    [definition]
+        <case1> IDST (excluding scale)
+            S[k] = sum_j=1^n A[j]*sin(pi*j*(k+1/2)/n), 0<=k<n
+        <case2> DST
+            S[k] = sum_j=0^n-1 a[j]*sin(pi*(j+1/2)*k/n), 0<k<=n
+    [usage]
+        <case1>
+            ip[0] = 0; // first time only
+            ddst(n, 1, a, ip, w);
+        <case2>
+            ip[0] = 0; // first time only
+            ddst(n, -1, a, ip, w);
+    [parameters]
+        n              :data length (int)
+                        n >= 2, n = power of 2
+        a[0...n-1]     :input/output data (double *)
+                        <case1>
+                            input data
+                                a[j] = A[j], 0<j<n
+                                a[0] = A[n]
+                            output data
+                                a[k] = S[k], 0<=k<n
+                        <case2>
+                            output data
+                                a[k] = S[k], 0<k<n
+                                a[0] = S[n]
+        ip[0...*]      :work area for bit reversal (int *)
+                        length of ip >= 2+sqrt(n/2)
+                        strictly, 
+                        length of ip >= 
+                            2+(1<<(int)(log(n/2+0.5)/log(2))/2).
+                        ip[0],ip[1] are pointers of the cos/sin table.
+        w[0...n*5/4-1] :cos/sin table (double *)
+                        w[],ip[] are initialized if ip[0] == 0.
+    [remark]
+        Inverse of 
+            ddst(n, -1, a, ip, w);
+        is 
+            a[0] *= 0.5;
+            ddst(n, 1, a, ip, w);
+            for (j = 0; j <= n - 1; j++) {
+                a[j] *= 2.0 / n;
+            }
+        .
+
+
+-------- Cosine Transform of RDFT (Real Symmetric DFT) --------
+    [definition]
+        C[k] = sum_j=0^n a[j]*cos(pi*j*k/n), 0<=k<=n
+    [usage]
+        ip[0] = 0; // first time only
+        dfct(n, a, t, ip, w);
+    [parameters]
+        n              :data length - 1 (int)
+                        n >= 2, n = power of 2
+        a[0...n]       :input/output data (double *)
+                        output data
+                            a[k] = C[k], 0<=k<=n
+        t[0...n/2]     :work area (double *)
+        ip[0...*]      :work area for bit reversal (int *)
+                        length of ip >= 2+sqrt(n/4)
+                        strictly, 
+                        length of ip >= 
+                            2+(1<<(int)(log(n/4+0.5)/log(2))/2).
+                        ip[0],ip[1] are pointers of the cos/sin table.
+        w[0...n*5/8-1] :cos/sin table (double *)
+                        w[],ip[] are initialized if ip[0] == 0.
+    [remark]
+        Inverse of 
+            a[0] *= 0.5;
+            a[n] *= 0.5;
+            dfct(n, a, t, ip, w);
+        is 
+            a[0] *= 0.5;
+            a[n] *= 0.5;
+            dfct(n, a, t, ip, w);
+            for (j = 0; j <= n; j++) {
+                a[j] *= 2.0 / n;
+            }
+        .
+
+
+-------- Sine Transform of RDFT (Real Anti-symmetric DFT) --------
+    [definition]
+        S[k] = sum_j=1^n-1 a[j]*sin(pi*j*k/n), 0<k<n
+    [usage]
+        ip[0] = 0; // first time only
+        dfst(n, a, t, ip, w);
+    [parameters]
+        n              :data length + 1 (int)
+                        n >= 2, n = power of 2
+        a[0...n-1]     :input/output data (double *)
+                        output data
+                            a[k] = S[k], 0<k<n
+                        (a[0] is used for work area)
+        t[0...n/2-1]   :work area (double *)
+        ip[0...*]      :work area for bit reversal (int *)
+                        length of ip >= 2+sqrt(n/4)
+                        strictly, 
+                        length of ip >= 
+                            2+(1<<(int)(log(n/4+0.5)/log(2))/2).
+                        ip[0],ip[1] are pointers of the cos/sin table.
+        w[0...n*5/8-1] :cos/sin table (double *)
+                        w[],ip[] are initialized if ip[0] == 0.
+    [remark]
+        Inverse of 
+            dfst(n, a, t, ip, w);
+        is 
+            dfst(n, a, t, ip, w);
+            for (j = 1; j <= n - 1; j++) {
+                a[j] *= 2.0 / n;
+            }
+        .
+
+
+Appendix :
+    The cos/sin table is recalculated when the larger table required.
+    w[] and ip[] are compatible with all routines.
+*/
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+void cdft(int n, int isgn, double *a, int *ip, double *w)
+{
+    void makewt(int nw, int *ip, double *w);
+    void cftfsub(int n, double *a, int *ip, int nw, double *w);
+    void cftbsub(int n, double *a, int *ip, int nw, double *w);
+    int nw;
+    
+    nw = ip[0];
+    if (n > (nw << 2)) {
+        nw = n >> 2;
+        makewt(nw, ip, w);
+    }
+    if (isgn >= 0) {
+        cftfsub(n, a, ip, nw, w);
+    } else {
+        cftbsub(n, a, ip, nw, w);
+    }
+}
+
+
+void rdft(int n, int isgn, double *a, int *ip, double *w)
+{
+    void makewt(int nw, int *ip, double *w);
+    void makect(int nc, int *ip, double *c);
+    void cftfsub(int n, double *a, int *ip, int nw, double *w);
+    void cftbsub(int n, double *a, int *ip, int nw, double *w);
+    void rftfsub(int n, double *a, int nc, double *c);
+    void rftbsub(int n, double *a, int nc, double *c);
+    int nw, nc;
+    double xi;
+    
+    nw = ip[0];
+    if (n > (nw << 2)) {
+        nw = n >> 2;
+        makewt(nw, ip, w);
+    }
+    nc = ip[1];
+    if (n > (nc << 2)) {
+        nc = n >> 2;
+        makect(nc, ip, w + nw);
+    }
+    if (isgn >= 0) {
+        if (n > 4) {
+            cftfsub(n, a, ip, nw, w);
+            rftfsub(n, a, nc, w + nw);
+        } else if (n == 4) {
+            cftfsub(n, a, ip, nw, w);
+        }
+        xi = a[0] - a[1];
+        a[0] += a[1];
+        a[1] = xi;
+    } else {
+        a[1] = 0.5 * (a[0] - a[1]);
+        a[0] -= a[1];
+        if (n > 4) {
+            rftbsub(n, a, nc, w + nw);
+            cftbsub(n, a, ip, nw, w);
+        } else if (n == 4) {
+            cftbsub(n, a, ip, nw, w);
+        }
+    }
+}
+
+
+void ddct(int n, int isgn, double *a, int *ip, double *w)
+{
+    void makewt(int nw, int *ip, double *w);
+    void makect(int nc, int *ip, double *c);
+    void cftfsub(int n, double *a, int *ip, int nw, double *w);
+    void cftbsub(int n, double *a, int *ip, int nw, double *w);
+    void rftfsub(int n, double *a, int nc, double *c);
+    void rftbsub(int n, double *a, int nc, double *c);
+    void dctsub(int n, double *a, int nc, double *c);
+    int j, nw, nc;
+    double xr;
+    
+    nw = ip[0];
+    if (n > (nw << 2)) {
+        nw = n >> 2;
+        makewt(nw, ip, w);
+    }
+    nc = ip[1];
+    if (n > nc) {
+        nc = n;
+        makect(nc, ip, w + nw);
+    }
+    if (isgn < 0) {
+        xr = a[n - 1];
+        for (j = n - 2; j >= 2; j -= 2) {
+            a[j + 1] = a[j] - a[j - 1];
+            a[j] += a[j - 1];
+        }
+        a[1] = a[0] - xr;
+        a[0] += xr;
+        if (n > 4) {
+            rftbsub(n, a, nc, w + nw);
+            cftbsub(n, a, ip, nw, w);
+        } else if (n == 4) {
+            cftbsub(n, a, ip, nw, w);
+        }
+    }
+    dctsub(n, a, nc, w + nw);
+    if (isgn >= 0) {
+        if (n > 4) {
+            cftfsub(n, a, ip, nw, w);
+            rftfsub(n, a, nc, w + nw);
+        } else if (n == 4) {
+            cftfsub(n, a, ip, nw, w);
+        }
+        xr = a[0] - a[1];
+        a[0] += a[1];
+        for (j = 2; j < n; j += 2) {
+            a[j - 1] = a[j] - a[j + 1];
+            a[j] += a[j + 1];
+        }
+        a[n - 1] = xr;
+    }
+}
+
+
+void ddst(int n, int isgn, double *a, int *ip, double *w)
+{
+    void makewt(int nw, int *ip, double *w);
+    void makect(int nc, int *ip, double *c);
+    void cftfsub(int n, double *a, int *ip, int nw, double *w);
+    void cftbsub(int n, double *a, int *ip, int nw, double *w);
+    void rftfsub(int n, double *a, int nc, double *c);
+    void rftbsub(int n, double *a, int nc, double *c);
+    void dstsub(int n, double *a, int nc, double *c);
+    int j, nw, nc;
+    double xr;
+    
+    nw = ip[0];
+    if (n > (nw << 2)) {
+        nw = n >> 2;
+        makewt(nw, ip, w);
+    }
+    nc = ip[1];
+    if (n > nc) {
+        nc = n;
+        makect(nc, ip, w + nw);
+    }
+    if (isgn < 0) {
+        xr = a[n - 1];
+        for (j = n - 2; j >= 2; j -= 2) {
+            a[j + 1] = -a[j] - a[j - 1];
+            a[j] -= a[j - 1];
+        }
+        a[1] = a[0] + xr;
+        a[0] -= xr;
+        if (n > 4) {
+            rftbsub(n, a, nc, w + nw);
+            cftbsub(n, a, ip, nw, w);
+        } else if (n == 4) {
+            cftbsub(n, a, ip, nw, w);
+        }
+    }
+    dstsub(n, a, nc, w + nw);
+    if (isgn >= 0) {
+        if (n > 4) {
+            cftfsub(n, a, ip, nw, w);
+            rftfsub(n, a, nc, w + nw);
+        } else if (n == 4) {
+            cftfsub(n, a, ip, nw, w);
+        }
+        xr = a[0] - a[1];
+        a[0] += a[1];
+        for (j = 2; j < n; j += 2) {
+            a[j - 1] = -a[j] - a[j + 1];
+            a[j] -= a[j + 1];
+        }
+        a[n - 1] = -xr;
+    }
+}
+
+
+void dfct(int n, double *a, double *t, int *ip, double *w)
+{
+    void makewt(int nw, int *ip, double *w);
+    void makect(int nc, int *ip, double *c);
+    void cftfsub(int n, double *a, int *ip, int nw, double *w);
+    void rftfsub(int n, double *a, int nc, double *c);
+    void dctsub(int n, double *a, int nc, double *c);
+    int j, k, l, m, mh, nw, nc;
+    double xr, xi, yr, yi;
+    
+    nw = ip[0];
+    if (n > (nw << 3)) {
+        nw = n >> 3;
+        makewt(nw, ip, w);
+    }
+    nc = ip[1];
+    if (n > (nc << 1)) {
+        nc = n >> 1;
+        makect(nc, ip, w + nw);
+    }
+    m = n >> 1;
+    yi = a[m];
+    xi = a[0] + a[n];
+    a[0] -= a[n];
+    t[0] = xi - yi;
+    t[m] = xi + yi;
+    if (n > 2) {
+        mh = m >> 1;
+        for (j = 1; j < mh; j++) {
+            k = m - j;
+            xr = a[j] - a[n - j];
+            xi = a[j] + a[n - j];
+            yr = a[k] - a[n - k];
+            yi = a[k] + a[n - k];
+            a[j] = xr;
+            a[k] = yr;
+            t[j] = xi - yi;
+            t[k] = xi + yi;
+        }
+        t[mh] = a[mh] + a[n - mh];
+        a[mh] -= a[n - mh];
+        dctsub(m, a, nc, w + nw);
+        if (m > 4) {
+            cftfsub(m, a, ip, nw, w);
+            rftfsub(m, a, nc, w + nw);
+        } else if (m == 4) {
+            cftfsub(m, a, ip, nw, w);
+        }
+        a[n - 1] = a[0] - a[1];
+        a[1] = a[0] + a[1];
+        for (j = m - 2; j >= 2; j -= 2) {
+            a[2 * j + 1] = a[j] + a[j + 1];
+            a[2 * j - 1] = a[j] - a[j + 1];
+        }
+        l = 2;
+        m = mh;
+        while (m >= 2) {
+            dctsub(m, t, nc, w + nw);
+            if (m > 4) {
+                cftfsub(m, t, ip, nw, w);
+                rftfsub(m, t, nc, w + nw);
+            } else if (m == 4) {
+                cftfsub(m, t, ip, nw, w);
+            }
+            a[n - l] = t[0] - t[1];
+            a[l] = t[0] + t[1];
+            k = 0;
+            for (j = 2; j < m; j += 2) {
+                k += l << 2;
+                a[k - l] = t[j] - t[j + 1];
+                a[k + l] = t[j] + t[j + 1];
+            }
+            l <<= 1;
+            mh = m >> 1;
+            for (j = 0; j < mh; j++) {
+                k = m - j;
+                t[j] = t[m + k] - t[m + j];
+                t[k] = t[m + k] + t[m + j];
+            }
+            t[mh] = t[m + mh];
+            m = mh;
+        }
+        a[l] = t[0];
+        a[n] = t[2] - t[1];
+        a[0] = t[2] + t[1];
+    } else {
+        a[1] = a[0];
+        a[2] = t[0];
+        a[0] = t[1];
+    }
+}
+
+
+void dfst(int n, double *a, double *t, int *ip, double *w)
+{
+    void makewt(int nw, int *ip, double *w);
+    void makect(int nc, int *ip, double *c);
+    void cftfsub(int n, double *a, int *ip, int nw, double *w);
+    void rftfsub(int n, double *a, int nc, double *c);
+    void dstsub(int n, double *a, int nc, double *c);
+    int j, k, l, m, mh, nw, nc;
+    double xr, xi, yr, yi;
+    
+    nw = ip[0];
+    if (n > (nw << 3)) {
+        nw = n >> 3;
+        makewt(nw, ip, w);
+    }
+    nc = ip[1];
+    if (n > (nc << 1)) {
+        nc = n >> 1;
+        makect(nc, ip, w + nw);
+    }
+    if (n > 2) {
+        m = n >> 1;
+        mh = m >> 1;
+        for (j = 1; j < mh; j++) {
+            k = m - j;
+            xr = a[j] + a[n - j];
+            xi = a[j] - a[n - j];
+            yr = a[k] + a[n - k];
+            yi = a[k] - a[n - k];
+            a[j] = xr;
+            a[k] = yr;
+            t[j] = xi + yi;
+            t[k] = xi - yi;
+        }
+        t[0] = a[mh] - a[n - mh];
+        a[mh] += a[n - mh];
+        a[0] = a[m];
+        dstsub(m, a, nc, w + nw);
+        if (m > 4) {
+            cftfsub(m, a, ip, nw, w);
+            rftfsub(m, a, nc, w + nw);
+        } else if (m == 4) {
+            cftfsub(m, a, ip, nw, w);
+        }
+        a[n - 1] = a[1] - a[0];
+        a[1] = a[0] + a[1];
+        for (j = m - 2; j >= 2; j -= 2) {
+            a[2 * j + 1] = a[j] - a[j + 1];
+            a[2 * j - 1] = -a[j] - a[j + 1];
+        }
+        l = 2;
+        m = mh;
+        while (m >= 2) {
+            dstsub(m, t, nc, w + nw);
+            if (m > 4) {
+                cftfsub(m, t, ip, nw, w);
+                rftfsub(m, t, nc, w + nw);
+            } else if (m == 4) {
+                cftfsub(m, t, ip, nw, w);
+            }
+            a[n - l] = t[1] - t[0];
+            a[l] = t[0] + t[1];
+            k = 0;
+            for (j = 2; j < m; j += 2) {
+                k += l << 2;
+                a[k - l] = -t[j] - t[j + 1];
+                a[k + l] = t[j] - t[j + 1];
+            }
+            l <<= 1;
+            mh = m >> 1;
+            for (j = 1; j < mh; j++) {
+                k = m - j;
+                t[j] = t[m + k] + t[m + j];
+                t[k] = t[m + k] - t[m + j];
+            }
+            t[0] = t[m + mh];
+            m = mh;
+        }
+        a[l] = t[0];
+    }
+    a[0] = 0;
+}
+
+
+/* -------- initializing routines -------- */
+
+
+#include <math.h>
+
+void makewt(int nw, int *ip, double *w)
+{
+    void makeipt(int nw, int *ip);
+    int j, nwh, nw0, nw1;
+    double delta, wn4r, wk1r, wk1i, wk3r, wk3i;
+    
+    ip[0] = nw;
+    ip[1] = 1;
+    if (nw > 2) {
+        nwh = nw >> 1;
+        delta = atan(1.0) / nwh;
+        wn4r = cos(delta * nwh);
+        w[0] = 1;
+        w[1] = wn4r;
+        if (nwh == 4) {
+            w[2] = cos(delta * 2);
+            w[3] = sin(delta * 2);
+        } else if (nwh > 4) {
+            makeipt(nw, ip);
+            w[2] = 0.5 / cos(delta * 2);
+            w[3] = 0.5 / cos(delta * 6);
+            for (j = 4; j < nwh; j += 4) {
+                w[j] = cos(delta * j);
+                w[j + 1] = sin(delta * j);
+                w[j + 2] = cos(3 * delta * j);
+                w[j + 3] = -sin(3 * delta * j);
+            }
+        }
+        nw0 = 0;
+        while (nwh > 2) {
+            nw1 = nw0 + nwh;
+            nwh >>= 1;
+            w[nw1] = 1;
+            w[nw1 + 1] = wn4r;
+            if (nwh == 4) {
+                wk1r = w[nw0 + 4];
+                wk1i = w[nw0 + 5];
+                w[nw1 + 2] = wk1r;
+                w[nw1 + 3] = wk1i;
+            } else if (nwh > 4) {
+                wk1r = w[nw0 + 4];
+                wk3r = w[nw0 + 6];
+                w[nw1 + 2] = 0.5 / wk1r;
+                w[nw1 + 3] = 0.5 / wk3r;
+                for (j = 4; j < nwh; j += 4) {
+                    wk1r = w[nw0 + 2 * j];
+                    wk1i = w[nw0 + 2 * j + 1];
+                    wk3r = w[nw0 + 2 * j + 2];
+                    wk3i = w[nw0 + 2 * j + 3];
+                    w[nw1 + j] = wk1r;
+                    w[nw1 + j + 1] = wk1i;
+                    w[nw1 + j + 2] = wk3r;
+                    w[nw1 + j + 3] = wk3i;
+                }
+            }
+            nw0 = nw1;
+        }
+    }
+}
+
+
+void makeipt(int nw, int *ip)
+{
+    int j, l, m, m2, p, q;
+    
+    ip[2] = 0;
+    ip[3] = 16;
+    m = 2;
+    for (l = nw; l > 32; l >>= 2) {
+        m2 = m << 1;
+        q = m2 << 3;
+        for (j = m; j < m2; j++) {
+            p = ip[j] << 2;
+            ip[m + j] = p;
+            ip[m2 + j] = p + q;
+        }
+        m = m2;
+    }
+}
+
+
+void makect(int nc, int *ip, double *c)
+{
+    int j, nch;
+    double delta;
+    
+    ip[1] = nc;
+    if (nc > 1) {
+        nch = nc >> 1;
+        delta = atan(1.0) / nch;
+        c[0] = cos(delta * nch);
+        c[nch] = 0.5 * c[0];
+        for (j = 1; j < nch; j++) {
+            c[j] = 0.5 * cos(delta * j);
+            c[nc - j] = 0.5 * sin(delta * j);
+        }
+    }
+}
+
+
+/* -------- child routines -------- */
+
+
+#ifdef USE_CDFT_PTHREADS
+#define USE_CDFT_THREADS
+#ifndef CDFT_THREADS_BEGIN_N
+#define CDFT_THREADS_BEGIN_N 8192
+#endif
+#ifndef CDFT_4THREADS_BEGIN_N
+#define CDFT_4THREADS_BEGIN_N 65536
+#endif
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define cdft_thread_t pthread_t
+#define cdft_thread_create(thp,func,argp) { \
+    if (pthread_create(thp, NULL, func, (void *) argp) != 0) { \
+        fprintf(stderr, "cdft thread error\n"); \
+        exit(1); \
+    } \
+}
+#define cdft_thread_wait(th) { \
+    if (pthread_join(th, NULL) != 0) { \
+        fprintf(stderr, "cdft thread error\n"); \
+        exit(1); \
+    } \
+}
+#endif /* USE_CDFT_PTHREADS */
+
+
+#ifdef USE_CDFT_WINTHREADS
+#define USE_CDFT_THREADS
+#ifndef CDFT_THREADS_BEGIN_N
+#define CDFT_THREADS_BEGIN_N 32768
+#endif
+#ifndef CDFT_4THREADS_BEGIN_N
+#define CDFT_4THREADS_BEGIN_N 524288
+#endif
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define cdft_thread_t HANDLE
+#define cdft_thread_create(thp,func,argp) { \
+    DWORD thid; \
+    *(thp) = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) func, (LPVOID) argp, 0, &thid); \
+    if (*(thp) == 0) { \
+        fprintf(stderr, "cdft thread error\n"); \
+        exit(1); \
+    } \
+}
+#define cdft_thread_wait(th) { \
+    WaitForSingleObject(th, INFINITE); \
+    CloseHandle(th); \
+}
+#endif /* USE_CDFT_WINTHREADS */
+
+
+void cftfsub(int n, double *a, int *ip, int nw, double *w)
+{
+    void bitrv2(int n, int *ip, double *a);
+    void bitrv216(double *a);
+    void bitrv208(double *a);
+    void cftf1st(int n, double *a, double *w);
+    void cftrec4(int n, double *a, int nw, double *w);
+    void cftleaf(int n, int isplt, double *a, int nw, double *w);
+    void cftfx41(int n, double *a, int nw, double *w);
+    void cftf161(double *a, double *w);
+    void cftf081(double *a, double *w);
+    void cftf040(double *a);
+    void cftx020(double *a);
+#ifdef USE_CDFT_THREADS
+    void cftrec4_th(int n, double *a, int nw, double *w);
+#endif /* USE_CDFT_THREADS */
+    
+    if (n > 8) {
+        if (n > 32) {
+            cftf1st(n, a, &w[nw - (n >> 2)]);
+#ifdef USE_CDFT_THREADS
+            if (n > CDFT_THREADS_BEGIN_N) {
+                cftrec4_th(n, a, nw, w);
+            } else 
+#endif /* USE_CDFT_THREADS */
+            if (n > 512) {
+                cftrec4(n, a, nw, w);
+            } else if (n > 128) {
+                cftleaf(n, 1, a, nw, w);
+            } else {
+                cftfx41(n, a, nw, w);
+            }
+            bitrv2(n, ip, a);
+        } else if (n == 32) {
+            cftf161(a, &w[nw - 8]);
+            bitrv216(a);
+        } else {
+            cftf081(a, w);
+            bitrv208(a);
+        }
+    } else if (n == 8) {
+        cftf040(a);
+    } else if (n == 4) {
+        cftx020(a);
+    }
+}
+
+
+void cftbsub(int n, double *a, int *ip, int nw, double *w)
+{
+    void bitrv2conj(int n, int *ip, double *a);
+    void bitrv216neg(double *a);
+    void bitrv208neg(double *a);
+    void cftb1st(int n, double *a, double *w);
+    void cftrec4(int n, double *a, int nw, double *w);
+    void cftleaf(int n, int isplt, double *a, int nw, double *w);
+    void cftfx41(int n, double *a, int nw, double *w);
+    void cftf161(double *a, double *w);
+    void cftf081(double *a, double *w);
+    void cftb040(double *a);
+    void cftx020(double *a);
+#ifdef USE_CDFT_THREADS
+    void cftrec4_th(int n, double *a, int nw, double *w);
+#endif /* USE_CDFT_THREADS */
+    
+    if (n > 8) {
+        if (n > 32) {
+            cftb1st(n, a, &w[nw - (n >> 2)]);
+#ifdef USE_CDFT_THREADS
+            if (n > CDFT_THREADS_BEGIN_N) {
+                cftrec4_th(n, a, nw, w);
+            } else 
+#endif /* USE_CDFT_THREADS */
+            if (n > 512) {
+                cftrec4(n, a, nw, w);
+            } else if (n > 128) {
+                cftleaf(n, 1, a, nw, w);
+            } else {
+                cftfx41(n, a, nw, w);
+            }
+            bitrv2conj(n, ip, a);
+        } else if (n == 32) {
+            cftf161(a, &w[nw - 8]);
+            bitrv216neg(a);
+        } else {
+            cftf081(a, w);
+            bitrv208neg(a);
+        }
+    } else if (n == 8) {
+        cftb040(a);
+    } else if (n == 4) {
+        cftx020(a);
+    }
+}
+
+
+void bitrv2(int n, int *ip, double *a)
+{
+    int j, j1, k, k1, l, m, nh, nm;
+    double xr, xi, yr, yi;
+    
+    m = 1;
+    for (l = n >> 2; l > 8; l >>= 2) {
+        m <<= 1;
+    }
+    nh = n >> 1;
+    nm = 4 * m;
+    if (l == 8) {
+        for (k = 0; k < m; k++) {
+            for (j = 0; j < k; j++) {
+                j1 = 4 * j + 2 * ip[m + k];
+                k1 = 4 * k + 2 * ip[m + j];
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nh;
+                k1 += 2;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += 2;
+                k1 += nh;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nh;
+                k1 -= 2;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+            }
+            k1 = 4 * k + 2 * ip[m + k];
+            j1 = k1 + 2;
+            k1 += nh;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += nm;
+            k1 += 2 * nm;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += nm;
+            k1 -= nm;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 -= 2;
+            k1 -= nh;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += nh + 2;
+            k1 += nh + 2;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 -= nh - nm;
+            k1 += 2 * nm - 2;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+        }
+    } else {
+        for (k = 0; k < m; k++) {
+            for (j = 0; j < k; j++) {
+                j1 = 4 * j + ip[m + k];
+                k1 = 4 * k + ip[m + j];
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nh;
+                k1 += 2;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += 2;
+                k1 += nh;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nh;
+                k1 -= 2;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = a[j1 + 1];
+                yr = a[k1];
+                yi = a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+            }
+            k1 = 4 * k + ip[m + k];
+            j1 = k1 + 2;
+            k1 += nh;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += nm;
+            k1 += nm;
+            xr = a[j1];
+            xi = a[j1 + 1];
+            yr = a[k1];
+            yi = a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+        }
+    }
+}
+
+
+void bitrv2conj(int n, int *ip, double *a)
+{
+    int j, j1, k, k1, l, m, nh, nm;
+    double xr, xi, yr, yi;
+    
+    m = 1;
+    for (l = n >> 2; l > 8; l >>= 2) {
+        m <<= 1;
+    }
+    nh = n >> 1;
+    nm = 4 * m;
+    if (l == 8) {
+        for (k = 0; k < m; k++) {
+            for (j = 0; j < k; j++) {
+                j1 = 4 * j + 2 * ip[m + k];
+                k1 = 4 * k + 2 * ip[m + j];
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nh;
+                k1 += 2;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += 2;
+                k1 += nh;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nh;
+                k1 -= 2;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= 2 * nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+            }
+            k1 = 4 * k + 2 * ip[m + k];
+            j1 = k1 + 2;
+            k1 += nh;
+            a[j1 - 1] = -a[j1 - 1];
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            a[k1 + 3] = -a[k1 + 3];
+            j1 += nm;
+            k1 += 2 * nm;
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += nm;
+            k1 -= nm;
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 -= 2;
+            k1 -= nh;
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 += nh + 2;
+            k1 += nh + 2;
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            j1 -= nh - nm;
+            k1 += 2 * nm - 2;
+            a[j1 - 1] = -a[j1 - 1];
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            a[k1 + 3] = -a[k1 + 3];
+        }
+    } else {
+        for (k = 0; k < m; k++) {
+            for (j = 0; j < k; j++) {
+                j1 = 4 * j + ip[m + k];
+                k1 = 4 * k + ip[m + j];
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nh;
+                k1 += 2;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += 2;
+                k1 += nh;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 += nm;
+                k1 += nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nh;
+                k1 -= 2;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+                j1 -= nm;
+                k1 -= nm;
+                xr = a[j1];
+                xi = -a[j1 + 1];
+                yr = a[k1];
+                yi = -a[k1 + 1];
+                a[j1] = yr;
+                a[j1 + 1] = yi;
+                a[k1] = xr;
+                a[k1 + 1] = xi;
+            }
+            k1 = 4 * k + ip[m + k];
+            j1 = k1 + 2;
+            k1 += nh;
+            a[j1 - 1] = -a[j1 - 1];
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            a[k1 + 3] = -a[k1 + 3];
+            j1 += nm;
+            k1 += nm;
+            a[j1 - 1] = -a[j1 - 1];
+            xr = a[j1];
+            xi = -a[j1 + 1];
+            yr = a[k1];
+            yi = -a[k1 + 1];
+            a[j1] = yr;
+            a[j1 + 1] = yi;
+            a[k1] = xr;
+            a[k1 + 1] = xi;
+            a[k1 + 3] = -a[k1 + 3];
+        }
+    }
+}
+
+
+void bitrv216(double *a)
+{
+    double x1r, x1i, x2r, x2i, x3r, x3i, x4r, x4i, 
+        x5r, x5i, x7r, x7i, x8r, x8i, x10r, x10i, 
+        x11r, x11i, x12r, x12i, x13r, x13i, x14r, x14i;
+    
+    x1r = a[2];
+    x1i = a[3];
+    x2r = a[4];
+    x2i = a[5];
+    x3r = a[6];
+    x3i = a[7];
+    x4r = a[8];
+    x4i = a[9];
+    x5r = a[10];
+    x5i = a[11];
+    x7r = a[14];
+    x7i = a[15];
+    x8r = a[16];
+    x8i = a[17];
+    x10r = a[20];
+    x10i = a[21];
+    x11r = a[22];
+    x11i = a[23];
+    x12r = a[24];
+    x12i = a[25];
+    x13r = a[26];
+    x13i = a[27];
+    x14r = a[28];
+    x14i = a[29];
+    a[2] = x8r;
+    a[3] = x8i;
+    a[4] = x4r;
+    a[5] = x4i;
+    a[6] = x12r;
+    a[7] = x12i;
+    a[8] = x2r;
+    a[9] = x2i;
+    a[10] = x10r;
+    a[11] = x10i;
+    a[14] = x14r;
+    a[15] = x14i;
+    a[16] = x1r;
+    a[17] = x1i;
+    a[20] = x5r;
+    a[21] = x5i;
+    a[22] = x13r;
+    a[23] = x13i;
+    a[24] = x3r;
+    a[25] = x3i;
+    a[26] = x11r;
+    a[27] = x11i;
+    a[28] = x7r;
+    a[29] = x7i;
+}
+
+
+void bitrv216neg(double *a)
+{
+    double x1r, x1i, x2r, x2i, x3r, x3i, x4r, x4i, 
+        x5r, x5i, x6r, x6i, x7r, x7i, x8r, x8i, 
+        x9r, x9i, x10r, x10i, x11r, x11i, x12r, x12i, 
+        x13r, x13i, x14r, x14i, x15r, x15i;
+    
+    x1r = a[2];
+    x1i = a[3];
+    x2r = a[4];
+    x2i = a[5];
+    x3r = a[6];
+    x3i = a[7];
+    x4r = a[8];
+    x4i = a[9];
+    x5r = a[10];
+    x5i = a[11];
+    x6r = a[12];
+    x6i = a[13];
+    x7r = a[14];
+    x7i = a[15];
+    x8r = a[16];
+    x8i = a[17];
+    x9r = a[18];
+    x9i = a[19];
+    x10r = a[20];
+    x10i = a[21];
+    x11r = a[22];
+    x11i = a[23];
+    x12r = a[24];
+    x12i = a[25];
+    x13r = a[26];
+    x13i = a[27];
+    x14r = a[28];
+    x14i = a[29];
+    x15r = a[30];
+    x15i = a[31];
+    a[2] = x15r;
+    a[3] = x15i;
+    a[4] = x7r;
+    a[5] = x7i;
+    a[6] = x11r;
+    a[7] = x11i;
+    a[8] = x3r;
+    a[9] = x3i;
+    a[10] = x13r;
+    a[11] = x13i;
+    a[12] = x5r;
+    a[13] = x5i;
+    a[14] = x9r;
+    a[15] = x9i;
+    a[16] = x1r;
+    a[17] = x1i;
+    a[18] = x14r;
+    a[19] = x14i;
+    a[20] = x6r;
+    a[21] = x6i;
+    a[22] = x10r;
+    a[23] = x10i;
+    a[24] = x2r;
+    a[25] = x2i;
+    a[26] = x12r;
+    a[27] = x12i;
+    a[28] = x4r;
+    a[29] = x4i;
+    a[30] = x8r;
+    a[31] = x8i;
+}
+
+
+void bitrv208(double *a)
+{
+    double x1r, x1i, x3r, x3i, x4r, x4i, x6r, x6i;
+    
+    x1r = a[2];
+    x1i = a[3];
+    x3r = a[6];
+    x3i = a[7];
+    x4r = a[8];
+    x4i = a[9];
+    x6r = a[12];
+    x6i = a[13];
+    a[2] = x4r;
+    a[3] = x4i;
+    a[6] = x6r;
+    a[7] = x6i;
+    a[8] = x1r;
+    a[9] = x1i;
+    a[12] = x3r;
+    a[13] = x3i;
+}
+
+
+void bitrv208neg(double *a)
+{
+    double x1r, x1i, x2r, x2i, x3r, x3i, x4r, x4i, 
+        x5r, x5i, x6r, x6i, x7r, x7i;
+    
+    x1r = a[2];
+    x1i = a[3];
+    x2r = a[4];
+    x2i = a[5];
+    x3r = a[6];
+    x3i = a[7];
+    x4r = a[8];
+    x4i = a[9];
+    x5r = a[10];
+    x5i = a[11];
+    x6r = a[12];
+    x6i = a[13];
+    x7r = a[14];
+    x7i = a[15];
+    a[2] = x7r;
+    a[3] = x7i;
+    a[4] = x3r;
+    a[5] = x3i;
+    a[6] = x5r;
+    a[7] = x5i;
+    a[8] = x1r;
+    a[9] = x1i;
+    a[10] = x6r;
+    a[11] = x6i;
+    a[12] = x2r;
+    a[13] = x2i;
+    a[14] = x4r;
+    a[15] = x4i;
+}
+
+
+void cftf1st(int n, double *a, double *w)
+{
+    int j, j0, j1, j2, j3, k, m, mh;
+    double wn4r, csc1, csc3, wk1r, wk1i, wk3r, wk3i, 
+        wd1r, wd1i, wd3r, wd3i;
+    double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, 
+        y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i;
+    
+    mh = n >> 3;
+    m = 2 * mh;
+    j1 = m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[0] + a[j2];
+    x0i = a[1] + a[j2 + 1];
+    x1r = a[0] - a[j2];
+    x1i = a[1] - a[j2 + 1];
+    x2r = a[j1] + a[j3];
+    x2i = a[j1 + 1] + a[j3 + 1];
+    x3r = a[j1] - a[j3];
+    x3i = a[j1 + 1] - a[j3 + 1];
+    a[0] = x0r + x2r;
+    a[1] = x0i + x2i;
+    a[j1] = x0r - x2r;
+    a[j1 + 1] = x0i - x2i;
+    a[j2] = x1r - x3i;
+    a[j2 + 1] = x1i + x3r;
+    a[j3] = x1r + x3i;
+    a[j3 + 1] = x1i - x3r;
+    wn4r = w[1];
+    csc1 = w[2];
+    csc3 = w[3];
+    wd1r = 1;
+    wd1i = 0;
+    wd3r = 1;
+    wd3i = 0;
+    k = 0;
+    for (j = 2; j < mh - 2; j += 4) {
+        k += 4;
+        wk1r = csc1 * (wd1r + w[k]);
+        wk1i = csc1 * (wd1i + w[k + 1]);
+        wk3r = csc3 * (wd3r + w[k + 2]);
+        wk3i = csc3 * (wd3i + w[k + 3]);
+        wd1r = w[k];
+        wd1i = w[k + 1];
+        wd3r = w[k + 2];
+        wd3i = w[k + 3];
+        j1 = j + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j] + a[j2];
+        x0i = a[j + 1] + a[j2 + 1];
+        x1r = a[j] - a[j2];
+        x1i = a[j + 1] - a[j2 + 1];
+        y0r = a[j + 2] + a[j2 + 2];
+        y0i = a[j + 3] + a[j2 + 3];
+        y1r = a[j + 2] - a[j2 + 2];
+        y1i = a[j + 3] - a[j2 + 3];
+        x2r = a[j1] + a[j3];
+        x2i = a[j1 + 1] + a[j3 + 1];
+        x3r = a[j1] - a[j3];
+        x3i = a[j1 + 1] - a[j3 + 1];
+        y2r = a[j1 + 2] + a[j3 + 2];
+        y2i = a[j1 + 3] + a[j3 + 3];
+        y3r = a[j1 + 2] - a[j3 + 2];
+        y3i = a[j1 + 3] - a[j3 + 3];
+        a[j] = x0r + x2r;
+        a[j + 1] = x0i + x2i;
+        a[j + 2] = y0r + y2r;
+        a[j + 3] = y0i + y2i;
+        a[j1] = x0r - x2r;
+        a[j1 + 1] = x0i - x2i;
+        a[j1 + 2] = y0r - y2r;
+        a[j1 + 3] = y0i - y2i;
+        x0r = x1r - x3i;
+        x0i = x1i + x3r;
+        a[j2] = wk1r * x0r - wk1i * x0i;
+        a[j2 + 1] = wk1r * x0i + wk1i * x0r;
+        x0r = y1r - y3i;
+        x0i = y1i + y3r;
+        a[j2 + 2] = wd1r * x0r - wd1i * x0i;
+        a[j2 + 3] = wd1r * x0i + wd1i * x0r;
+        x0r = x1r + x3i;
+        x0i = x1i - x3r;
+        a[j3] = wk3r * x0r + wk3i * x0i;
+        a[j3 + 1] = wk3r * x0i - wk3i * x0r;
+        x0r = y1r + y3i;
+        x0i = y1i - y3r;
+        a[j3 + 2] = wd3r * x0r + wd3i * x0i;
+        a[j3 + 3] = wd3r * x0i - wd3i * x0r;
+        j0 = m - j;
+        j1 = j0 + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j0] + a[j2];
+        x0i = a[j0 + 1] + a[j2 + 1];
+        x1r = a[j0] - a[j2];
+        x1i = a[j0 + 1] - a[j2 + 1];
+        y0r = a[j0 - 2] + a[j2 - 2];
+        y0i = a[j0 - 1] + a[j2 - 1];
+        y1r = a[j0 - 2] - a[j2 - 2];
+        y1i = a[j0 - 1] - a[j2 - 1];
+        x2r = a[j1] + a[j3];
+        x2i = a[j1 + 1] + a[j3 + 1];
+        x3r = a[j1] - a[j3];
+        x3i = a[j1 + 1] - a[j3 + 1];
+        y2r = a[j1 - 2] + a[j3 - 2];
+        y2i = a[j1 - 1] + a[j3 - 1];
+        y3r = a[j1 - 2] - a[j3 - 2];
+        y3i = a[j1 - 1] - a[j3 - 1];
+        a[j0] = x0r + x2r;
+        a[j0 + 1] = x0i + x2i;
+        a[j0 - 2] = y0r + y2r;
+        a[j0 - 1] = y0i + y2i;
+        a[j1] = x0r - x2r;
+        a[j1 + 1] = x0i - x2i;
+        a[j1 - 2] = y0r - y2r;
+        a[j1 - 1] = y0i - y2i;
+        x0r = x1r - x3i;
+        x0i = x1i + x3r;
+        a[j2] = wk1i * x0r - wk1r * x0i;
+        a[j2 + 1] = wk1i * x0i + wk1r * x0r;
+        x0r = y1r - y3i;
+        x0i = y1i + y3r;
+        a[j2 - 2] = wd1i * x0r - wd1r * x0i;
+        a[j2 - 1] = wd1i * x0i + wd1r * x0r;
+        x0r = x1r + x3i;
+        x0i = x1i - x3r;
+        a[j3] = wk3i * x0r + wk3r * x0i;
+        a[j3 + 1] = wk3i * x0i - wk3r * x0r;
+        x0r = y1r + y3i;
+        x0i = y1i - y3r;
+        a[j3 - 2] = wd3i * x0r + wd3r * x0i;
+        a[j3 - 1] = wd3i * x0i - wd3r * x0r;
+    }
+    wk1r = csc1 * (wd1r + wn4r);
+    wk1i = csc1 * (wd1i + wn4r);
+    wk3r = csc3 * (wd3r - wn4r);
+    wk3i = csc3 * (wd3i - wn4r);
+    j0 = mh;
+    j1 = j0 + m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[j0 - 2] + a[j2 - 2];
+    x0i = a[j0 - 1] + a[j2 - 1];
+    x1r = a[j0 - 2] - a[j2 - 2];
+    x1i = a[j0 - 1] - a[j2 - 1];
+    x2r = a[j1 - 2] + a[j3 - 2];
+    x2i = a[j1 - 1] + a[j3 - 1];
+    x3r = a[j1 - 2] - a[j3 - 2];
+    x3i = a[j1 - 1] - a[j3 - 1];
+    a[j0 - 2] = x0r + x2r;
+    a[j0 - 1] = x0i + x2i;
+    a[j1 - 2] = x0r - x2r;
+    a[j1 - 1] = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    a[j2 - 2] = wk1r * x0r - wk1i * x0i;
+    a[j2 - 1] = wk1r * x0i + wk1i * x0r;
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    a[j3 - 2] = wk3r * x0r + wk3i * x0i;
+    a[j3 - 1] = wk3r * x0i - wk3i * x0r;
+    x0r = a[j0] + a[j2];
+    x0i = a[j0 + 1] + a[j2 + 1];
+    x1r = a[j0] - a[j2];
+    x1i = a[j0 + 1] - a[j2 + 1];
+    x2r = a[j1] + a[j3];
+    x2i = a[j1 + 1] + a[j3 + 1];
+    x3r = a[j1] - a[j3];
+    x3i = a[j1 + 1] - a[j3 + 1];
+    a[j0] = x0r + x2r;
+    a[j0 + 1] = x0i + x2i;
+    a[j1] = x0r - x2r;
+    a[j1 + 1] = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    a[j2] = wn4r * (x0r - x0i);
+    a[j2 + 1] = wn4r * (x0i + x0r);
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    a[j3] = -wn4r * (x0r + x0i);
+    a[j3 + 1] = -wn4r * (x0i - x0r);
+    x0r = a[j0 + 2] + a[j2 + 2];
+    x0i = a[j0 + 3] + a[j2 + 3];
+    x1r = a[j0 + 2] - a[j2 + 2];
+    x1i = a[j0 + 3] - a[j2 + 3];
+    x2r = a[j1 + 2] + a[j3 + 2];
+    x2i = a[j1 + 3] + a[j3 + 3];
+    x3r = a[j1 + 2] - a[j3 + 2];
+    x3i = a[j1 + 3] - a[j3 + 3];
+    a[j0 + 2] = x0r + x2r;
+    a[j0 + 3] = x0i + x2i;
+    a[j1 + 2] = x0r - x2r;
+    a[j1 + 3] = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    a[j2 + 2] = wk1i * x0r - wk1r * x0i;
+    a[j2 + 3] = wk1i * x0i + wk1r * x0r;
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    a[j3 + 2] = wk3i * x0r + wk3r * x0i;
+    a[j3 + 3] = wk3i * x0i - wk3r * x0r;
+}
+
+
+void cftb1st(int n, double *a, double *w)
+{
+    int j, j0, j1, j2, j3, k, m, mh;
+    double wn4r, csc1, csc3, wk1r, wk1i, wk3r, wk3i, 
+        wd1r, wd1i, wd3r, wd3i;
+    double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, 
+        y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i;
+    
+    mh = n >> 3;
+    m = 2 * mh;
+    j1 = m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[0] + a[j2];
+    x0i = -a[1] - a[j2 + 1];
+    x1r = a[0] - a[j2];
+    x1i = -a[1] + a[j2 + 1];
+    x2r = a[j1] + a[j3];
+    x2i = a[j1 + 1] + a[j3 + 1];
+    x3r = a[j1] - a[j3];
+    x3i = a[j1 + 1] - a[j3 + 1];
+    a[0] = x0r + x2r;
+    a[1] = x0i - x2i;
+    a[j1] = x0r - x2r;
+    a[j1 + 1] = x0i + x2i;
+    a[j2] = x1r + x3i;
+    a[j2 + 1] = x1i + x3r;
+    a[j3] = x1r - x3i;
+    a[j3 + 1] = x1i - x3r;
+    wn4r = w[1];
+    csc1 = w[2];
+    csc3 = w[3];
+    wd1r = 1;
+    wd1i = 0;
+    wd3r = 1;
+    wd3i = 0;
+    k = 0;
+    for (j = 2; j < mh - 2; j += 4) {
+        k += 4;
+        wk1r = csc1 * (wd1r + w[k]);
+        wk1i = csc1 * (wd1i + w[k + 1]);
+        wk3r = csc3 * (wd3r + w[k + 2]);
+        wk3i = csc3 * (wd3i + w[k + 3]);
+        wd1r = w[k];
+        wd1i = w[k + 1];
+        wd3r = w[k + 2];
+        wd3i = w[k + 3];
+        j1 = j + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j] + a[j2];
+        x0i = -a[j + 1] - a[j2 + 1];
+        x1r = a[j] - a[j2];
+        x1i = -a[j + 1] + a[j2 + 1];
+        y0r = a[j + 2] + a[j2 + 2];
+        y0i = -a[j + 3] - a[j2 + 3];
+        y1r = a[j + 2] - a[j2 + 2];
+        y1i = -a[j + 3] + a[j2 + 3];
+        x2r = a[j1] + a[j3];
+        x2i = a[j1 + 1] + a[j3 + 1];
+        x3r = a[j1] - a[j3];
+        x3i = a[j1 + 1] - a[j3 + 1];
+        y2r = a[j1 + 2] + a[j3 + 2];
+        y2i = a[j1 + 3] + a[j3 + 3];
+        y3r = a[j1 + 2] - a[j3 + 2];
+        y3i = a[j1 + 3] - a[j3 + 3];
+        a[j] = x0r + x2r;
+        a[j + 1] = x0i - x2i;
+        a[j + 2] = y0r + y2r;
+        a[j + 3] = y0i - y2i;
+        a[j1] = x0r - x2r;
+        a[j1 + 1] = x0i + x2i;
+        a[j1 + 2] = y0r - y2r;
+        a[j1 + 3] = y0i + y2i;
+        x0r = x1r + x3i;
+        x0i = x1i + x3r;
+        a[j2] = wk1r * x0r - wk1i * x0i;
+        a[j2 + 1] = wk1r * x0i + wk1i * x0r;
+        x0r = y1r + y3i;
+        x0i = y1i + y3r;
+        a[j2 + 2] = wd1r * x0r - wd1i * x0i;
+        a[j2 + 3] = wd1r * x0i + wd1i * x0r;
+        x0r = x1r - x3i;
+        x0i = x1i - x3r;
+        a[j3] = wk3r * x0r + wk3i * x0i;
+        a[j3 + 1] = wk3r * x0i - wk3i * x0r;
+        x0r = y1r - y3i;
+        x0i = y1i - y3r;
+        a[j3 + 2] = wd3r * x0r + wd3i * x0i;
+        a[j3 + 3] = wd3r * x0i - wd3i * x0r;
+        j0 = m - j;
+        j1 = j0 + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j0] + a[j2];
+        x0i = -a[j0 + 1] - a[j2 + 1];
+        x1r = a[j0] - a[j2];
+        x1i = -a[j0 + 1] + a[j2 + 1];
+        y0r = a[j0 - 2] + a[j2 - 2];
+        y0i = -a[j0 - 1] - a[j2 - 1];
+        y1r = a[j0 - 2] - a[j2 - 2];
+        y1i = -a[j0 - 1] + a[j2 - 1];
+        x2r = a[j1] + a[j3];
+        x2i = a[j1 + 1] + a[j3 + 1];
+        x3r = a[j1] - a[j3];
+        x3i = a[j1 + 1] - a[j3 + 1];
+        y2r = a[j1 - 2] + a[j3 - 2];
+        y2i = a[j1 - 1] + a[j3 - 1];
+        y3r = a[j1 - 2] - a[j3 - 2];
+        y3i = a[j1 - 1] - a[j3 - 1];
+        a[j0] = x0r + x2r;
+        a[j0 + 1] = x0i - x2i;
+        a[j0 - 2] = y0r + y2r;
+        a[j0 - 1] = y0i - y2i;
+        a[j1] = x0r - x2r;
+        a[j1 + 1] = x0i + x2i;
+        a[j1 - 2] = y0r - y2r;
+        a[j1 - 1] = y0i + y2i;
+        x0r = x1r + x3i;
+        x0i = x1i + x3r;
+        a[j2] = wk1i * x0r - wk1r * x0i;
+        a[j2 + 1] = wk1i * x0i + wk1r * x0r;
+        x0r = y1r + y3i;
+        x0i = y1i + y3r;
+        a[j2 - 2] = wd1i * x0r - wd1r * x0i;
+        a[j2 - 1] = wd1i * x0i + wd1r * x0r;
+        x0r = x1r - x3i;
+        x0i = x1i - x3r;
+        a[j3] = wk3i * x0r + wk3r * x0i;
+        a[j3 + 1] = wk3i * x0i - wk3r * x0r;
+        x0r = y1r - y3i;
+        x0i = y1i - y3r;
+        a[j3 - 2] = wd3i * x0r + wd3r * x0i;
+        a[j3 - 1] = wd3i * x0i - wd3r * x0r;
+    }
+    wk1r = csc1 * (wd1r + wn4r);
+    wk1i = csc1 * (wd1i + wn4r);
+    wk3r = csc3 * (wd3r - wn4r);
+    wk3i = csc3 * (wd3i - wn4r);
+    j0 = mh;
+    j1 = j0 + m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[j0 - 2] + a[j2 - 2];
+    x0i = -a[j0 - 1] - a[j2 - 1];
+    x1r = a[j0 - 2] - a[j2 - 2];
+    x1i = -a[j0 - 1] + a[j2 - 1];
+    x2r = a[j1 - 2] + a[j3 - 2];
+    x2i = a[j1 - 1] + a[j3 - 1];
+    x3r = a[j1 - 2] - a[j3 - 2];
+    x3i = a[j1 - 1] - a[j3 - 1];
+    a[j0 - 2] = x0r + x2r;
+    a[j0 - 1] = x0i - x2i;
+    a[j1 - 2] = x0r - x2r;
+    a[j1 - 1] = x0i + x2i;
+    x0r = x1r + x3i;
+    x0i = x1i + x3r;
+    a[j2 - 2] = wk1r * x0r - wk1i * x0i;
+    a[j2 - 1] = wk1r * x0i + wk1i * x0r;
+    x0r = x1r - x3i;
+    x0i = x1i - x3r;
+    a[j3 - 2] = wk3r * x0r + wk3i * x0i;
+    a[j3 - 1] = wk3r * x0i - wk3i * x0r;
+    x0r = a[j0] + a[j2];
+    x0i = -a[j0 + 1] - a[j2 + 1];
+    x1r = a[j0] - a[j2];
+    x1i = -a[j0 + 1] + a[j2 + 1];
+    x2r = a[j1] + a[j3];
+    x2i = a[j1 + 1] + a[j3 + 1];
+    x3r = a[j1] - a[j3];
+    x3i = a[j1 + 1] - a[j3 + 1];
+    a[j0] = x0r + x2r;
+    a[j0 + 1] = x0i - x2i;
+    a[j1] = x0r - x2r;
+    a[j1 + 1] = x0i + x2i;
+    x0r = x1r + x3i;
+    x0i = x1i + x3r;
+    a[j2] = wn4r * (x0r - x0i);
+    a[j2 + 1] = wn4r * (x0i + x0r);
+    x0r = x1r - x3i;
+    x0i = x1i - x3r;
+    a[j3] = -wn4r * (x0r + x0i);
+    a[j3 + 1] = -wn4r * (x0i - x0r);
+    x0r = a[j0 + 2] + a[j2 + 2];
+    x0i = -a[j0 + 3] - a[j2 + 3];
+    x1r = a[j0 + 2] - a[j2 + 2];
+    x1i = -a[j0 + 3] + a[j2 + 3];
+    x2r = a[j1 + 2] + a[j3 + 2];
+    x2i = a[j1 + 3] + a[j3 + 3];
+    x3r = a[j1 + 2] - a[j3 + 2];
+    x3i = a[j1 + 3] - a[j3 + 3];
+    a[j0 + 2] = x0r + x2r;
+    a[j0 + 3] = x0i - x2i;
+    a[j1 + 2] = x0r - x2r;
+    a[j1 + 3] = x0i + x2i;
+    x0r = x1r + x3i;
+    x0i = x1i + x3r;
+    a[j2 + 2] = wk1i * x0r - wk1r * x0i;
+    a[j2 + 3] = wk1i * x0i + wk1r * x0r;
+    x0r = x1r - x3i;
+    x0i = x1i - x3r;
+    a[j3 + 2] = wk3i * x0r + wk3r * x0i;
+    a[j3 + 3] = wk3i * x0i - wk3r * x0r;
+}
+
+
+#ifdef USE_CDFT_THREADS
+struct cdft_arg_st {
+    int n0;
+    int n;
+    double *a;
+    int nw;
+    double *w;
+};
+typedef struct cdft_arg_st cdft_arg_t;
+
+
+void cftrec4_th(int n, double *a, int nw, double *w)
+{
+    void *cftrec1_th(void *p);
+    void *cftrec2_th(void *p);
+    int i, idiv4, m, nthread;
+    cdft_thread_t th[4];
+    cdft_arg_t ag[4];
+    
+    nthread = 2;
+    idiv4 = 0;
+    m = n >> 1;
+    if (n > CDFT_4THREADS_BEGIN_N) {
+        nthread = 4;
+        idiv4 = 1;
+        m >>= 1;
+    }
+    for (i = 0; i < nthread; i++) {
+        ag[i].n0 = n;
+        ag[i].n = m;
+        ag[i].a = &a[i * m];
+        ag[i].nw = nw;
+        ag[i].w = w;
+        if (i != idiv4) {
+            cdft_thread_create(&th[i], cftrec1_th, &ag[i]);
+        } else {
+            cdft_thread_create(&th[i], cftrec2_th, &ag[i]);
+        }
+    }
+    for (i = 0; i < nthread; i++) {
+        cdft_thread_wait(th[i]);
+    }
+}
+
+
+void *cftrec1_th(void *p)
+{
+    int cfttree(int n, int j, int k, double *a, int nw, double *w);
+    void cftleaf(int n, int isplt, double *a, int nw, double *w);
+    void cftmdl1(int n, double *a, double *w);
+    int isplt, j, k, m, n, n0, nw;
+    double *a, *w;
+    
+    n0 = ((cdft_arg_t *) p)->n0;
+    n = ((cdft_arg_t *) p)->n;
+    a = ((cdft_arg_t *) p)->a;
+    nw = ((cdft_arg_t *) p)->nw;
+    w = ((cdft_arg_t *) p)->w;
+    m = n0;
+    while (m > 512) {
+        m >>= 2;
+        cftmdl1(m, &a[n - m], &w[nw - (m >> 1)]);
+    }
+    cftleaf(m, 1, &a[n - m], nw, w);
+    k = 0;
+    for (j = n - m; j > 0; j -= m) {
+        k++;
+        isplt = cfttree(m, j, k, a, nw, w);
+        cftleaf(m, isplt, &a[j - m], nw, w);
+    }
+    return (void *) 0;
+}
+
+
+void *cftrec2_th(void *p)
+{
+    int cfttree(int n, int j, int k, double *a, int nw, double *w);
+    void cftleaf(int n, int isplt, double *a, int nw, double *w);
+    void cftmdl2(int n, double *a, double *w);
+    int isplt, j, k, m, n, n0, nw;
+    double *a, *w;
+    
+    n0 = ((cdft_arg_t *) p)->n0;
+    n = ((cdft_arg_t *) p)->n;
+    a = ((cdft_arg_t *) p)->a;
+    nw = ((cdft_arg_t *) p)->nw;
+    w = ((cdft_arg_t *) p)->w;
+    k = 1;
+    m = n0;
+    while (m > 512) {
+        m >>= 2;
+        k <<= 2;
+        cftmdl2(m, &a[n - m], &w[nw - m]);
+    }
+    cftleaf(m, 0, &a[n - m], nw, w);
+    k >>= 1;
+    for (j = n - m; j > 0; j -= m) {
+        k++;
+        isplt = cfttree(m, j, k, a, nw, w);
+        cftleaf(m, isplt, &a[j - m], nw, w);
+    }
+    return (void *) 0;
+}
+#endif /* USE_CDFT_THREADS */
+
+
+void cftrec4(int n, double *a, int nw, double *w)
+{
+    int cfttree(int n, int j, int k, double *a, int nw, double *w);
+    void cftleaf(int n, int isplt, double *a, int nw, double *w);
+    void cftmdl1(int n, double *a, double *w);
+    int isplt, j, k, m;
+    
+    m = n;
+    while (m > 512) {
+        m >>= 2;
+        cftmdl1(m, &a[n - m], &w[nw - (m >> 1)]);
+    }
+    cftleaf(m, 1, &a[n - m], nw, w);
+    k = 0;
+    for (j = n - m; j > 0; j -= m) {
+        k++;
+        isplt = cfttree(m, j, k, a, nw, w);
+        cftleaf(m, isplt, &a[j - m], nw, w);
+    }
+}
+
+
+int cfttree(int n, int j, int k, double *a, int nw, double *w)
+{
+    void cftmdl1(int n, double *a, double *w);
+    void cftmdl2(int n, double *a, double *w);
+    int i, isplt, m;
+    
+    if ((k & 3) != 0) {
+        isplt = k & 1;
+        if (isplt != 0) {
+            cftmdl1(n, &a[j - n], &w[nw - (n >> 1)]);
+        } else {
+            cftmdl2(n, &a[j - n], &w[nw - n]);
+        }
+    } else {
+        m = n;
+        for (i = k; (i & 3) == 0; i >>= 2) {
+            m <<= 2;
+        }
+        isplt = i & 1;
+        if (isplt != 0) {
+            while (m > 128) {
+                cftmdl1(m, &a[j - m], &w[nw - (m >> 1)]);
+                m >>= 2;
+            }
+        } else {
+            while (m > 128) {
+                cftmdl2(m, &a[j - m], &w[nw - m]);
+                m >>= 2;
+            }
+        }
+    }
+    return isplt;
+}
+
+
+void cftleaf(int n, int isplt, double *a, int nw, double *w)
+{
+    void cftmdl1(int n, double *a, double *w);
+    void cftmdl2(int n, double *a, double *w);
+    void cftf161(double *a, double *w);
+    void cftf162(double *a, double *w);
+    void cftf081(double *a, double *w);
+    void cftf082(double *a, double *w);
+    
+    if (n == 512) {
+        cftmdl1(128, a, &w[nw - 64]);
+        cftf161(a, &w[nw - 8]);
+        cftf162(&a[32], &w[nw - 32]);
+        cftf161(&a[64], &w[nw - 8]);
+        cftf161(&a[96], &w[nw - 8]);
+        cftmdl2(128, &a[128], &w[nw - 128]);
+        cftf161(&a[128], &w[nw - 8]);
+        cftf162(&a[160], &w[nw - 32]);
+        cftf161(&a[192], &w[nw - 8]);
+        cftf162(&a[224], &w[nw - 32]);
+        cftmdl1(128, &a[256], &w[nw - 64]);
+        cftf161(&a[256], &w[nw - 8]);
+        cftf162(&a[288], &w[nw - 32]);
+        cftf161(&a[320], &w[nw - 8]);
+        cftf161(&a[352], &w[nw - 8]);
+        if (isplt != 0) {
+            cftmdl1(128, &a[384], &w[nw - 64]);
+            cftf161(&a[480], &w[nw - 8]);
+        } else {
+            cftmdl2(128, &a[384], &w[nw - 128]);
+            cftf162(&a[480], &w[nw - 32]);
+        }
+        cftf161(&a[384], &w[nw - 8]);
+        cftf162(&a[416], &w[nw - 32]);
+        cftf161(&a[448], &w[nw - 8]);
+    } else {
+        cftmdl1(64, a, &w[nw - 32]);
+        cftf081(a, &w[nw - 8]);
+        cftf082(&a[16], &w[nw - 8]);
+        cftf081(&a[32], &w[nw - 8]);
+        cftf081(&a[48], &w[nw - 8]);
+        cftmdl2(64, &a[64], &w[nw - 64]);
+        cftf081(&a[64], &w[nw - 8]);
+        cftf082(&a[80], &w[nw - 8]);
+        cftf081(&a[96], &w[nw - 8]);
+        cftf082(&a[112], &w[nw - 8]);
+        cftmdl1(64, &a[128], &w[nw - 32]);
+        cftf081(&a[128], &w[nw - 8]);
+        cftf082(&a[144], &w[nw - 8]);
+        cftf081(&a[160], &w[nw - 8]);
+        cftf081(&a[176], &w[nw - 8]);
+        if (isplt != 0) {
+            cftmdl1(64, &a[192], &w[nw - 32]);
+            cftf081(&a[240], &w[nw - 8]);
+        } else {
+            cftmdl2(64, &a[192], &w[nw - 64]);
+            cftf082(&a[240], &w[nw - 8]);
+        }
+        cftf081(&a[192], &w[nw - 8]);
+        cftf082(&a[208], &w[nw - 8]);
+        cftf081(&a[224], &w[nw - 8]);
+    }
+}
+
+
+void cftmdl1(int n, double *a, double *w)
+{
+    int j, j0, j1, j2, j3, k, m, mh;
+    double wn4r, wk1r, wk1i, wk3r, wk3i;
+    double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+    
+    mh = n >> 3;
+    m = 2 * mh;
+    j1 = m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[0] + a[j2];
+    x0i = a[1] + a[j2 + 1];
+    x1r = a[0] - a[j2];
+    x1i = a[1] - a[j2 + 1];
+    x2r = a[j1] + a[j3];
+    x2i = a[j1 + 1] + a[j3 + 1];
+    x3r = a[j1] - a[j3];
+    x3i = a[j1 + 1] - a[j3 + 1];
+    a[0] = x0r + x2r;
+    a[1] = x0i + x2i;
+    a[j1] = x0r - x2r;
+    a[j1 + 1] = x0i - x2i;
+    a[j2] = x1r - x3i;
+    a[j2 + 1] = x1i + x3r;
+    a[j3] = x1r + x3i;
+    a[j3 + 1] = x1i - x3r;
+    wn4r = w[1];
+    k = 0;
+    for (j = 2; j < mh; j += 2) {
+        k += 4;
+        wk1r = w[k];
+        wk1i = w[k + 1];
+        wk3r = w[k + 2];
+        wk3i = w[k + 3];
+        j1 = j + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j] + a[j2];
+        x0i = a[j + 1] + a[j2 + 1];
+        x1r = a[j] - a[j2];
+        x1i = a[j + 1] - a[j2 + 1];
+        x2r = a[j1] + a[j3];
+        x2i = a[j1 + 1] + a[j3 + 1];
+        x3r = a[j1] - a[j3];
+        x3i = a[j1 + 1] - a[j3 + 1];
+        a[j] = x0r + x2r;
+        a[j + 1] = x0i + x2i;
+        a[j1] = x0r - x2r;
+        a[j1 + 1] = x0i - x2i;
+        x0r = x1r - x3i;
+        x0i = x1i + x3r;
+        a[j2] = wk1r * x0r - wk1i * x0i;
+        a[j2 + 1] = wk1r * x0i + wk1i * x0r;
+        x0r = x1r + x3i;
+        x0i = x1i - x3r;
+        a[j3] = wk3r * x0r + wk3i * x0i;
+        a[j3 + 1] = wk3r * x0i - wk3i * x0r;
+        j0 = m - j;
+        j1 = j0 + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j0] + a[j2];
+        x0i = a[j0 + 1] + a[j2 + 1];
+        x1r = a[j0] - a[j2];
+        x1i = a[j0 + 1] - a[j2 + 1];
+        x2r = a[j1] + a[j3];
+        x2i = a[j1 + 1] + a[j3 + 1];
+        x3r = a[j1] - a[j3];
+        x3i = a[j1 + 1] - a[j3 + 1];
+        a[j0] = x0r + x2r;
+        a[j0 + 1] = x0i + x2i;
+        a[j1] = x0r - x2r;
+        a[j1 + 1] = x0i - x2i;
+        x0r = x1r - x3i;
+        x0i = x1i + x3r;
+        a[j2] = wk1i * x0r - wk1r * x0i;
+        a[j2 + 1] = wk1i * x0i + wk1r * x0r;
+        x0r = x1r + x3i;
+        x0i = x1i - x3r;
+        a[j3] = wk3i * x0r + wk3r * x0i;
+        a[j3 + 1] = wk3i * x0i - wk3r * x0r;
+    }
+    j0 = mh;
+    j1 = j0 + m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[j0] + a[j2];
+    x0i = a[j0 + 1] + a[j2 + 1];
+    x1r = a[j0] - a[j2];
+    x1i = a[j0 + 1] - a[j2 + 1];
+    x2r = a[j1] + a[j3];
+    x2i = a[j1 + 1] + a[j3 + 1];
+    x3r = a[j1] - a[j3];
+    x3i = a[j1 + 1] - a[j3 + 1];
+    a[j0] = x0r + x2r;
+    a[j0 + 1] = x0i + x2i;
+    a[j1] = x0r - x2r;
+    a[j1 + 1] = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    a[j2] = wn4r * (x0r - x0i);
+    a[j2 + 1] = wn4r * (x0i + x0r);
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    a[j3] = -wn4r * (x0r + x0i);
+    a[j3 + 1] = -wn4r * (x0i - x0r);
+}
+
+
+void cftmdl2(int n, double *a, double *w)
+{
+    int j, j0, j1, j2, j3, k, kr, m, mh;
+    double wn4r, wk1r, wk1i, wk3r, wk3i, wd1r, wd1i, wd3r, wd3i;
+    double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, y0r, y0i, y2r, y2i;
+    
+    mh = n >> 3;
+    m = 2 * mh;
+    wn4r = w[1];
+    j1 = m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[0] - a[j2 + 1];
+    x0i = a[1] + a[j2];
+    x1r = a[0] + a[j2 + 1];
+    x1i = a[1] - a[j2];
+    x2r = a[j1] - a[j3 + 1];
+    x2i = a[j1 + 1] + a[j3];
+    x3r = a[j1] + a[j3 + 1];
+    x3i = a[j1 + 1] - a[j3];
+    y0r = wn4r * (x2r - x2i);
+    y0i = wn4r * (x2i + x2r);
+    a[0] = x0r + y0r;
+    a[1] = x0i + y0i;
+    a[j1] = x0r - y0r;
+    a[j1 + 1] = x0i - y0i;
+    y0r = wn4r * (x3r - x3i);
+    y0i = wn4r * (x3i + x3r);
+    a[j2] = x1r - y0i;
+    a[j2 + 1] = x1i + y0r;
+    a[j3] = x1r + y0i;
+    a[j3 + 1] = x1i - y0r;
+    k = 0;
+    kr = 2 * m;
+    for (j = 2; j < mh; j += 2) {
+        k += 4;
+        wk1r = w[k];
+        wk1i = w[k + 1];
+        wk3r = w[k + 2];
+        wk3i = w[k + 3];
+        kr -= 4;
+        wd1i = w[kr];
+        wd1r = w[kr + 1];
+        wd3i = w[kr + 2];
+        wd3r = w[kr + 3];
+        j1 = j + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j] - a[j2 + 1];
+        x0i = a[j + 1] + a[j2];
+        x1r = a[j] + a[j2 + 1];
+        x1i = a[j + 1] - a[j2];
+        x2r = a[j1] - a[j3 + 1];
+        x2i = a[j1 + 1] + a[j3];
+        x3r = a[j1] + a[j3 + 1];
+        x3i = a[j1 + 1] - a[j3];
+        y0r = wk1r * x0r - wk1i * x0i;
+        y0i = wk1r * x0i + wk1i * x0r;
+        y2r = wd1r * x2r - wd1i * x2i;
+        y2i = wd1r * x2i + wd1i * x2r;
+        a[j] = y0r + y2r;
+        a[j + 1] = y0i + y2i;
+        a[j1] = y0r - y2r;
+        a[j1 + 1] = y0i - y2i;
+        y0r = wk3r * x1r + wk3i * x1i;
+        y0i = wk3r * x1i - wk3i * x1r;
+        y2r = wd3r * x3r + wd3i * x3i;
+        y2i = wd3r * x3i - wd3i * x3r;
+        a[j2] = y0r + y2r;
+        a[j2 + 1] = y0i + y2i;
+        a[j3] = y0r - y2r;
+        a[j3 + 1] = y0i - y2i;
+        j0 = m - j;
+        j1 = j0 + m;
+        j2 = j1 + m;
+        j3 = j2 + m;
+        x0r = a[j0] - a[j2 + 1];
+        x0i = a[j0 + 1] + a[j2];
+        x1r = a[j0] + a[j2 + 1];
+        x1i = a[j0 + 1] - a[j2];
+        x2r = a[j1] - a[j3 + 1];
+        x2i = a[j1 + 1] + a[j3];
+        x3r = a[j1] + a[j3 + 1];
+        x3i = a[j1 + 1] - a[j3];
+        y0r = wd1i * x0r - wd1r * x0i;
+        y0i = wd1i * x0i + wd1r * x0r;
+        y2r = wk1i * x2r - wk1r * x2i;
+        y2i = wk1i * x2i + wk1r * x2r;
+        a[j0] = y0r + y2r;
+        a[j0 + 1] = y0i + y2i;
+        a[j1] = y0r - y2r;
+        a[j1 + 1] = y0i - y2i;
+        y0r = wd3i * x1r + wd3r * x1i;
+        y0i = wd3i * x1i - wd3r * x1r;
+        y2r = wk3i * x3r + wk3r * x3i;
+        y2i = wk3i * x3i - wk3r * x3r;
+        a[j2] = y0r + y2r;
+        a[j2 + 1] = y0i + y2i;
+        a[j3] = y0r - y2r;
+        a[j3 + 1] = y0i - y2i;
+    }
+    wk1r = w[m];
+    wk1i = w[m + 1];
+    j0 = mh;
+    j1 = j0 + m;
+    j2 = j1 + m;
+    j3 = j2 + m;
+    x0r = a[j0] - a[j2 + 1];
+    x0i = a[j0 + 1] + a[j2];
+    x1r = a[j0] + a[j2 + 1];
+    x1i = a[j0 + 1] - a[j2];
+    x2r = a[j1] - a[j3 + 1];
+    x2i = a[j1 + 1] + a[j3];
+    x3r = a[j1] + a[j3 + 1];
+    x3i = a[j1 + 1] - a[j3];
+    y0r = wk1r * x0r - wk1i * x0i;
+    y0i = wk1r * x0i + wk1i * x0r;
+    y2r = wk1i * x2r - wk1r * x2i;
+    y2i = wk1i * x2i + wk1r * x2r;
+    a[j0] = y0r + y2r;
+    a[j0 + 1] = y0i + y2i;
+    a[j1] = y0r - y2r;
+    a[j1 + 1] = y0i - y2i;
+    y0r = wk1i * x1r - wk1r * x1i;
+    y0i = wk1i * x1i + wk1r * x1r;
+    y2r = wk1r * x3r - wk1i * x3i;
+    y2i = wk1r * x3i + wk1i * x3r;
+    a[j2] = y0r - y2r;
+    a[j2 + 1] = y0i - y2i;
+    a[j3] = y0r + y2r;
+    a[j3 + 1] = y0i + y2i;
+}
+
+
+void cftfx41(int n, double *a, int nw, double *w)
+{
+    void cftf161(double *a, double *w);
+    void cftf162(double *a, double *w);
+    void cftf081(double *a, double *w);
+    void cftf082(double *a, double *w);
+    
+    if (n == 128) {
+        cftf161(a, &w[nw - 8]);
+        cftf162(&a[32], &w[nw - 32]);
+        cftf161(&a[64], &w[nw - 8]);
+        cftf161(&a[96], &w[nw - 8]);
+    } else {
+        cftf081(a, &w[nw - 8]);
+        cftf082(&a[16], &w[nw - 8]);
+        cftf081(&a[32], &w[nw - 8]);
+        cftf081(&a[48], &w[nw - 8]);
+    }
+}
+
+
+void cftf161(double *a, double *w)
+{
+    double wn4r, wk1r, wk1i, 
+        x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, 
+        y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i, 
+        y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i, 
+        y8r, y8i, y9r, y9i, y10r, y10i, y11r, y11i, 
+        y12r, y12i, y13r, y13i, y14r, y14i, y15r, y15i;
+    
+    wn4r = w[1];
+    wk1r = w[2];
+    wk1i = w[3];
+    x0r = a[0] + a[16];
+    x0i = a[1] + a[17];
+    x1r = a[0] - a[16];
+    x1i = a[1] - a[17];
+    x2r = a[8] + a[24];
+    x2i = a[9] + a[25];
+    x3r = a[8] - a[24];
+    x3i = a[9] - a[25];
+    y0r = x0r + x2r;
+    y0i = x0i + x2i;
+    y4r = x0r - x2r;
+    y4i = x0i - x2i;
+    y8r = x1r - x3i;
+    y8i = x1i + x3r;
+    y12r = x1r + x3i;
+    y12i = x1i - x3r;
+    x0r = a[2] + a[18];
+    x0i = a[3] + a[19];
+    x1r = a[2] - a[18];
+    x1i = a[3] - a[19];
+    x2r = a[10] + a[26];
+    x2i = a[11] + a[27];
+    x3r = a[10] - a[26];
+    x3i = a[11] - a[27];
+    y1r = x0r + x2r;
+    y1i = x0i + x2i;
+    y5r = x0r - x2r;
+    y5i = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    y9r = wk1r * x0r - wk1i * x0i;
+    y9i = wk1r * x0i + wk1i * x0r;
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    y13r = wk1i * x0r - wk1r * x0i;
+    y13i = wk1i * x0i + wk1r * x0r;
+    x0r = a[4] + a[20];
+    x0i = a[5] + a[21];
+    x1r = a[4] - a[20];
+    x1i = a[5] - a[21];
+    x2r = a[12] + a[28];
+    x2i = a[13] + a[29];
+    x3r = a[12] - a[28];
+    x3i = a[13] - a[29];
+    y2r = x0r + x2r;
+    y2i = x0i + x2i;
+    y6r = x0r - x2r;
+    y6i = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    y10r = wn4r * (x0r - x0i);
+    y10i = wn4r * (x0i + x0r);
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    y14r = wn4r * (x0r + x0i);
+    y14i = wn4r * (x0i - x0r);
+    x0r = a[6] + a[22];
+    x0i = a[7] + a[23];
+    x1r = a[6] - a[22];
+    x1i = a[7] - a[23];
+    x2r = a[14] + a[30];
+    x2i = a[15] + a[31];
+    x3r = a[14] - a[30];
+    x3i = a[15] - a[31];
+    y3r = x0r + x2r;
+    y3i = x0i + x2i;
+    y7r = x0r - x2r;
+    y7i = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    y11r = wk1i * x0r - wk1r * x0i;
+    y11i = wk1i * x0i + wk1r * x0r;
+    x0r = x1r + x3i;
+    x0i = x1i - x3r;
+    y15r = wk1r * x0r - wk1i * x0i;
+    y15i = wk1r * x0i + wk1i * x0r;
+    x0r = y12r - y14r;
+    x0i = y12i - y14i;
+    x1r = y12r + y14r;
+    x1i = y12i + y14i;
+    x2r = y13r - y15r;
+    x2i = y13i - y15i;
+    x3r = y13r + y15r;
+    x3i = y13i + y15i;
+    a[24] = x0r + x2r;
+    a[25] = x0i + x2i;
+    a[26] = x0r - x2r;
+    a[27] = x0i - x2i;
+    a[28] = x1r - x3i;
+    a[29] = x1i + x3r;
+    a[30] = x1r + x3i;
+    a[31] = x1i - x3r;
+    x0r = y8r + y10r;
+    x0i = y8i + y10i;
+    x1r = y8r - y10r;
+    x1i = y8i - y10i;
+    x2r = y9r + y11r;
+    x2i = y9i + y11i;
+    x3r = y9r - y11r;
+    x3i = y9i - y11i;
+    a[16] = x0r + x2r;
+    a[17] = x0i + x2i;
+    a[18] = x0r - x2r;
+    a[19] = x0i - x2i;
+    a[20] = x1r - x3i;
+    a[21] = x1i + x3r;
+    a[22] = x1r + x3i;
+    a[23] = x1i - x3r;
+    x0r = y5r - y7i;
+    x0i = y5i + y7r;
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    x0r = y5r + y7i;
+    x0i = y5i - y7r;
+    x3r = wn4r * (x0r - x0i);
+    x3i = wn4r * (x0i + x0r);
+    x0r = y4r - y6i;
+    x0i = y4i + y6r;
+    x1r = y4r + y6i;
+    x1i = y4i - y6r;
+    a[8] = x0r + x2r;
+    a[9] = x0i + x2i;
+    a[10] = x0r - x2r;
+    a[11] = x0i - x2i;
+    a[12] = x1r - x3i;
+    a[13] = x1i + x3r;
+    a[14] = x1r + x3i;
+    a[15] = x1i - x3r;
+    x0r = y0r + y2r;
+    x0i = y0i + y2i;
+    x1r = y0r - y2r;
+    x1i = y0i - y2i;
+    x2r = y1r + y3r;
+    x2i = y1i + y3i;
+    x3r = y1r - y3r;
+    x3i = y1i - y3i;
+    a[0] = x0r + x2r;
+    a[1] = x0i + x2i;
+    a[2] = x0r - x2r;
+    a[3] = x0i - x2i;
+    a[4] = x1r - x3i;
+    a[5] = x1i + x3r;
+    a[6] = x1r + x3i;
+    a[7] = x1i - x3r;
+}
+
+
+void cftf162(double *a, double *w)
+{
+    double wn4r, wk1r, wk1i, wk2r, wk2i, wk3r, wk3i, 
+        x0r, x0i, x1r, x1i, x2r, x2i, 
+        y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i, 
+        y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i, 
+        y8r, y8i, y9r, y9i, y10r, y10i, y11r, y11i, 
+        y12r, y12i, y13r, y13i, y14r, y14i, y15r, y15i;
+    
+    wn4r = w[1];
+    wk1r = w[4];
+    wk1i = w[5];
+    wk3r = w[6];
+    wk3i = -w[7];
+    wk2r = w[8];
+    wk2i = w[9];
+    x1r = a[0] - a[17];
+    x1i = a[1] + a[16];
+    x0r = a[8] - a[25];
+    x0i = a[9] + a[24];
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    y0r = x1r + x2r;
+    y0i = x1i + x2i;
+    y4r = x1r - x2r;
+    y4i = x1i - x2i;
+    x1r = a[0] + a[17];
+    x1i = a[1] - a[16];
+    x0r = a[8] + a[25];
+    x0i = a[9] - a[24];
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    y8r = x1r - x2i;
+    y8i = x1i + x2r;
+    y12r = x1r + x2i;
+    y12i = x1i - x2r;
+    x0r = a[2] - a[19];
+    x0i = a[3] + a[18];
+    x1r = wk1r * x0r - wk1i * x0i;
+    x1i = wk1r * x0i + wk1i * x0r;
+    x0r = a[10] - a[27];
+    x0i = a[11] + a[26];
+    x2r = wk3i * x0r - wk3r * x0i;
+    x2i = wk3i * x0i + wk3r * x0r;
+    y1r = x1r + x2r;
+    y1i = x1i + x2i;
+    y5r = x1r - x2r;
+    y5i = x1i - x2i;
+    x0r = a[2] + a[19];
+    x0i = a[3] - a[18];
+    x1r = wk3r * x0r - wk3i * x0i;
+    x1i = wk3r * x0i + wk3i * x0r;
+    x0r = a[10] + a[27];
+    x0i = a[11] - a[26];
+    x2r = wk1r * x0r + wk1i * x0i;
+    x2i = wk1r * x0i - wk1i * x0r;
+    y9r = x1r - x2r;
+    y9i = x1i - x2i;
+    y13r = x1r + x2r;
+    y13i = x1i + x2i;
+    x0r = a[4] - a[21];
+    x0i = a[5] + a[20];
+    x1r = wk2r * x0r - wk2i * x0i;
+    x1i = wk2r * x0i + wk2i * x0r;
+    x0r = a[12] - a[29];
+    x0i = a[13] + a[28];
+    x2r = wk2i * x0r - wk2r * x0i;
+    x2i = wk2i * x0i + wk2r * x0r;
+    y2r = x1r + x2r;
+    y2i = x1i + x2i;
+    y6r = x1r - x2r;
+    y6i = x1i - x2i;
+    x0r = a[4] + a[21];
+    x0i = a[5] - a[20];
+    x1r = wk2i * x0r - wk2r * x0i;
+    x1i = wk2i * x0i + wk2r * x0r;
+    x0r = a[12] + a[29];
+    x0i = a[13] - a[28];
+    x2r = wk2r * x0r - wk2i * x0i;
+    x2i = wk2r * x0i + wk2i * x0r;
+    y10r = x1r - x2r;
+    y10i = x1i - x2i;
+    y14r = x1r + x2r;
+    y14i = x1i + x2i;
+    x0r = a[6] - a[23];
+    x0i = a[7] + a[22];
+    x1r = wk3r * x0r - wk3i * x0i;
+    x1i = wk3r * x0i + wk3i * x0r;
+    x0r = a[14] - a[31];
+    x0i = a[15] + a[30];
+    x2r = wk1i * x0r - wk1r * x0i;
+    x2i = wk1i * x0i + wk1r * x0r;
+    y3r = x1r + x2r;
+    y3i = x1i + x2i;
+    y7r = x1r - x2r;
+    y7i = x1i - x2i;
+    x0r = a[6] + a[23];
+    x0i = a[7] - a[22];
+    x1r = wk1i * x0r + wk1r * x0i;
+    x1i = wk1i * x0i - wk1r * x0r;
+    x0r = a[14] + a[31];
+    x0i = a[15] - a[30];
+    x2r = wk3i * x0r - wk3r * x0i;
+    x2i = wk3i * x0i + wk3r * x0r;
+    y11r = x1r + x2r;
+    y11i = x1i + x2i;
+    y15r = x1r - x2r;
+    y15i = x1i - x2i;
+    x1r = y0r + y2r;
+    x1i = y0i + y2i;
+    x2r = y1r + y3r;
+    x2i = y1i + y3i;
+    a[0] = x1r + x2r;
+    a[1] = x1i + x2i;
+    a[2] = x1r - x2r;
+    a[3] = x1i - x2i;
+    x1r = y0r - y2r;
+    x1i = y0i - y2i;
+    x2r = y1r - y3r;
+    x2i = y1i - y3i;
+    a[4] = x1r - x2i;
+    a[5] = x1i + x2r;
+    a[6] = x1r + x2i;
+    a[7] = x1i - x2r;
+    x1r = y4r - y6i;
+    x1i = y4i + y6r;
+    x0r = y5r - y7i;
+    x0i = y5i + y7r;
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    a[8] = x1r + x2r;
+    a[9] = x1i + x2i;
+    a[10] = x1r - x2r;
+    a[11] = x1i - x2i;
+    x1r = y4r + y6i;
+    x1i = y4i - y6r;
+    x0r = y5r + y7i;
+    x0i = y5i - y7r;
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    a[12] = x1r - x2i;
+    a[13] = x1i + x2r;
+    a[14] = x1r + x2i;
+    a[15] = x1i - x2r;
+    x1r = y8r + y10r;
+    x1i = y8i + y10i;
+    x2r = y9r - y11r;
+    x2i = y9i - y11i;
+    a[16] = x1r + x2r;
+    a[17] = x1i + x2i;
+    a[18] = x1r - x2r;
+    a[19] = x1i - x2i;
+    x1r = y8r - y10r;
+    x1i = y8i - y10i;
+    x2r = y9r + y11r;
+    x2i = y9i + y11i;
+    a[20] = x1r - x2i;
+    a[21] = x1i + x2r;
+    a[22] = x1r + x2i;
+    a[23] = x1i - x2r;
+    x1r = y12r - y14i;
+    x1i = y12i + y14r;
+    x0r = y13r + y15i;
+    x0i = y13i - y15r;
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    a[24] = x1r + x2r;
+    a[25] = x1i + x2i;
+    a[26] = x1r - x2r;
+    a[27] = x1i - x2i;
+    x1r = y12r + y14i;
+    x1i = y12i - y14r;
+    x0r = y13r - y15i;
+    x0i = y13i + y15r;
+    x2r = wn4r * (x0r - x0i);
+    x2i = wn4r * (x0i + x0r);
+    a[28] = x1r - x2i;
+    a[29] = x1i + x2r;
+    a[30] = x1r + x2i;
+    a[31] = x1i - x2r;
+}
+
+
+void cftf081(double *a, double *w)
+{
+    double wn4r, x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, 
+        y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i, 
+        y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i;
+    
+    wn4r = w[1];
+    x0r = a[0] + a[8];
+    x0i = a[1] + a[9];
+    x1r = a[0] - a[8];
+    x1i = a[1] - a[9];
+    x2r = a[4] + a[12];
+    x2i = a[5] + a[13];
+    x3r = a[4] - a[12];
+    x3i = a[5] - a[13];
+    y0r = x0r + x2r;
+    y0i = x0i + x2i;
+    y2r = x0r - x2r;
+    y2i = x0i - x2i;
+    y1r = x1r - x3i;
+    y1i = x1i + x3r;
+    y3r = x1r + x3i;
+    y3i = x1i - x3r;
+    x0r = a[2] + a[10];
+    x0i = a[3] + a[11];
+    x1r = a[2] - a[10];
+    x1i = a[3] - a[11];
+    x2r = a[6] + a[14];
+    x2i = a[7] + a[15];
+    x3r = a[6] - a[14];
+    x3i = a[7] - a[15];
+    y4r = x0r + x2r;
+    y4i = x0i + x2i;
+    y6r = x0r - x2r;
+    y6i = x0i - x2i;
+    x0r = x1r - x3i;
+    x0i = x1i + x3r;
+    x2r = x1r + x3i;
+    x2i = x1i - x3r;
+    y5r = wn4r * (x0r - x0i);
+    y5i = wn4r * (x0r + x0i);
+    y7r = wn4r * (x2r - x2i);
+    y7i = wn4r * (x2r + x2i);
+    a[8] = y1r + y5r;
+    a[9] = y1i + y5i;
+    a[10] = y1r - y5r;
+    a[11] = y1i - y5i;
+    a[12] = y3r - y7i;
+    a[13] = y3i + y7r;
+    a[14] = y3r + y7i;
+    a[15] = y3i - y7r;
+    a[0] = y0r + y4r;
+    a[1] = y0i + y4i;
+    a[2] = y0r - y4r;
+    a[3] = y0i - y4i;
+    a[4] = y2r - y6i;
+    a[5] = y2i + y6r;
+    a[6] = y2r + y6i;
+    a[7] = y2i - y6r;
+}
+
+
+void cftf082(double *a, double *w)
+{
+    double wn4r, wk1r, wk1i, x0r, x0i, x1r, x1i, 
+        y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i, 
+        y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i;
+    
+    wn4r = w[1];
+    wk1r = w[2];
+    wk1i = w[3];
+    y0r = a[0] - a[9];
+    y0i = a[1] + a[8];
+    y1r = a[0] + a[9];
+    y1i = a[1] - a[8];
+    x0r = a[4] - a[13];
+    x0i = a[5] + a[12];
+    y2r = wn4r * (x0r - x0i);
+    y2i = wn4r * (x0i + x0r);
+    x0r = a[4] + a[13];
+    x0i = a[5] - a[12];
+    y3r = wn4r * (x0r - x0i);
+    y3i = wn4r * (x0i + x0r);
+    x0r = a[2] - a[11];
+    x0i = a[3] + a[10];
+    y4r = wk1r * x0r - wk1i * x0i;
+    y4i = wk1r * x0i + wk1i * x0r;
+    x0r = a[2] + a[11];
+    x0i = a[3] - a[10];
+    y5r = wk1i * x0r - wk1r * x0i;
+    y5i = wk1i * x0i + wk1r * x0r;
+    x0r = a[6] - a[15];
+    x0i = a[7] + a[14];
+    y6r = wk1i * x0r - wk1r * x0i;
+    y6i = wk1i * x0i + wk1r * x0r;
+    x0r = a[6] + a[15];
+    x0i = a[7] - a[14];
+    y7r = wk1r * x0r - wk1i * x0i;
+    y7i = wk1r * x0i + wk1i * x0r;
+    x0r = y0r + y2r;
+    x0i = y0i + y2i;
+    x1r = y4r + y6r;
+    x1i = y4i + y6i;
+    a[0] = x0r + x1r;
+    a[1] = x0i + x1i;
+    a[2] = x0r - x1r;
+    a[3] = x0i - x1i;
+    x0r = y0r - y2r;
+    x0i = y0i - y2i;
+    x1r = y4r - y6r;
+    x1i = y4i - y6i;
+    a[4] = x0r - x1i;
+    a[5] = x0i + x1r;
+    a[6] = x0r + x1i;
+    a[7] = x0i - x1r;
+    x0r = y1r - y3i;
+    x0i = y1i + y3r;
+    x1r = y5r - y7r;
+    x1i = y5i - y7i;
+    a[8] = x0r + x1r;
+    a[9] = x0i + x1i;
+    a[10] = x0r - x1r;
+    a[11] = x0i - x1i;
+    x0r = y1r + y3i;
+    x0i = y1i - y3r;
+    x1r = y5r + y7r;
+    x1i = y5i + y7i;
+    a[12] = x0r - x1i;
+    a[13] = x0i + x1r;
+    a[14] = x0r + x1i;
+    a[15] = x0i - x1r;
+}
+
+
+void cftf040(double *a)
+{
+    double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+    
+    x0r = a[0] + a[4];
+    x0i = a[1] + a[5];
+    x1r = a[0] - a[4];
+    x1i = a[1] - a[5];
+    x2r = a[2] + a[6];
+    x2i = a[3] + a[7];
+    x3r = a[2] - a[6];
+    x3i = a[3] - a[7];
+    a[0] = x0r + x2r;
+    a[1] = x0i + x2i;
+    a[2] = x1r - x3i;
+    a[3] = x1i + x3r;
+    a[4] = x0r - x2r;
+    a[5] = x0i - x2i;
+    a[6] = x1r + x3i;
+    a[7] = x1i - x3r;
+}
+
+
+void cftb040(double *a)
+{
+    double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;
+    
+    x0r = a[0] + a[4];
+    x0i = a[1] + a[5];
+    x1r = a[0] - a[4];
+    x1i = a[1] - a[5];
+    x2r = a[2] + a[6];
+    x2i = a[3] + a[7];
+    x3r = a[2] - a[6];
+    x3i = a[3] - a[7];
+    a[0] = x0r + x2r;
+    a[1] = x0i + x2i;
+    a[2] = x1r + x3i;
+    a[3] = x1i - x3r;
+    a[4] = x0r - x2r;
+    a[5] = x0i - x2i;
+    a[6] = x1r - x3i;
+    a[7] = x1i + x3r;
+}
+
+
+void cftx020(double *a)
+{
+    double x0r, x0i;
+    
+    x0r = a[0] - a[2];
+    x0i = a[1] - a[3];
+    a[0] += a[2];
+    a[1] += a[3];
+    a[2] = x0r;
+    a[3] = x0i;
+}
+
+
+void rftfsub(int n, double *a, int nc, double *c)
+{
+    int j, k, kk, ks, m;
+    double wkr, wki, xr, xi, yr, yi;
+    
+    m = n >> 1;
+    ks = 2 * nc / m;
+    kk = 0;
+    for (j = 2; j < m; j += 2) {
+        k = n - j;
+        kk += ks;
+        wkr = 0.5 - c[nc - kk];
+        wki = c[kk];
+        xr = a[j] - a[k];
+        xi = a[j + 1] + a[k + 1];
+        yr = wkr * xr - wki * xi;
+        yi = wkr * xi + wki * xr;
+        a[j] -= yr;
+        a[j + 1] -= yi;
+        a[k] += yr;
+        a[k + 1] -= yi;
+    }
+}
+
+
+void rftbsub(int n, double *a, int nc, double *c)
+{
+    int j, k, kk, ks, m;
+    double wkr, wki, xr, xi, yr, yi;
+    
+    m = n >> 1;
+    ks = 2 * nc / m;
+    kk = 0;
+    for (j = 2; j < m; j += 2) {
+        k = n - j;
+        kk += ks;
+        wkr = 0.5 - c[nc - kk];
+        wki = c[kk];
+        xr = a[j] - a[k];
+        xi = a[j + 1] + a[k + 1];
+        yr = wkr * xr + wki * xi;
+        yi = wkr * xi - wki * xr;
+        a[j] -= yr;
+        a[j + 1] -= yi;
+        a[k] += yr;
+        a[k + 1] -= yi;
+    }
+}
+
+
+void dctsub(int n, double *a, int nc, double *c)
+{
+    int j, k, kk, ks, m;
+    double wkr, wki, xr;
+    
+    m = n >> 1;
+    ks = nc / n;
+    kk = 0;
+    for (j = 1; j < m; j++) {
+        k = n - j;
+        kk += ks;
+        wkr = c[kk] - c[nc - kk];
+        wki = c[kk] + c[nc - kk];
+        xr = wki * a[j] - wkr * a[k];
+        a[j] = wkr * a[j] + wki * a[k];
+        a[k] = xr;
+    }
+    a[m] *= c[0];
+}
+
+
+void dstsub(int n, double *a, int nc, double *c)
+{
+    int j, k, kk, ks, m;
+    double wkr, wki, xr;
+    
+    m = n >> 1;
+    ks = nc / n;
+    kk = 0;
+    for (j = 1; j < m; j++) {
+        k = n - j;
+        kk += ks;
+        wkr = c[kk] - c[nc - kk];
+        wki = c[kk] + c[nc - kk];
+        xr = wki * a[k] - wkr * a[j];
+        a[k] = wkr * a[k] + wki * a[j];
+        a[j] = xr;
+    }
+    a[m] *= c[0];
+}
+
+#if defined(__cplusplus)
+} // end of extern "C"
+#endif
diff --git a/src/loris/loris.h b/src/loris/loris.h
new file mode 100644
index 0000000..26d0d15
--- /dev/null
+++ b/src/loris/loris.h
@@ -0,0 +1,1020 @@
+#ifndef INCLUDE_LORIS_H
+#define INCLUDE_LORIS_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ *    loris.h
+ *
+ *    Header specifying C-linkable procedural interface for Loris. 
+ *
+ *    Main components of this interface:
+ *    - version identification symbols
+ *    - type declarations
+ *    - Analyzer configuration
+ *    - LinearEnvelope (formerly BreakpointEnvelope) operations
+ *    - PartialList operations
+ *    - Partial operations
+ *    - Breakpoint operations
+ *    - sound modeling functions for preparing PartialLists
+ *    - utility functions for manipulating PartialLists
+ *    - notification and exception handlers (all exceptions must be caught and
+ *        handled internally, clients can specify an exception handler and 
+ *        a notification function. The default one in Loris uses printf()).
+ *
+ *    loris.h is generated automatically from loris.h.in. Do not modify loris.h
+ *
+ * Kelly Fitz, 4 Feb 2002
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+ 
+/* ---------------------------------------------------------------- */
+/*      Version
+/*
+/*  Define symbols that facilitate version/release identification.
+ */
+ 
+#define LORIS_MAJOR_VERSION 1
+#define LORIS_MINOR_VERSION 8
+#define LORIS_SUBMINOR_VERSION 
+#define LORIS_VERSION_STR "Loris 1.8"
+
+/* ---------------------------------------------------------------- */
+/*      Types
+/*
+/* The (class) types Breakpoint, LinearEnvelope, Partial, 
+   and PartialList are imported from the Loris namespace.
+   The first three are classes, the latter is a typedef
+   for std::list< Loris::Partial >. 
+ */
+#if defined(__cplusplus)
+    //    include std library list header, declaring templates
+    //    is too painful and fragile:
+    #include <list>
+    
+    //    declare Loris classes in Loris namespace:
+    namespace Loris
+    {
+        class Breakpoint;
+        class LinearEnvelope;
+        class Partial;
+      
+        //    this typedef has to be copied from PartialList.h
+        typedef std::list< Loris::Partial > PartialList;
+    }
+   
+   // import those names into the global namespace
+   using Loris::Breakpoint;
+   using Loris::LinearEnvelope;
+   using Loris::Partial;
+   using Loris::PartialList;
+#else 
+    /* no classes, just declare types and use
+      opaque C pointers 
+    */
+    typedef struct Breakpoint Breakpoint;
+    typedef struct LinearEnvelope LinearEnvelope;
+    typedef struct PartialList PartialList;
+    typedef struct Partial Partial;
+#endif
+
+/*
+   TODO
+    Maybe should also have loris_label_t and loris_size_t
+    defined, depending on configure.
+*/
+
+#if defined(__cplusplus)
+    extern "C" {
+#endif
+
+/* ---------------------------------------------------------------- */
+/*      Analyzer configuration
+/*
+/*  An Analyzer represents a configuration of parameters for
+    performing Reassigned Bandwidth-Enhanced Additive Analysis
+    of sampled waveforms. This analysis process yields a collection 
+    of Partials, each having a trio of synchronous, non-uniformly-
+    sampled breakpoint envelopes representing the time-varying 
+    frequency, amplitude, and noisiness of a single bandwidth-
+    enhanced sinusoid. 
+
+    For more information about Reassigned Bandwidth-Enhanced 
+    Analysis and the Reassigned Bandwidth-Enhanced Additive Sound 
+    Model, refer to the Loris website: www.cerlsoundgroup.org/Loris/.
+    
+    In the procedural interface, there is only one Analyzer. 
+    It must be configured by calling analyzer_configure before
+    any of the other analyzer operations can be performed.
+ */
+
+void analyze( const double * buffer, unsigned int bufferSize, 
+              double srate, PartialList * partials );
+/*  Analyze an array of bufferSize (mono) samples at the given sample rate           
+    (in Hz) and append the extracted Partials to the given 
+    PartialList.                                                 
+ */
+                       
+void analyzer_configure( double resolution, double windowWidth );
+/*  Configure the sole Analyzer instance with the specified
+    frequency resolution (minimum instantaneous frequency    
+    difference between Partials). All other Analyzer parameters     
+    are computed from the specified frequency resolution. 
+   
+    Construct the Analyzer instance if necessary.
+   
+    In the procedural interface, there is only one Analyzer. 
+    It must be configured by calling analyzer_configure before
+    any of the other analyzer operations can be performed.   
+ */
+
+double analyzer_getAmpFloor( void );
+/*  Return the amplitude floor (lowest detected spectral amplitude),              
+    in (negative) dB, for the Loris Analyzer.                 
+ */
+
+double analyzer_getCropTime( void );
+/*  Return the crop time (maximum temporal displacement of a time-
+    frequency data point from the time-domain center of the analysis
+    window, beyond which data points are considered "unreliable")
+    for the Loris Analyzer.
+ */
+
+double analyzer_getFreqDrift( void );
+/*  Return the maximum allowable frequency difference between                     
+    consecutive Breakpoints in a Partial envelope for the Loris Analyzer.                 
+ */
+
+double analyzer_getFreqFloor( void );
+/*  Return the frequency floor (minimum instantaneous Partial                  
+    frequency), in Hz, for the Loris Analyzer.                 
+ */
+
+double analyzer_getFreqResolution( void );
+/*  Return the frequency resolution (minimum instantaneous frequency          
+    difference between Partials) for the Loris Analyzer.     
+ */
+
+double analyzer_getHopTime( void );
+/*  Return the hop time (which corresponds approximately to the 
+    average density of Partial envelope Breakpoint data) for this 
+    Analyzer.
+ */
+
+double analyzer_getSidelobeLevel( void );
+/*  Return the sidelobe attenutation level for the Kaiser analysis window in
+    positive dB. Higher numbers (e.g. 90) give very good sidelobe 
+    rejection but cause the window to be longer in time. Smaller 
+    numbers raise the level of the sidelobes, increasing the likelihood
+    of frequency-domain interference, but allow the window to be shorter
+    in time.
+ */
+
+double analyzer_getWindowWidth( void );
+/*  Return the frequency-domain main lobe width (measured between 
+    zero-crossings) of the analysis window used by the Loris Analyzer.                 
+ */
+
+void analyzer_setAmpFloor( double x );
+/*  Set the amplitude floor (lowest detected spectral amplitude), in              
+    (negative) dB, for the Loris Analyzer.                 
+ */
+
+void analyzer_setBwRegionWidth( double x );
+/*  Deprecated, use analyzer_storeResidueBandwidth instead.
+ */
+
+void analyzer_setCropTime( double x );
+/*  Set the crop time (maximum temporal displacement of a time-
+    frequency data point from the time-domain center of the analysis
+    window, beyond which data points are considered "unreliable")
+    for the Loris Analyzer.
+ */
+
+void analyzer_setFreqDrift( double x );
+/*  Set the maximum allowable frequency difference between                     
+    consecutive Breakpoints in a Partial envelope for the Loris Analyzer.                 
+ */
+
+void analyzer_setFreqFloor( double x );
+/*  Set the amplitude floor (minimum instantaneous Partial                  
+    frequency), in Hz, for the Loris Analyzer.
+ */
+
+void analyzer_setFreqResolution( double x );
+/*  Set the frequency resolution (minimum instantaneous frequency          
+    difference between Partials) for the Loris Analyzer. (Does not cause     
+    other parameters to be recomputed.)                                     
+ */
+
+void analyzer_setHopTime( double x );
+/*  Set the hop time (which corresponds approximately to the average
+    density of Partial envelope Breakpoint data) for the Loris Analyzer.
+ */
+
+void analyzer_setSidelobeLevel( double x );
+/*  Set the sidelobe attenutation level for the Kaiser analysis window in
+    positive dB. Larger numbers (e.g. 90) give very good sidelobe 
+    rejection but cause the window to be longer in time. Smaller 
+    numbers raise the level of the sidelobes, increasing the likelihood
+    of frequency-domain interference, but allow the window to be shorter
+    in time.
+ */
+
+void analyzer_setWindowWidth( double x );
+/*  Set the frequency-domain main lobe width (measured between 
+    zero-crossings) of the analysis window used by the Loris Analyzer.                 
+ */
+ 
+void analyzer_storeResidueBandwidth( double regionWidth );
+/*	Construct Partial bandwidth envelopes during analysis
+	by associating residual energy in the spectrum (after
+	peak extraction) with the selected spectral peaks that
+	are used to construct Partials. 
+	
+	regionWidth is the width (in Hz) of the bandwidth 
+	association regions used by this process, must be positive.
+ */
+ 
+void analyzer_storeConvergenceBandwidth( double tolerancePct );
+/*	Construct Partial bandwidth envelopes during analysis
+	by storing the mixed derivative of short-time phase, 
+	scaled and shifted so that a value of 0 corresponds
+	to a pure sinusoid, and a value of 1 corresponds to a
+	bandwidth-enhanced sinusoid with maximal energy spread
+	(minimum sinusoidal convergence).
+	
+	tolerance is the amount of range over which the 
+	mixed derivative indicator should be allowed to drift away 
+	from a pure sinusoid before saturating. This range is mapped
+	to bandwidth values on the range [0,1]. Must be positive and 
+	not greater than 1.
+ */
+
+void analyzer_storeNoBandwidth( void );
+/*	Disable bandwidth envelope construction. Bandwidth 
+	will be zero for all Breakpoints in all Partials.
+ */
+
+double analyzer_getBwRegionWidth( void );
+/*  Return the width (in Hz) of the Bandwidth Association regions
+	used by this Analyzer, only if the spectral residue method is
+	used to compute bandwidth envelopes. Return zero if the mixed
+	derivative method is used, or if no bandwidth is computed.
+ */
+
+double analyzer_getBwConvergenceTolerance( void );
+/*	Return the mixed derivative convergence tolerance
+	only if the convergence indicator is used to compute
+	bandwidth envelopes. Return zero if the spectral residue
+	method is used or if no bandwidth is computed.
+ */
+
+
+/* ---------------------------------------------------------------- */
+/*      LinearEnvelope object interface                                
+/*
+/*  A LinearEnvelope represents a linear segment breakpoint 
+    function with infinite extension at each end (that is, the 
+    values past either end of the breakpoint function have the 
+    values at the nearest end).
+
+    In C++, a LinearEnvelope is a Loris::LinearEnvelope.
+ */
+ 
+LinearEnvelope * createLinearEnvelope( void );
+/*  Construct and return a new LinearEnvelope having no 
+    breakpoints and an implicit value of 0. everywhere, 
+    until the first breakpoint is inserted.            
+ */
+
+LinearEnvelope * copyLinearEnvelope( const LinearEnvelope * ptr_this );
+/*  Construct and return a new LinearEnvelope that is an
+    exact copy of the specified LinearEnvelopes, having 
+    an identical set of breakpoints.    
+ */
+
+void destroyLinearEnvelope( LinearEnvelope * ptr_this );
+/*  Destroy this LinearEnvelope.                                 
+ */
+ 
+void linearEnvelope_insertBreakpoint( LinearEnvelope * ptr_this,
+                                      double time, double val );
+/*  Insert a breakpoint representing the specified (time, value) 
+    pair into this LinearEnvelope. If there is already a 
+    breakpoint at the specified time, it will be replaced with 
+    the new breakpoint.
+ */
+
+double linearEnvelope_valueAt( const LinearEnvelope * ptr_this, 
+                               double time );
+/*  Return the interpolated value of this LinearEnvelope at the 
+    specified time.                            
+ */
+
+/* ---------------------------------------------------------------- */
+/*      PartialList object interface
+/*
+/*  A PartialList represents a collection of Bandwidth-Enhanced 
+    Partials, each having a trio of synchronous, non-uniformly-
+    sampled breakpoint envelopes representing the time-varying 
+    frequency, amplitude, and noisiness of a single bandwidth-
+    enhanced sinusoid.
+
+    For more information about Bandwidth-Enhanced Partials and the  
+    Reassigned Bandwidth-Enhanced Additive Sound Model, refer to
+    the Loris website: www.cerlsoundgroup.org/Loris/.
+
+    In C++, a PartialList is a Loris::PartialList.
+ */ 
+PartialList * createPartialList( void );
+/*  Return a new empty PartialList.
+ */
+ 
+void destroyPartialList( PartialList * ptr_this );
+/*  Destroy this PartialList.
+ */
+ 
+void partialList_clear( PartialList * ptr_this );
+/*  Remove (and destroy) all the Partials from this PartialList,
+    leaving it empty.
+ */
+ 
+void partialList_copy( PartialList * ptr_this, 
+                       const PartialList * src );
+/*  Make this PartialList a copy of the source PartialList by making
+    copies of all of the Partials in the source and adding them to 
+    this PartialList.
+ */
+ 
+unsigned long partialList_size( const PartialList * ptr_this );
+/*  Return the number of Partials in this PartialList.
+ */
+ 
+void partialList_splice( PartialList * ptr_this, 
+                               PartialList * src );
+/*  Splice all the Partials in the source PartialList onto the end of
+    this PartialList, leaving the source empty.
+ */
+ 
+/* ---------------------------------------------------------------- */
+/*      Partial object interface
+/*
+/*  A Partial represents a single component in the
+    reassigned bandwidth-enhanced additive model. A Partial consists of a
+    chain of Breakpoints describing the time-varying frequency, amplitude,
+    and bandwidth (or noisiness) envelopes of the component, and a 4-byte
+    label. The Breakpoints are non-uniformly distributed in time. For more
+    information about Reassigned Bandwidth-Enhanced Analysis and the
+    Reassigned Bandwidth-Enhanced Additive Sound Model, refer to the Loris
+    website: www.cerlsoundgroup.org/Loris/.
+ */ 
+
+double partial_startTime( const Partial * p );
+/*  Return the start time (seconds) for the specified Partial.
+ */
+
+double partial_endTime( const Partial * p );
+/*  Return the end time (seconds) for the specified Partial.
+ */
+
+double partial_duration( const Partial * p );
+/*  Return the duration (seconds) for the specified Partial.
+ */
+
+double partial_initialPhase( const Partial * p );
+/*  Return the initial phase (radians) for the specified Partial.
+ */
+
+int partial_label( const Partial * p );
+/*  Return the integer label for the specified Partial.
+ */
+
+unsigned long partial_numBreakpoints( const Partial * p );
+/*  Return the number of Breakpoints in the specified Partial.
+ */
+
+double partial_frequencyAt( const Partial * p, double t );
+/*  Return the frequency (Hz) of the specified Partial interpolated
+    at a particular time. It is an error to apply this function to
+    a Partial having no Breakpoints.
+ */
+
+double partial_bandwidthAt( const Partial * p, double t );
+/*  Return the bandwidth of the specified Partial interpolated
+    at a particular time. It is an error to apply this function to
+    a Partial having no Breakpoints.
+ */
+
+double partial_phaseAt( const Partial * p, double t );
+/*  Return the phase (radians) of the specified Partial interpolated
+    at a particular time. It is an error to apply this function to
+    a Partial having no Breakpoints.
+ */
+
+double partial_amplitudeAt( const Partial * p, double t );
+/*  Return the (absolute) amplitude of the specified Partial interpolated
+    at a particular time. Partials are assumed to fade out
+    over 1 millisecond at the ends (rather than instantaneously).
+    It is an error to apply this function to a Partial having no Breakpoints.
+ */
+
+void partial_setLabel( Partial * p, int label );
+/*   Assign a new integer label to the specified Partial.
+ */
+
+/* ---------------------------------------------------------------- */
+/*      Breakpoint object interface
+/*
+/*  A Breakpoint represents a single breakpoint in the
+    Partial parameter (frequency, amplitude, bandwidth) envelope.
+    Instantaneous phase is also stored, but is only used at the onset of 
+    a partial, or when it makes a transition from zero to nonzero amplitude.
+    
+    Loris Partials represent reassigned bandwidth-enhanced model components.
+    A Partial consists of a chain of Breakpoints describing the time-varying
+    frequency, amplitude, and bandwidth (noisiness) of the component.
+    For more information about Reassigned Bandwidth-Enhanced 
+    Analysis and the Reassigned Bandwidth-Enhanced Additive Sound 
+    Model, refer to the Loris website: 
+    www.cerlsoundgroup.org/Loris/.
+ */ 
+
+double breakpoint_getAmplitude( const Breakpoint * bp );
+/*   Return the (absolute) amplitude of the specified Breakpoint.
+ */
+
+double breakpoint_getBandwidth( const Breakpoint * bp );
+/*  Return the bandwidth coefficient of the specified Breakpoint.
+ */
+
+double breakpoint_getFrequency( const Breakpoint * bp );
+/*  Return the frequency (Hz) of the specified Breakpoint.
+ */
+
+double breakpoint_getPhase( const Breakpoint * bp );
+/*  Return the phase (radians) of the specified Breakpoint.
+ */
+
+void breakpoint_setAmplitude( Breakpoint * bp, double a );
+/*   Assign a new (absolute) amplitude to the specified Breakpoint.
+ */
+
+void breakpoint_setBandwidth( Breakpoint * bp, double bw );
+/*  Assign a new bandwidth coefficient to the specified Breakpoint.
+ */
+
+void breakpoint_setFrequency( Breakpoint * bp, double f );
+/*  Assign a new frequency (Hz) to the specified Breakpoint.
+ */
+
+void breakpoint_setPhase( Breakpoint * bp, double phi );
+/*  Assign a new phase (radians) to the specified Breakpoint.
+ */
+
+/* ---------------------------------------------------------------- */
+/*      non-object-based procedures
+/*
+/*  Operations in Loris that need not be accessed though object
+    interfaces are represented as simple functions.
+ */
+
+void channelize( PartialList * partials, 
+                 LinearEnvelope * refFreqEnvelope, int refLabel );
+/*  Label Partials in a PartialList with the integer nearest to
+    the amplitude-weighted average ratio of their frequency envelope
+    to a reference frequency envelope. The frequency spectrum is 
+    partitioned into non-overlapping channels whose time-varying 
+    center frequencies track the reference frequency envelope. 
+    The reference label indicates which channel's center frequency
+    is exactly equal to the reference envelope frequency, and other
+    channels' center frequencies are multiples of the reference 
+    envelope frequency divided by the reference label. Each Partial 
+    in the PartialList is labeled with the number of the channel
+    that best fits its frequency envelope. The quality of the fit
+    is evaluated at the breakpoints in the Partial envelope and
+    weighted by the amplitude at each breakpoint, so that high-
+    amplitude breakpoints contribute more to the channel decision.
+    Partials are labeled, but otherwise unmodified. In particular, 
+    their frequencies are not modified in any way.
+ */
+
+void collate( PartialList * partials );
+/*  Collate unlabeled (zero-labeled) Partials into the smallest-possible 
+    number of Partials that does not combine any overlapping Partials.
+    Collated Partials appear at the end of the sequence, after all 
+    labeled Partials.
+ */
+
+LinearEnvelope * 
+createFreqReference( PartialList * partials, 
+                     double minFreq, double maxFreq, long numSamps );
+/*  Return a newly-constructed LinearEnvelope using the legacy 
+    FrequencyReference class. The envelope will have approximately
+    the specified number of samples. The specified number of samples 
+    must be greater than 1. Uses the FundamentalEstimator 
+    (FundamentalFromPartials) class to construct an estimator of 
+    fundamental frequency, configured to emulate the behavior of
+    the FrequencyReference class in Loris 1.4-1.5.2. If numSamps 
+    is zero, construct the reference envelope from fundamental 
+    estimates taken every five milliseconds.
+	
+	For simple sounds, this frequency reference may be a 
+	good first approximation to a reference envelope for
+	channelization (see channelize()).
+	
+	Clients are responsible for disposing of the newly-constructed 
+	LinearEnvelope.
+ */
+ 
+LinearEnvelope * 
+createF0Estimate( PartialList * partials, double minFreq, double maxFreq, 
+                  double interval );
+/* Return a newly-constructed LinearEnvelope that estimates
+   the time-varying fundamental frequency of the sound
+   represented by the Partials in a PartialList. This uses
+   the FundamentalEstimator (FundamentalFromPartials) 
+   class to construct an estimator of fundamental frequency, 
+   and returns a LinearEnvelope that samples the estimator at the 
+   specified time interval (in seconds). Default values are used 
+   to configure the estimator. Only estimates in the specified 
+   frequency range will be considered valid, estimates outside this 
+   range will be ignored.
+   
+   Clients are responsible for disposing of the newly-constructed 
+   LinearEnvelope.
+ */
+
+void dilate( PartialList * partials, 
+             const double * initial, const double * target, int npts );
+/*  Dilate Partials in a PartialList according to the given 
+    initial and target time points. Partial envelopes are 
+    stretched and compressed so that temporal features at
+    the initial time points are aligned with the final time
+    points. Time points are sorted, so Partial envelopes are 
+    are only stretched and compressed, but breakpoints are not
+    reordered. Duplicate time points are allowed. There must be
+    the same number of initial and target time points.
+ */
+
+void distill( PartialList * partials );
+/*  Distill labeled (channelized) Partials in a PartialList into a 
+    PartialList containing at most one Partial per label. Unlabeled 
+    (zero-labeled) Partials are left unmodified at the end of the 
+    distilled Partials.
+ */
+
+void exportAiff( const char * path, const double * buffer, 
+                 unsigned int bufferSize, double samplerate, int bitsPerSamp );
+/*  Export mono audio samples stored in an array of size bufferSize to 
+    an AIFF file having the specified sample rate at the given file path 
+    (or name). The floating point samples in the buffer are clamped to the 
+    range (-1.,1.) and converted to integers having bitsPerSamp bits.
+ */
+                 
+void exportSdif( const char * path, PartialList * partials );
+/*  Export Partials in a PartialList to a SDIF file at the specified
+    file path (or name). SDIF data is described by RBEM and RBEL 
+    matrices. 
+    For more information about SDIF, see the SDIF web site at:
+        www.ircam.fr/equipes/analyse-synthese/sdif/  
+ */
+                
+void exportSpc( const char * path, PartialList * partials, double midiPitch, 
+                int enhanced, double endApproachTime );
+/*  Export Partials in a PartialList to a Spc file at the specified file
+    path (or name). The fractional MIDI pitch must be specified. The 
+    enhanced parameter defaults to true (for bandwidth-enhanced spc files), 
+    but an be specified false for pure-sines spc files. The endApproachTime 
+    parameter is in seconds. A nonzero endApproachTime indicates that the plist does 
+    not include a release, but rather ends in a static spectrum corresponding 
+    to the final breakpoint values of the partials. The endApproachTime
+    specifies how long before the end of the sound the amplitude, frequency, 
+    and bandwidth values are to be modified to make a gradual transition to 
+    the static spectrum.
+ */
+
+/*  Apply a reference Partial to fix the frequencies of Breakpoints
+    whose amplitude is below threshold_dB. 0 harmonifies full-amplitude
+    Partials, to apply only to quiet Partials, specify a lower 
+    threshold like -90). The reference Partial is the first Partial
+    in the PartialList labeled refLabel (usually 1). The LinearEnvelope 
+    is a time-varying weighting on the harmonifing process. When 1, 
+    harmonic frequencies are used, when 0, breakpoint frequencies are 
+    unmodified. 
+ */
+void harmonify( PartialList * partials, long refLabel,
+                const LinearEnvelope * env, double threshold_dB );
+ 
+unsigned int importAiff( const char * path, double * buffer, unsigned int bufferSize, 
+                         double * samplerate );
+/*  Import audio samples stored in an AIFF file at the given file
+    path (or name). The samples are converted to floating point 
+    values on the range (-1.,1.) and stored in an array of doubles. 
+    The value returned is the number of samples in buffer, and it is at
+    most bufferSize. If samplerate is not a NULL pointer, 
+    then, on return, it points to the value of the sample rate (in
+    Hz) of the AIFF samples. The AIFF file must contain only a single
+    channel of audio data. The prior contents of buffer, if any, are 
+    overwritten.
+ */
+
+void importSdif( const char * path, PartialList * partials );
+/*  Import Partials from an SDIF file at the given file path (or 
+    name), and append them to a PartialList.
+ */    
+
+void importSpc( const char * path, PartialList * partials );
+/*  Import Partials from an Spc file at the given file path (or 
+    name), and return them in a PartialList.
+ */    
+
+void morph( const PartialList * src0, const PartialList * src1, 
+            const LinearEnvelope * ffreq, 
+            const LinearEnvelope * famp, 
+            const LinearEnvelope * fbw, 
+            PartialList * dst );
+/*  Morph labeled Partials in two PartialLists according to the
+    given frequency, amplitude, and bandwidth (noisiness) morphing
+    envelopes, and append the morphed Partials to the destination 
+    PartialList. Loris morphs Partials by interpolating frequency,
+    amplitude, and bandwidth envelopes of corresponding Partials in 
+    the source PartialLists. For more information about the Loris
+    morphing algorithm, see the Loris website: 
+    www.cerlsoundgroup.org/Loris/
+ */
+
+void morphWithReference( const PartialList * src0, 
+                         const PartialList * src1,
+                         long src0RefLabel, 
+                         long src1RefLabel,
+                         const LinearEnvelope * ffreq, 
+                         const LinearEnvelope * famp, 
+                         const LinearEnvelope * fbw, 
+                         PartialList * dst );
+/*	Morph labeled Partials in two PartialLists according to the
+	given frequency, amplitude, and bandwidth (noisiness) morphing
+	envelopes, and append the morphed Partials to the destination 
+	PartialList. Specify the labels of the Partials to be used as 
+	reference Partial for the two morph sources. The reference 
+	partial is used to compute frequencies for very low-amplitude 
+	Partials whose frequency estimates are not considered reliable. 
+	The reference Partial is considered to have good frequency 
+	estimates throughout. A reference label of 0 indicates that 
+	no reference Partial should be used for the corresponding
+	morph source.
+   
+	Loris morphs Partials by interpolating frequency,
+	amplitude, and bandwidth envelopes of corresponding Partials in 
+	the source PartialLists. For more information about the Loris
+	morphing algorithm, see the Loris website: 
+	www.cerlsoundgroup.org/Loris/
+ */
+ 
+void morpher_setAmplitudeShape( double shape );
+/* Set the shaping parameter for the amplitude morphing
+	function. This shaping parameter controls the slope of
+	the amplitude morphing function, for values greater than
+	1, this function gets nearly linear (like the old
+	amplitude morphing function), for values much less than
+	1 (e.g. 1E-5) the slope is gently curved and sounds
+	pretty "linear", for very small values (e.g. 1E-12) the
+	curve is very steep and sounds un-natural because of the
+	huge jump from zero amplitude to very small amplitude.
+	
+	Use LORIS_DEFAULT_AMPMORPHSHAPE to obtain the default
+	amplitude morphing shape for Loris, (equal to 1E-5,
+	which works well for many musical instrument morphs,
+	unless Loris was compiled with the symbol
+	LINEAR_AMP_MORPHS defined, in which case
+	LORIS_DEFAULT_AMPMORPHSHAPE is equal to
+	LORIS_LINEAR_AMPMORPHSHAPE).
+	
+	Use LORIS_LINEAR_AMPMORPHSHAPE to approximate the linear
+	amplitude morphs performed by older versions of Loris.
+	
+	The amplitude shape must be positive.
+ */
+ 
+extern const double LORIS_DEFAULT_AMPMORPHSHAPE;    
+extern const double LORIS_LINEAR_AMPMORPHSHAPE;
+
+void resample( PartialList * partials, double interval );
+/*  Resample all Partials in a PartialList using the specified
+    sampling interval, so that the Breakpoints in the Partial 
+    envelopes will all lie on a common temporal grid.
+    The Breakpoint times in resampled Partials will comprise a  
+    contiguous sequence of integer multiples of the sampling interval,
+    beginning with the multiple nearest to the Partial's start time and
+    ending with the multiple nearest to the Partial's end time. Resampling
+    is performed in-place. 
+
+ */
+
+void shapeSpectrum( PartialList * partials, PartialList * surface,
+                    double stretchFreq, double stretchTime );
+/*  Scale the amplitudes of a set of Partials by applying 
+    a spectral suface constructed from another set.
+    Stretch the spectral surface in time and frequency
+    using the specified stretch factors. Set the stretch
+    factors to one for no stretching.
+ */
+
+void sift( PartialList * partials );
+/*  Identify overlapping Partials having the same (nonzero)
+    label. If any two partials with same label
+    overlap in time, set the label of the weaker
+    (having less total energy) partial to zero.
+
+ */ 
+
+unsigned int 
+synthesize( const PartialList * partials,
+            double * buffer, unsigned int bufferSize,
+            double srate );
+/*  Synthesize Partials in a PartialList at the given sample
+    rate, and store the (floating point) samples in a buffer of
+    size bufferSize. The buffer is neither resized nor 
+    cleared before synthesis, so newly synthesized samples are
+    added to any previously computed samples in the buffer, and
+    samples beyond the end of the buffer are lost. Return the
+    number of samples synthesized, that is, the index of the
+    latest sample in the buffer that was modified.
+ */
+
+/* ---------------------------------------------------------------- */
+/*      utility functions
+/*
+/*  Operations for transforming and manipulating collections
+    of Partials.
+ */
+
+double avgAmplitude( const Partial * p );
+/*  Return the average amplitude over all Breakpoints in this Partial.
+    Return zero if the Partial has no Breakpoints.
+ */
+
+double avgFrequency( const Partial * p );
+/*  Return the average frequency over all Breakpoints in this Partial.
+    Return zero if the Partial has no Breakpoints.
+ */
+
+void copyIf( const PartialList * src, PartialList * dst, 
+             int ( * predicate )( const Partial * p, void * data ),
+             void * data );
+/*  Append copies of Partials in the source PartialList satisfying the
+    specified predicate to the destination PartialList. The source list
+    is unmodified. The data parameter can be used to 
+    supply extra user-defined data to the function. Pass 0 if no 
+    additional data is needed.
+ */
+             
+void copyLabeled( const PartialList * src, long label, PartialList * dst );
+/*  Append copies of Partials in the source PartialList having the
+    specified label to the destination PartialList. The source list
+    is unmodified.
+ */
+
+void crop( PartialList * partials, double t1, double t2 );
+/*  Trim Partials by removing Breakpoints outside a specified time span.
+    Insert a Breakpoint at the boundary when cropping occurs. Remove
+	any Partials that are left empty after cropping (Partials having no
+	Breakpoints between t1 and t2).
+ */
+
+void extractIf( PartialList * src, PartialList * dst, 
+                int ( * predicate )( const Partial * p, void * data ),
+                void * data );
+/*  Remove Partials in the source PartialList satisfying the
+    specified predicate from the source list and append them to
+    the destination PartialList. The data parameter can be used to 
+    supply extra user-defined data to the function. Pass 0 if no 
+    additional data is needed.
+ */
+
+void extractLabeled( PartialList * src, long label, PartialList * dst );
+/*  Remove Partials in the source PartialList having the specified
+    label from the source list and append them to the destination 
+    PartialList. 
+ */
+
+void fixPhaseAfter( PartialList * partials, double time );
+/*  Recompute phases of all Breakpoints later than the specified 
+    time so that the synthesized phases of those later Breakpoints 
+    matches the stored phase, as long as the synthesized phase at 
+    the specified time matches the stored (not recomputed) phase.
+    
+    Phase fixing is only applied to non-null (nonzero-amplitude) 
+    Breakpoints, because null Breakpoints are interpreted as phase 
+    reset points in Loris. If a null is encountered, its phase is 
+    corrected from its non-Null successor, if it has one, otherwise 
+    it is unmodified.
+ */
+
+void fixPhaseAt( PartialList * partials, double time );
+/*  Recompute phases of all Breakpoints in a Partial
+    so that the synthesized phases match the stored phases, 
+    and the synthesized phase at (nearest) the specified
+    time matches the stored (not recomputed) phase.
+    
+    Backward phase-fixing stops if a null (zero-amplitude) 
+    Breakpoint is encountered, because nulls are interpreted as 
+    phase reset points in Loris. If a null is encountered, the 
+    remainder of the Partial (the front part) is fixed in the 
+    forward direction, beginning at the start of the Partial. 
+    Forward phase fixing is only applied to non-null 
+    (nonzero-amplitude) Breakpoints. If a null is encountered, 
+    its phase is corrected from its non-Null successor, if 
+    it has one, otherwise it is unmodified.
+ */
+
+void fixPhaseBefore( PartialList * partials, double time );
+/*  Recompute phases of all Breakpoints earlier than the specified 
+    time so that the synthesized phases of those earlier Breakpoints 
+    matches the stored phase, and the synthesized phase at the 
+    specified time matches the stored (not recomputed) phase.
+
+    Backward phase-fixing stops if a null (zero-amplitude) Breakpoint
+    is encountered, because nulls are interpreted as phase reset 
+    points in Loris. If a null is encountered, the remainder of the 
+    Partial (the front part) is fixed in the forward direction, 
+    beginning at the start of the Partial.
+ */
+
+void fixPhaseBetween( PartialList * partials, double tbeg, double tend );
+/*
+    Fix the phase travel between two times by adjusting the
+    frequency and phase of Breakpoints between those two times.
+    
+    This algorithm assumes that there is nothing interesting 
+    about the phases of the intervening Breakpoints, and modifies 
+    their frequencies as little as possible to achieve the correct 
+    amount of phase travel such that the frequencies and phases at 
+    the specified times match the stored values. The phases of all 
+    the Breakpoints between the specified times are recomputed.
+ */
+
+void fixPhaseForward( PartialList * partials, double tbeg, double tend );
+/*  Recompute phases of all Breakpoints later than the specified 
+    time so that the synthesized phases of those later Breakpoints 
+    matches the stored phase, as long as the synthesized phase at 
+    the specified time matches the stored (not recomputed) phase. 
+    Breakpoints later than tend are unmodified.
+    
+    Phase fixing is only applied to non-null (nonzero-amplitude) 
+    Breakpoints, because null Breakpoints are interpreted as phase 
+    reset points in Loris. If a null is encountered, its phase is 
+    corrected from its non-Null successor, if it has one, otherwise 
+    it is unmodified.
+ */
+
+int forEachBreakpoint( Partial * p,
+                       int ( * func )( Breakpoint * p, double time, void * data ),
+                       void * data );
+/*  Apply a function to each Breakpoint in a Partial. The function
+    is called once for each Breakpoint in the source Partial. The
+    function may modify the Breakpoint (but should not otherwise attempt 
+    to modify the Partial). The data parameter can be used to supply extra
+    user-defined data to the function. Pass 0 if no additional data is needed.
+    The function should return 0 if successful. If the function returns
+    a non-zero value, then forEachBreakpoint immediately returns that value
+    without applying the function to any other Breakpoints in the Partial.
+    forEachBreakpoint returns zero if all calls to func return zero.
+ */
+                         
+int forEachPartial( PartialList * src,
+                    int ( * func )( Partial * p, void * data ),
+                    void * data );
+/*  Apply a function to each Partial in a PartialList. The function
+    is called once for each Partial in the source PartialList. The
+    function may modify the Partial (but should not attempt to modify
+    the PartialList). The data parameter can be used to supply extra
+    user-defined data to the function. Pass 0 if no additional data 
+    is needed. The function should return 0 if successful. If the 
+    function returns a non-zero value, then forEachPartial immediately 
+    returns that value without applying the function to any other 
+    Partials in the PartialList. forEachPartial returns zero if all 
+    calls to func return zero.
+ */
+
+double peakAmplitude( const Partial * p );
+/*  Return the maximum amplitude achieved by a Partial.
+ */
+
+void removeIf( PartialList * src, 
+               int ( * predicate )( const Partial * p, void * data ),
+               void * data );
+/*  Remove from a PartialList all Partials satisfying the
+    specified predicate. The data parameter can be used to 
+    supply extra user-defined data to the function. Pass 0 if no 
+    additional data is needed.
+ */
+
+void removeLabeled( PartialList * src, long label );
+/*  Remove from a PartialList all Partials having the specified label.
+ */
+
+void scaleAmplitude( PartialList * partials, LinearEnvelope * ampEnv );
+/*  Scale the amplitude of the Partials in a PartialList according 
+    to an envelope representing a time-varying amplitude scale value.
+ */
+
+void scaleAmp( PartialList * partials, LinearEnvelope * ampEnv );
+/*  Bad old name for scaleAmplitude.
+ */
+                 
+void scaleBandwidth( PartialList * partials, LinearEnvelope * bwEnv );
+/*  Scale the bandwidth of the Partials in a PartialList according 
+    to an envelope representing a time-varying bandwidth scale value.
+ */
+                 
+void scaleFrequency( PartialList * partials, LinearEnvelope * freqEnv );
+/*  Scale the frequency of the Partials in a PartialList according 
+    to an envelope representing a time-varying frequency scale value.
+ */
+                 
+void scaleNoiseRatio( PartialList * partials, LinearEnvelope * noiseEnv );
+/*  Scale the relative noise content of the Partials in a PartialList 
+    according to an envelope representing a (time-varying) noise energy 
+    scale value.
+ */
+
+void setBandwidth( PartialList * partials, LinearEnvelope * bwEnv );
+/*  Set the bandwidth of the Partials in a PartialList according 
+    to an envelope representing a time-varying bandwidth value.
+ */
+                 
+void shiftPitch( PartialList * partials, LinearEnvelope * pitchEnv );
+/*  Shift the pitch of all Partials in a PartialList according to 
+    the given pitch envelope. The pitch envelope is assumed to have 
+    units of cents (1/100 of a halfstep).
+ */
+
+void shiftTime( PartialList * partials, double offset );
+/*  Shift the time of all the Breakpoints in a Partial by a 
+    constant amount.
+ */
+
+void sortByLabel( PartialList * partials );
+/*  Sort the Partials in a PartialList in order of increasing label.
+    The sort is stable; Partials having the same label are not 
+    reordered.
+ */
+
+void timeSpan( PartialList * partials, double * tmin, double * tmax );
+/* Return the minimum start time and maximum end time
+   in seconds of all Partials in this PartialList. The v
+   times are returned in the (non-null) pointers tmin
+   and tmax.
+ */
+
+double weightedAvgFrequency( const Partial * p );
+/*  Return the average frequency over all Breakpoints in this Partial, 
+    weighted by the Breakpoint amplitudes. Return zero if the Partial 
+    has no Breakpoints.
+ */
+ 
+/* ---------------------------------------------------------------- */
+/*      Notification and exception handlers                            
+/*
+/*  An exception handler and a notifier may be specified. Both 
+    are functions taking a const char * argument and returning
+    void.
+ */
+
+void setExceptionHandler( void(*f)(const char *) );
+/*  Specify a function to call when reporting exceptions. The 
+    function takes a const char * argument, and returns void.
+ */
+
+void setNotifier( void(*f)(const char *) );
+/*  Specify a notification function. The function takes a 
+    const char * argument, and returns void.
+ */
+
+#if defined(__cplusplus)
+}    /* extern "C"     */
+#endif
+
+#endif    /* ndef INCLUDE_LORIS_H */
diff --git a/src/loris/loris.h.in b/src/loris/loris.h.in
new file mode 100644
index 0000000..9948da3
--- /dev/null
+++ b/src/loris/loris.h.in
@@ -0,0 +1,1020 @@
+#ifndef INCLUDE_LORIS_H
+#define INCLUDE_LORIS_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ *    loris.h
+ *
+ *    Header specifying C-linkable procedural interface for Loris. 
+ *
+ *    Main components of this interface:
+ *    - version identification symbols
+ *    - type declarations
+ *    - Analyzer configuration
+ *    - LinearEnvelope (formerly BreakpointEnvelope) operations
+ *    - PartialList operations
+ *    - Partial operations
+ *    - Breakpoint operations
+ *    - sound modeling functions for preparing PartialLists
+ *    - utility functions for manipulating PartialLists
+ *    - notification and exception handlers (all exceptions must be caught and
+ *        handled internally, clients can specify an exception handler and 
+ *        a notification function. The default one in Loris uses printf()).
+ *
+ *    loris.h is generated automatically from loris.h.in. Do not modify loris.h
+ *
+ * Kelly Fitz, 4 Feb 2002
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+ 
+/* ---------------------------------------------------------------- */
+/*      Version
+/*
+/*  Define symbols that facilitate version/release identification.
+ */
+ 
+#define LORIS_MAJOR_VERSION @LORIS_MAJOR_VERSION@
+#define LORIS_MINOR_VERSION @LORIS_MINOR_VERSION@
+#define LORIS_SUBMINOR_VERSION @LORIS_SUBMINOR_VERSION@
+#define LORIS_VERSION_STR "@LORIS_VERSION_STR@"
+
+/* ---------------------------------------------------------------- */
+/*      Types
+/*
+/* The (class) types Breakpoint, LinearEnvelope, Partial, 
+   and PartialList are imported from the Loris namespace.
+   The first three are classes, the latter is a typedef
+   for std::list< Loris::Partial >. 
+ */
+#if defined(__cplusplus)
+    //    include std library list header, declaring templates
+    //    is too painful and fragile:
+    #include <list>
+    
+    //    declare Loris classes in Loris namespace:
+    namespace Loris
+    {
+        class Breakpoint;
+        class LinearEnvelope;
+        class Partial;
+      
+        //    this typedef has to be copied from PartialList.h
+        typedef std::list< Loris::Partial > PartialList;
+    }
+   
+   // import those names into the global namespace
+   using Loris::Breakpoint;
+   using Loris::LinearEnvelope;
+   using Loris::Partial;
+   using Loris::PartialList;
+#else 
+    /* no classes, just declare types and use
+      opaque C pointers 
+    */
+    typedef struct Breakpoint Breakpoint;
+    typedef struct LinearEnvelope LinearEnvelope;
+    typedef struct PartialList PartialList;
+    typedef struct Partial Partial;
+#endif
+
+/*
+   TODO
+    Maybe should also have loris_label_t and loris_size_t
+    defined, depending on configure.
+*/
+
+#if defined(__cplusplus)
+    extern "C" {
+#endif
+
+/* ---------------------------------------------------------------- */
+/*      Analyzer configuration
+/*
+/*  An Analyzer represents a configuration of parameters for
+    performing Reassigned Bandwidth-Enhanced Additive Analysis
+    of sampled waveforms. This analysis process yields a collection 
+    of Partials, each having a trio of synchronous, non-uniformly-
+    sampled breakpoint envelopes representing the time-varying 
+    frequency, amplitude, and noisiness of a single bandwidth-
+    enhanced sinusoid. 
+
+    For more information about Reassigned Bandwidth-Enhanced 
+    Analysis and the Reassigned Bandwidth-Enhanced Additive Sound 
+    Model, refer to the Loris website: www.cerlsoundgroup.org/Loris/.
+    
+    In the procedural interface, there is only one Analyzer. 
+    It must be configured by calling analyzer_configure before
+    any of the other analyzer operations can be performed.
+ */
+
+void analyze( const double * buffer, unsigned int bufferSize, 
+              double srate, PartialList * partials );
+/*  Analyze an array of bufferSize (mono) samples at the given sample rate           
+    (in Hz) and append the extracted Partials to the given 
+    PartialList.                                                 
+ */
+                       
+void analyzer_configure( double resolution, double windowWidth );
+/*  Configure the sole Analyzer instance with the specified
+    frequency resolution (minimum instantaneous frequency    
+    difference between Partials). All other Analyzer parameters     
+    are computed from the specified frequency resolution. 
+   
+    Construct the Analyzer instance if necessary.
+   
+    In the procedural interface, there is only one Analyzer. 
+    It must be configured by calling analyzer_configure before
+    any of the other analyzer operations can be performed.   
+ */
+
+double analyzer_getAmpFloor( void );
+/*  Return the amplitude floor (lowest detected spectral amplitude),              
+    in (negative) dB, for the Loris Analyzer.                 
+ */
+
+double analyzer_getCropTime( void );
+/*  Return the crop time (maximum temporal displacement of a time-
+    frequency data point from the time-domain center of the analysis
+    window, beyond which data points are considered "unreliable")
+    for the Loris Analyzer.
+ */
+
+double analyzer_getFreqDrift( void );
+/*  Return the maximum allowable frequency difference between                     
+    consecutive Breakpoints in a Partial envelope for the Loris Analyzer.                 
+ */
+
+double analyzer_getFreqFloor( void );
+/*  Return the frequency floor (minimum instantaneous Partial                  
+    frequency), in Hz, for the Loris Analyzer.                 
+ */
+
+double analyzer_getFreqResolution( void );
+/*  Return the frequency resolution (minimum instantaneous frequency          
+    difference between Partials) for the Loris Analyzer.     
+ */
+
+double analyzer_getHopTime( void );
+/*  Return the hop time (which corresponds approximately to the 
+    average density of Partial envelope Breakpoint data) for this 
+    Analyzer.
+ */
+
+double analyzer_getSidelobeLevel( void );
+/*  Return the sidelobe attenutation level for the Kaiser analysis window in
+    positive dB. Higher numbers (e.g. 90) give very good sidelobe 
+    rejection but cause the window to be longer in time. Smaller 
+    numbers raise the level of the sidelobes, increasing the likelihood
+    of frequency-domain interference, but allow the window to be shorter
+    in time.
+ */
+
+double analyzer_getWindowWidth( void );
+/*  Return the frequency-domain main lobe width (measured between 
+    zero-crossings) of the analysis window used by the Loris Analyzer.                 
+ */
+
+void analyzer_setAmpFloor( double x );
+/*  Set the amplitude floor (lowest detected spectral amplitude), in              
+    (negative) dB, for the Loris Analyzer.                 
+ */
+
+void analyzer_setBwRegionWidth( double x );
+/*  Deprecated, use analyzer_storeResidueBandwidth instead.
+ */
+
+void analyzer_setCropTime( double x );
+/*  Set the crop time (maximum temporal displacement of a time-
+    frequency data point from the time-domain center of the analysis
+    window, beyond which data points are considered "unreliable")
+    for the Loris Analyzer.
+ */
+
+void analyzer_setFreqDrift( double x );
+/*  Set the maximum allowable frequency difference between                     
+    consecutive Breakpoints in a Partial envelope for the Loris Analyzer.                 
+ */
+
+void analyzer_setFreqFloor( double x );
+/*  Set the amplitude floor (minimum instantaneous Partial                  
+    frequency), in Hz, for the Loris Analyzer.
+ */
+
+void analyzer_setFreqResolution( double x );
+/*  Set the frequency resolution (minimum instantaneous frequency          
+    difference between Partials) for the Loris Analyzer. (Does not cause     
+    other parameters to be recomputed.)                                     
+ */
+
+void analyzer_setHopTime( double x );
+/*  Set the hop time (which corresponds approximately to the average
+    density of Partial envelope Breakpoint data) for the Loris Analyzer.
+ */
+
+void analyzer_setSidelobeLevel( double x );
+/*  Set the sidelobe attenutation level for the Kaiser analysis window in
+    positive dB. Larger numbers (e.g. 90) give very good sidelobe 
+    rejection but cause the window to be longer in time. Smaller 
+    numbers raise the level of the sidelobes, increasing the likelihood
+    of frequency-domain interference, but allow the window to be shorter
+    in time.
+ */
+
+void analyzer_setWindowWidth( double x );
+/*  Set the frequency-domain main lobe width (measured between 
+    zero-crossings) of the analysis window used by the Loris Analyzer.                 
+ */
+ 
+void analyzer_storeResidueBandwidth( double regionWidth );
+/*	Construct Partial bandwidth envelopes during analysis
+	by associating residual energy in the spectrum (after
+	peak extraction) with the selected spectral peaks that
+	are used to construct Partials. 
+	
+	regionWidth is the width (in Hz) of the bandwidth 
+	association regions used by this process, must be positive.
+ */
+ 
+void analyzer_storeConvergenceBandwidth( double tolerancePct );
+/*	Construct Partial bandwidth envelopes during analysis
+	by storing the mixed derivative of short-time phase, 
+	scaled and shifted so that a value of 0 corresponds
+	to a pure sinusoid, and a value of 1 corresponds to a
+	bandwidth-enhanced sinusoid with maximal energy spread
+	(minimum sinusoidal convergence).
+	
+	tolerance is the amount of range over which the 
+	mixed derivative indicator should be allowed to drift away 
+	from a pure sinusoid before saturating. This range is mapped
+	to bandwidth values on the range [0,1]. Must be positive and 
+	not greater than 1.
+ */
+
+void analyzer_storeNoBandwidth( void );
+/*	Disable bandwidth envelope construction. Bandwidth 
+	will be zero for all Breakpoints in all Partials.
+ */
+
+double analyzer_getBwRegionWidth( void );
+/*  Return the width (in Hz) of the Bandwidth Association regions
+	used by this Analyzer, only if the spectral residue method is
+	used to compute bandwidth envelopes. Return zero if the mixed
+	derivative method is used, or if no bandwidth is computed.
+ */
+
+double analyzer_getBwConvergenceTolerance( void );
+/*	Return the mixed derivative convergence tolerance
+	only if the convergence indicator is used to compute
+	bandwidth envelopes. Return zero if the spectral residue
+	method is used or if no bandwidth is computed.
+ */
+
+
+/* ---------------------------------------------------------------- */
+/*      LinearEnvelope object interface                                
+/*
+/*  A LinearEnvelope represents a linear segment breakpoint 
+    function with infinite extension at each end (that is, the 
+    values past either end of the breakpoint function have the 
+    values at the nearest end).
+
+    In C++, a LinearEnvelope is a Loris::LinearEnvelope.
+ */
+ 
+LinearEnvelope * createLinearEnvelope( void );
+/*  Construct and return a new LinearEnvelope having no 
+    breakpoints and an implicit value of 0. everywhere, 
+    until the first breakpoint is inserted.            
+ */
+
+LinearEnvelope * copyLinearEnvelope( const LinearEnvelope * ptr_this );
+/*  Construct and return a new LinearEnvelope that is an
+    exact copy of the specified LinearEnvelopes, having 
+    an identical set of breakpoints.    
+ */
+
+void destroyLinearEnvelope( LinearEnvelope * ptr_this );
+/*  Destroy this LinearEnvelope.                                 
+ */
+ 
+void linearEnvelope_insertBreakpoint( LinearEnvelope * ptr_this,
+                                      double time, double val );
+/*  Insert a breakpoint representing the specified (time, value) 
+    pair into this LinearEnvelope. If there is already a 
+    breakpoint at the specified time, it will be replaced with 
+    the new breakpoint.
+ */
+
+double linearEnvelope_valueAt( const LinearEnvelope * ptr_this, 
+                               double time );
+/*  Return the interpolated value of this LinearEnvelope at the 
+    specified time.                            
+ */
+
+/* ---------------------------------------------------------------- */
+/*      PartialList object interface
+/*
+/*  A PartialList represents a collection of Bandwidth-Enhanced 
+    Partials, each having a trio of synchronous, non-uniformly-
+    sampled breakpoint envelopes representing the time-varying 
+    frequency, amplitude, and noisiness of a single bandwidth-
+    enhanced sinusoid.
+
+    For more information about Bandwidth-Enhanced Partials and the  
+    Reassigned Bandwidth-Enhanced Additive Sound Model, refer to
+    the Loris website: www.cerlsoundgroup.org/Loris/.
+
+    In C++, a PartialList is a Loris::PartialList.
+ */ 
+PartialList * createPartialList( void );
+/*  Return a new empty PartialList.
+ */
+ 
+void destroyPartialList( PartialList * ptr_this );
+/*  Destroy this PartialList.
+ */
+ 
+void partialList_clear( PartialList * ptr_this );
+/*  Remove (and destroy) all the Partials from this PartialList,
+    leaving it empty.
+ */
+ 
+void partialList_copy( PartialList * ptr_this, 
+                       const PartialList * src );
+/*  Make this PartialList a copy of the source PartialList by making
+    copies of all of the Partials in the source and adding them to 
+    this PartialList.
+ */
+ 
+unsigned long partialList_size( const PartialList * ptr_this );
+/*  Return the number of Partials in this PartialList.
+ */
+ 
+void partialList_splice( PartialList * ptr_this, 
+                               PartialList * src );
+/*  Splice all the Partials in the source PartialList onto the end of
+    this PartialList, leaving the source empty.
+ */
+ 
+/* ---------------------------------------------------------------- */
+/*      Partial object interface
+/*
+/*  A Partial represents a single component in the
+    reassigned bandwidth-enhanced additive model. A Partial consists of a
+    chain of Breakpoints describing the time-varying frequency, amplitude,
+    and bandwidth (or noisiness) envelopes of the component, and a 4-byte
+    label. The Breakpoints are non-uniformly distributed in time. For more
+    information about Reassigned Bandwidth-Enhanced Analysis and the
+    Reassigned Bandwidth-Enhanced Additive Sound Model, refer to the Loris
+    website: www.cerlsoundgroup.org/Loris/.
+ */ 
+
+double partial_startTime( const Partial * p );
+/*  Return the start time (seconds) for the specified Partial.
+ */
+
+double partial_endTime( const Partial * p );
+/*  Return the end time (seconds) for the specified Partial.
+ */
+
+double partial_duration( const Partial * p );
+/*  Return the duration (seconds) for the specified Partial.
+ */
+
+double partial_initialPhase( const Partial * p );
+/*  Return the initial phase (radians) for the specified Partial.
+ */
+
+int partial_label( const Partial * p );
+/*  Return the integer label for the specified Partial.
+ */
+
+unsigned long partial_numBreakpoints( const Partial * p );
+/*  Return the number of Breakpoints in the specified Partial.
+ */
+
+double partial_frequencyAt( const Partial * p, double t );
+/*  Return the frequency (Hz) of the specified Partial interpolated
+    at a particular time. It is an error to apply this function to
+    a Partial having no Breakpoints.
+ */
+
+double partial_bandwidthAt( const Partial * p, double t );
+/*  Return the bandwidth of the specified Partial interpolated
+    at a particular time. It is an error to apply this function to
+    a Partial having no Breakpoints.
+ */
+
+double partial_phaseAt( const Partial * p, double t );
+/*  Return the phase (radians) of the specified Partial interpolated
+    at a particular time. It is an error to apply this function to
+    a Partial having no Breakpoints.
+ */
+
+double partial_amplitudeAt( const Partial * p, double t );
+/*  Return the (absolute) amplitude of the specified Partial interpolated
+    at a particular time. Partials are assumed to fade out
+    over 1 millisecond at the ends (rather than instantaneously).
+    It is an error to apply this function to a Partial having no Breakpoints.
+ */
+
+void partial_setLabel( Partial * p, int label );
+/*   Assign a new integer label to the specified Partial.
+ */
+
+/* ---------------------------------------------------------------- */
+/*      Breakpoint object interface
+/*
+/*  A Breakpoint represents a single breakpoint in the
+    Partial parameter (frequency, amplitude, bandwidth) envelope.
+    Instantaneous phase is also stored, but is only used at the onset of 
+    a partial, or when it makes a transition from zero to nonzero amplitude.
+    
+    Loris Partials represent reassigned bandwidth-enhanced model components.
+    A Partial consists of a chain of Breakpoints describing the time-varying
+    frequency, amplitude, and bandwidth (noisiness) of the component.
+    For more information about Reassigned Bandwidth-Enhanced 
+    Analysis and the Reassigned Bandwidth-Enhanced Additive Sound 
+    Model, refer to the Loris website: 
+    www.cerlsoundgroup.org/Loris/.
+ */ 
+
+double breakpoint_getAmplitude( const Breakpoint * bp );
+/*   Return the (absolute) amplitude of the specified Breakpoint.
+ */
+
+double breakpoint_getBandwidth( const Breakpoint * bp );
+/*  Return the bandwidth coefficient of the specified Breakpoint.
+ */
+
+double breakpoint_getFrequency( const Breakpoint * bp );
+/*  Return the frequency (Hz) of the specified Breakpoint.
+ */
+
+double breakpoint_getPhase( const Breakpoint * bp );
+/*  Return the phase (radians) of the specified Breakpoint.
+ */
+
+void breakpoint_setAmplitude( Breakpoint * bp, double a );
+/*   Assign a new (absolute) amplitude to the specified Breakpoint.
+ */
+
+void breakpoint_setBandwidth( Breakpoint * bp, double bw );
+/*  Assign a new bandwidth coefficient to the specified Breakpoint.
+ */
+
+void breakpoint_setFrequency( Breakpoint * bp, double f );
+/*  Assign a new frequency (Hz) to the specified Breakpoint.
+ */
+
+void breakpoint_setPhase( Breakpoint * bp, double phi );
+/*  Assign a new phase (radians) to the specified Breakpoint.
+ */
+
+/* ---------------------------------------------------------------- */
+/*      non-object-based procedures
+/*
+/*  Operations in Loris that need not be accessed though object
+    interfaces are represented as simple functions.
+ */
+
+void channelize( PartialList * partials, 
+                 LinearEnvelope * refFreqEnvelope, int refLabel );
+/*  Label Partials in a PartialList with the integer nearest to
+    the amplitude-weighted average ratio of their frequency envelope
+    to a reference frequency envelope. The frequency spectrum is 
+    partitioned into non-overlapping channels whose time-varying 
+    center frequencies track the reference frequency envelope. 
+    The reference label indicates which channel's center frequency
+    is exactly equal to the reference envelope frequency, and other
+    channels' center frequencies are multiples of the reference 
+    envelope frequency divided by the reference label. Each Partial 
+    in the PartialList is labeled with the number of the channel
+    that best fits its frequency envelope. The quality of the fit
+    is evaluated at the breakpoints in the Partial envelope and
+    weighted by the amplitude at each breakpoint, so that high-
+    amplitude breakpoints contribute more to the channel decision.
+    Partials are labeled, but otherwise unmodified. In particular, 
+    their frequencies are not modified in any way.
+ */
+
+void collate( PartialList * partials );
+/*  Collate unlabeled (zero-labeled) Partials into the smallest-possible 
+    number of Partials that does not combine any overlapping Partials.
+    Collated Partials appear at the end of the sequence, after all 
+    labeled Partials.
+ */
+
+LinearEnvelope * 
+createFreqReference( PartialList * partials, 
+                     double minFreq, double maxFreq, long numSamps );
+/*  Return a newly-constructed LinearEnvelope using the legacy 
+    FrequencyReference class. The envelope will have approximately
+    the specified number of samples. The specified number of samples 
+    must be greater than 1. Uses the FundamentalEstimator 
+    (FundamentalFromPartials) class to construct an estimator of 
+    fundamental frequency, configured to emulate the behavior of
+    the FrequencyReference class in Loris 1.4-1.5.2. If numSamps 
+    is zero, construct the reference envelope from fundamental 
+    estimates taken every five milliseconds.
+	
+	For simple sounds, this frequency reference may be a 
+	good first approximation to a reference envelope for
+	channelization (see channelize()).
+	
+	Clients are responsible for disposing of the newly-constructed 
+	LinearEnvelope.
+ */
+ 
+LinearEnvelope * 
+createF0Estimate( PartialList * partials, double minFreq, double maxFreq, 
+                  double interval );
+/* Return a newly-constructed LinearEnvelope that estimates
+   the time-varying fundamental frequency of the sound
+   represented by the Partials in a PartialList. This uses
+   the FundamentalEstimator (FundamentalFromPartials) 
+   class to construct an estimator of fundamental frequency, 
+   and returns a LinearEnvelope that samples the estimator at the 
+   specified time interval (in seconds). Default values are used 
+   to configure the estimator. Only estimates in the specified 
+   frequency range will be considered valid, estimates outside this 
+   range will be ignored.
+   
+   Clients are responsible for disposing of the newly-constructed 
+   LinearEnvelope.
+ */
+
+void dilate( PartialList * partials, 
+             const double * initial, const double * target, int npts );
+/*  Dilate Partials in a PartialList according to the given 
+    initial and target time points. Partial envelopes are 
+    stretched and compressed so that temporal features at
+    the initial time points are aligned with the final time
+    points. Time points are sorted, so Partial envelopes are 
+    are only stretched and compressed, but breakpoints are not
+    reordered. Duplicate time points are allowed. There must be
+    the same number of initial and target time points.
+ */
+
+void distill( PartialList * partials );
+/*  Distill labeled (channelized) Partials in a PartialList into a 
+    PartialList containing at most one Partial per label. Unlabeled 
+    (zero-labeled) Partials are left unmodified at the end of the 
+    distilled Partials.
+ */
+
+void exportAiff( const char * path, const double * buffer, 
+                 unsigned int bufferSize, double samplerate, int bitsPerSamp );
+/*  Export mono audio samples stored in an array of size bufferSize to 
+    an AIFF file having the specified sample rate at the given file path 
+    (or name). The floating point samples in the buffer are clamped to the 
+    range (-1.,1.) and converted to integers having bitsPerSamp bits.
+ */
+                 
+void exportSdif( const char * path, PartialList * partials );
+/*  Export Partials in a PartialList to a SDIF file at the specified
+    file path (or name). SDIF data is described by RBEM and RBEL 
+    matrices. 
+    For more information about SDIF, see the SDIF web site at:
+        www.ircam.fr/equipes/analyse-synthese/sdif/  
+ */
+                
+void exportSpc( const char * path, PartialList * partials, double midiPitch, 
+                int enhanced, double endApproachTime );
+/*  Export Partials in a PartialList to a Spc file at the specified file
+    path (or name). The fractional MIDI pitch must be specified. The 
+    enhanced parameter defaults to true (for bandwidth-enhanced spc files), 
+    but an be specified false for pure-sines spc files. The endApproachTime 
+    parameter is in seconds. A nonzero endApproachTime indicates that the plist does 
+    not include a release, but rather ends in a static spectrum corresponding 
+    to the final breakpoint values of the partials. The endApproachTime
+    specifies how long before the end of the sound the amplitude, frequency, 
+    and bandwidth values are to be modified to make a gradual transition to 
+    the static spectrum.
+ */
+
+/*  Apply a reference Partial to fix the frequencies of Breakpoints
+    whose amplitude is below threshold_dB. 0 harmonifies full-amplitude
+    Partials, to apply only to quiet Partials, specify a lower 
+    threshold like -90). The reference Partial is the first Partial
+    in the PartialList labeled refLabel (usually 1). The LinearEnvelope 
+    is a time-varying weighting on the harmonifing process. When 1, 
+    harmonic frequencies are used, when 0, breakpoint frequencies are 
+    unmodified. 
+ */
+void harmonify( PartialList * partials, long refLabel,
+                const LinearEnvelope * env, double threshold_dB );
+ 
+unsigned int importAiff( const char * path, double * buffer, unsigned int bufferSize, 
+                         double * samplerate );
+/*  Import audio samples stored in an AIFF file at the given file
+    path (or name). The samples are converted to floating point 
+    values on the range (-1.,1.) and stored in an array of doubles. 
+    The value returned is the number of samples in buffer, and it is at
+    most bufferSize. If samplerate is not a NULL pointer, 
+    then, on return, it points to the value of the sample rate (in
+    Hz) of the AIFF samples. The AIFF file must contain only a single
+    channel of audio data. The prior contents of buffer, if any, are 
+    overwritten.
+ */
+
+void importSdif( const char * path, PartialList * partials );
+/*  Import Partials from an SDIF file at the given file path (or 
+    name), and append them to a PartialList.
+ */    
+
+void importSpc( const char * path, PartialList * partials );
+/*  Import Partials from an Spc file at the given file path (or 
+    name), and return them in a PartialList.
+ */    
+
+void morph( const PartialList * src0, const PartialList * src1, 
+            const LinearEnvelope * ffreq, 
+            const LinearEnvelope * famp, 
+            const LinearEnvelope * fbw, 
+            PartialList * dst );
+/*  Morph labeled Partials in two PartialLists according to the
+    given frequency, amplitude, and bandwidth (noisiness) morphing
+    envelopes, and append the morphed Partials to the destination 
+    PartialList. Loris morphs Partials by interpolating frequency,
+    amplitude, and bandwidth envelopes of corresponding Partials in 
+    the source PartialLists. For more information about the Loris
+    morphing algorithm, see the Loris website: 
+    www.cerlsoundgroup.org/Loris/
+ */
+
+void morphWithReference( const PartialList * src0, 
+                         const PartialList * src1,
+                         long src0RefLabel, 
+                         long src1RefLabel,
+                         const LinearEnvelope * ffreq, 
+                         const LinearEnvelope * famp, 
+                         const LinearEnvelope * fbw, 
+                         PartialList * dst );
+/*	Morph labeled Partials in two PartialLists according to the
+	given frequency, amplitude, and bandwidth (noisiness) morphing
+	envelopes, and append the morphed Partials to the destination 
+	PartialList. Specify the labels of the Partials to be used as 
+	reference Partial for the two morph sources. The reference 
+	partial is used to compute frequencies for very low-amplitude 
+	Partials whose frequency estimates are not considered reliable. 
+	The reference Partial is considered to have good frequency 
+	estimates throughout. A reference label of 0 indicates that 
+	no reference Partial should be used for the corresponding
+	morph source.
+   
+	Loris morphs Partials by interpolating frequency,
+	amplitude, and bandwidth envelopes of corresponding Partials in 
+	the source PartialLists. For more information about the Loris
+	morphing algorithm, see the Loris website: 
+	www.cerlsoundgroup.org/Loris/
+ */
+ 
+void morpher_setAmplitudeShape( double shape );
+/* Set the shaping parameter for the amplitude morphing
+	function. This shaping parameter controls the slope of
+	the amplitude morphing function, for values greater than
+	1, this function gets nearly linear (like the old
+	amplitude morphing function), for values much less than
+	1 (e.g. 1E-5) the slope is gently curved and sounds
+	pretty "linear", for very small values (e.g. 1E-12) the
+	curve is very steep and sounds un-natural because of the
+	huge jump from zero amplitude to very small amplitude.
+	
+	Use LORIS_DEFAULT_AMPMORPHSHAPE to obtain the default
+	amplitude morphing shape for Loris, (equal to 1E-5,
+	which works well for many musical instrument morphs,
+	unless Loris was compiled with the symbol
+	LINEAR_AMP_MORPHS defined, in which case
+	LORIS_DEFAULT_AMPMORPHSHAPE is equal to
+	LORIS_LINEAR_AMPMORPHSHAPE).
+	
+	Use LORIS_LINEAR_AMPMORPHSHAPE to approximate the linear
+	amplitude morphs performed by older versions of Loris.
+	
+	The amplitude shape must be positive.
+ */
+ 
+extern const double LORIS_DEFAULT_AMPMORPHSHAPE;    
+extern const double LORIS_LINEAR_AMPMORPHSHAPE;
+
+void resample( PartialList * partials, double interval );
+/*  Resample all Partials in a PartialList using the specified
+    sampling interval, so that the Breakpoints in the Partial 
+    envelopes will all lie on a common temporal grid.
+    The Breakpoint times in resampled Partials will comprise a  
+    contiguous sequence of integer multiples of the sampling interval,
+    beginning with the multiple nearest to the Partial's start time and
+    ending with the multiple nearest to the Partial's end time. Resampling
+    is performed in-place. 
+
+ */
+
+void shapeSpectrum( PartialList * partials, PartialList * surface,
+                    double stretchFreq, double stretchTime );
+/*  Scale the amplitudes of a set of Partials by applying 
+    a spectral suface constructed from another set.
+    Stretch the spectral surface in time and frequency
+    using the specified stretch factors. Set the stretch
+    factors to one for no stretching.
+ */
+
+void sift( PartialList * partials );
+/*  Identify overlapping Partials having the same (nonzero)
+    label. If any two partials with same label
+    overlap in time, set the label of the weaker
+    (having less total energy) partial to zero.
+
+ */ 
+
+unsigned int 
+synthesize( const PartialList * partials,
+            double * buffer, unsigned int bufferSize,
+            double srate );
+/*  Synthesize Partials in a PartialList at the given sample
+    rate, and store the (floating point) samples in a buffer of
+    size bufferSize. The buffer is neither resized nor 
+    cleared before synthesis, so newly synthesized samples are
+    added to any previously computed samples in the buffer, and
+    samples beyond the end of the buffer are lost. Return the
+    number of samples synthesized, that is, the index of the
+    latest sample in the buffer that was modified.
+ */
+
+/* ---------------------------------------------------------------- */
+/*      utility functions
+/*
+/*  Operations for transforming and manipulating collections
+    of Partials.
+ */
+
+double avgAmplitude( const Partial * p );
+/*  Return the average amplitude over all Breakpoints in this Partial.
+    Return zero if the Partial has no Breakpoints.
+ */
+
+double avgFrequency( const Partial * p );
+/*  Return the average frequency over all Breakpoints in this Partial.
+    Return zero if the Partial has no Breakpoints.
+ */
+
+void copyIf( const PartialList * src, PartialList * dst, 
+             int ( * predicate )( const Partial * p, void * data ),
+             void * data );
+/*  Append copies of Partials in the source PartialList satisfying the
+    specified predicate to the destination PartialList. The source list
+    is unmodified. The data parameter can be used to 
+    supply extra user-defined data to the function. Pass 0 if no 
+    additional data is needed.
+ */
+             
+void copyLabeled( const PartialList * src, long label, PartialList * dst );
+/*  Append copies of Partials in the source PartialList having the
+    specified label to the destination PartialList. The source list
+    is unmodified.
+ */
+
+void crop( PartialList * partials, double t1, double t2 );
+/*  Trim Partials by removing Breakpoints outside a specified time span.
+    Insert a Breakpoint at the boundary when cropping occurs. Remove
+	any Partials that are left empty after cropping (Partials having no
+	Breakpoints between t1 and t2).
+ */
+
+void extractIf( PartialList * src, PartialList * dst, 
+                int ( * predicate )( const Partial * p, void * data ),
+                void * data );
+/*  Remove Partials in the source PartialList satisfying the
+    specified predicate from the source list and append them to
+    the destination PartialList. The data parameter can be used to 
+    supply extra user-defined data to the function. Pass 0 if no 
+    additional data is needed.
+ */
+
+void extractLabeled( PartialList * src, long label, PartialList * dst );
+/*  Remove Partials in the source PartialList having the specified
+    label from the source list and append them to the destination 
+    PartialList. 
+ */
+
+void fixPhaseAfter( PartialList * partials, double time );
+/*  Recompute phases of all Breakpoints later than the specified 
+    time so that the synthesized phases of those later Breakpoints 
+    matches the stored phase, as long as the synthesized phase at 
+    the specified time matches the stored (not recomputed) phase.
+    
+    Phase fixing is only applied to non-null (nonzero-amplitude) 
+    Breakpoints, because null Breakpoints are interpreted as phase 
+    reset points in Loris. If a null is encountered, its phase is 
+    corrected from its non-Null successor, if it has one, otherwise 
+    it is unmodified.
+ */
+
+void fixPhaseAt( PartialList * partials, double time );
+/*  Recompute phases of all Breakpoints in a Partial
+    so that the synthesized phases match the stored phases, 
+    and the synthesized phase at (nearest) the specified
+    time matches the stored (not recomputed) phase.
+    
+    Backward phase-fixing stops if a null (zero-amplitude) 
+    Breakpoint is encountered, because nulls are interpreted as 
+    phase reset points in Loris. If a null is encountered, the 
+    remainder of the Partial (the front part) is fixed in the 
+    forward direction, beginning at the start of the Partial. 
+    Forward phase fixing is only applied to non-null 
+    (nonzero-amplitude) Breakpoints. If a null is encountered, 
+    its phase is corrected from its non-Null successor, if 
+    it has one, otherwise it is unmodified.
+ */
+
+void fixPhaseBefore( PartialList * partials, double time );
+/*  Recompute phases of all Breakpoints earlier than the specified 
+    time so that the synthesized phases of those earlier Breakpoints 
+    matches the stored phase, and the synthesized phase at the 
+    specified time matches the stored (not recomputed) phase.
+
+    Backward phase-fixing stops if a null (zero-amplitude) Breakpoint
+    is encountered, because nulls are interpreted as phase reset 
+    points in Loris. If a null is encountered, the remainder of the 
+    Partial (the front part) is fixed in the forward direction, 
+    beginning at the start of the Partial.
+ */
+
+void fixPhaseBetween( PartialList * partials, double tbeg, double tend );
+/*
+    Fix the phase travel between two times by adjusting the
+    frequency and phase of Breakpoints between those two times.
+    
+    This algorithm assumes that there is nothing interesting 
+    about the phases of the intervening Breakpoints, and modifies 
+    their frequencies as little as possible to achieve the correct 
+    amount of phase travel such that the frequencies and phases at 
+    the specified times match the stored values. The phases of all 
+    the Breakpoints between the specified times are recomputed.
+ */
+
+void fixPhaseForward( PartialList * partials, double tbeg, double tend );
+/*  Recompute phases of all Breakpoints later than the specified 
+    time so that the synthesized phases of those later Breakpoints 
+    matches the stored phase, as long as the synthesized phase at 
+    the specified time matches the stored (not recomputed) phase. 
+    Breakpoints later than tend are unmodified.
+    
+    Phase fixing is only applied to non-null (nonzero-amplitude) 
+    Breakpoints, because null Breakpoints are interpreted as phase 
+    reset points in Loris. If a null is encountered, its phase is 
+    corrected from its non-Null successor, if it has one, otherwise 
+    it is unmodified.
+ */
+
+int forEachBreakpoint( Partial * p,
+                       int ( * func )( Breakpoint * p, double time, void * data ),
+                       void * data );
+/*  Apply a function to each Breakpoint in a Partial. The function
+    is called once for each Breakpoint in the source Partial. The
+    function may modify the Breakpoint (but should not otherwise attempt 
+    to modify the Partial). The data parameter can be used to supply extra
+    user-defined data to the function. Pass 0 if no additional data is needed.
+    The function should return 0 if successful. If the function returns
+    a non-zero value, then forEachBreakpoint immediately returns that value
+    without applying the function to any other Breakpoints in the Partial.
+    forEachBreakpoint returns zero if all calls to func return zero.
+ */
+                         
+int forEachPartial( PartialList * src,
+                    int ( * func )( Partial * p, void * data ),
+                    void * data );
+/*  Apply a function to each Partial in a PartialList. The function
+    is called once for each Partial in the source PartialList. The
+    function may modify the Partial (but should not attempt to modify
+    the PartialList). The data parameter can be used to supply extra
+    user-defined data to the function. Pass 0 if no additional data 
+    is needed. The function should return 0 if successful. If the 
+    function returns a non-zero value, then forEachPartial immediately 
+    returns that value without applying the function to any other 
+    Partials in the PartialList. forEachPartial returns zero if all 
+    calls to func return zero.
+ */
+
+double peakAmplitude( const Partial * p );
+/*  Return the maximum amplitude achieved by a Partial.
+ */
+
+void removeIf( PartialList * src, 
+               int ( * predicate )( const Partial * p, void * data ),
+               void * data );
+/*  Remove from a PartialList all Partials satisfying the
+    specified predicate. The data parameter can be used to 
+    supply extra user-defined data to the function. Pass 0 if no 
+    additional data is needed.
+ */
+
+void removeLabeled( PartialList * src, long label );
+/*  Remove from a PartialList all Partials having the specified label.
+ */
+
+void scaleAmplitude( PartialList * partials, LinearEnvelope * ampEnv );
+/*  Scale the amplitude of the Partials in a PartialList according 
+    to an envelope representing a time-varying amplitude scale value.
+ */
+
+void scaleAmp( PartialList * partials, LinearEnvelope * ampEnv );
+/*  Bad old name for scaleAmplitude.
+ */
+                 
+void scaleBandwidth( PartialList * partials, LinearEnvelope * bwEnv );
+/*  Scale the bandwidth of the Partials in a PartialList according 
+    to an envelope representing a time-varying bandwidth scale value.
+ */
+                 
+void scaleFrequency( PartialList * partials, LinearEnvelope * freqEnv );
+/*  Scale the frequency of the Partials in a PartialList according 
+    to an envelope representing a time-varying frequency scale value.
+ */
+                 
+void scaleNoiseRatio( PartialList * partials, LinearEnvelope * noiseEnv );
+/*  Scale the relative noise content of the Partials in a PartialList 
+    according to an envelope representing a (time-varying) noise energy 
+    scale value.
+ */
+
+void setBandwidth( PartialList * partials, LinearEnvelope * bwEnv );
+/*  Set the bandwidth of the Partials in a PartialList according 
+    to an envelope representing a time-varying bandwidth value.
+ */
+                 
+void shiftPitch( PartialList * partials, LinearEnvelope * pitchEnv );
+/*  Shift the pitch of all Partials in a PartialList according to 
+    the given pitch envelope. The pitch envelope is assumed to have 
+    units of cents (1/100 of a halfstep).
+ */
+
+void shiftTime( PartialList * partials, double offset );
+/*  Shift the time of all the Breakpoints in a Partial by a 
+    constant amount.
+ */
+
+void sortByLabel( PartialList * partials );
+/*  Sort the Partials in a PartialList in order of increasing label.
+    The sort is stable; Partials having the same label are not 
+    reordered.
+ */
+
+void timeSpan( PartialList * partials, double * tmin, double * tmax );
+/* Return the minimum start time and maximum end time
+   in seconds of all Partials in this PartialList. The v
+   times are returned in the (non-null) pointers tmin
+   and tmax.
+ */
+
+double weightedAvgFrequency( const Partial * p );
+/*  Return the average frequency over all Breakpoints in this Partial, 
+    weighted by the Breakpoint amplitudes. Return zero if the Partial 
+    has no Breakpoints.
+ */
+ 
+/* ---------------------------------------------------------------- */
+/*      Notification and exception handlers                            
+/*
+/*  An exception handler and a notifier may be specified. Both 
+    are functions taking a const char * argument and returning
+    void.
+ */
+
+void setExceptionHandler( void(*f)(const char *) );
+/*  Specify a function to call when reporting exceptions. The 
+    function takes a const char * argument, and returns void.
+ */
+
+void setNotifier( void(*f)(const char *) );
+/*  Specify a notification function. The function takes a 
+    const char * argument, and returns void.
+ */
+
+#if defined(__cplusplus)
+}    /* extern "C"     */
+#endif
+
+#endif    /* ndef INCLUDE_LORIS_H */
diff --git a/src/loris/lorisAnalyzer_pi.C b/src/loris/lorisAnalyzer_pi.C
new file mode 100644
index 0000000..9cafb05
--- /dev/null
+++ b/src/loris/lorisAnalyzer_pi.C
@@ -0,0 +1,1014 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ *	lorisAnalyzer_pi.C
+ *
+ *	A component of the C-linkable procedural interface for Loris. 
+ *
+ *	Main components of the Loris procedural interface:
+ *	- object interfaces - Analyzer, Synthesizer, Partial, PartialIterator, 
+ *		PartialList, PartialListIterator, Breakpoint, BreakpointEnvelope,  
+ *		and SampleVector need to be (opaque) objects in the interface, 
+ * 		either because they hold state (e.g. Analyzer) or because they are 
+ *		fundamental data types (e.g. Partial), so they need a procedural 
+ *		interface to their member functions. All these things need to be 
+ *		opaque pointers for the benefit of C.
+ *	- non-object-based procedures - other classes in Loris are not so stateful,
+ *		and have sufficiently narrow functionality that they need only 
+ *		procedures, and no object representation.
+ *	- utility functions - some procedures that are generally useful but are
+ *		not yet part of the Loris core are also defined.
+ *	- notification and exception handlers - all exceptions must be caught and
+ *		handled internally, clients can specify an exception handler and 
+ *		a notification function (the default one in Loris uses printf()).
+ *
+ *	This file contains the procedural interface for the Loris Analyzer class.
+ *
+ * Kelly Fitz, 10 Nov 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "loris.h"
+#include "lorisException_pi.h"
+
+#include "Analyzer.h"
+#include "Notifier.h"
+
+using namespace Loris;
+
+/* ---------------------------------------------------------------- */
+/*		Analyzer object interface
+/*
+/*	An Analyzer represents a configuration of parameters for
+	performing Reassigned Bandwidth-Enhanced Additive Analysis
+	of sampled waveforms. This analysis process yields a collection 
+	of Partials, each having a trio of synchronous, non-uniformly-
+	sampled breakpoint envelopes representing the time-varying 
+	frequency, amplitude, and noisiness of a single bandwidth-
+	enhanced sinusoid. 
+
+	For more information about Reassigned Bandwidth-Enhanced 
+	Analysis and the Reassigned Bandwidth-Enhanced Additive Sound 
+	Model, refer to the Loris website: www.cerlsoundgroup.org/Loris/.
+
+	In the procedural interface, there is only one Analyzer. 
+   It must be configured by calling analyzer_configure before
+   any of the other analyzer operations can be performed.
+ */
+static Analyzer * ptr_instance = 0;
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_configure
+/*
+/*	Configure the sole Analyzer instance with the specified
+	frequency resolution (minimum instantaneous frequency	
+	difference between Partials). All other Analyzer parameters 	
+	are computed from the specified frequency resolution. 
+   
+  	Construct the Analyzer instance if necessary.
+   
+	In the procedural interface, there is only one Analyzer. 
+   	It must be configured by calling analyzer_configure before
+   	any of the other analyzer operations can be performed.   
+ */
+extern "C"
+void analyzer_configure( double resolution, double windowWidth )
+{
+	try 
+	{
+      if ( 0 == ptr_instance )
+      {
+         debugger << "creating Analyzer" << endl;         
+         ptr_instance = new Analyzer( resolution, windowWidth );
+      }
+      else
+      {
+         debugger << "configuring Analyzer" << endl;         
+         ptr_instance->configure( resolution, windowWidth );
+      }
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in createAnalyzer(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in createAnalyzer(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyze        
+/*
+/*	Analyze an array of bufferSize (mono) samples at the given 
+	sample rate (in Hz) and append the extracted Partials to the 
+	given PartialList. 							
+   
+   	analyzer_configure must be called before any other analyzer 
+   	function.
+ */
+extern "C"
+void analyze( const double * buffer, unsigned int bufferSize, 
+              double srate, PartialList * partials )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try 
+	{
+		ThrowIfNull((double *) buffer);
+		ThrowIfNull((PartialList *) partials);
+		
+		//	perform analysis:
+		notifier << "analyzing " << bufferSize << " samples at " <<
+					srate << " Hz with frequency resolution " <<
+					ptr_instance->freqResolution() << endl;
+		if ( bufferSize > 0 )
+		{
+			ptr_instance->analyze( buffer, buffer + bufferSize, srate );
+		
+			//	splice the Partials into the destination list:
+			partials->splice( partials->end(), ptr_instance->partials() );
+		}
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in analyze(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in analyze(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_getFreqResolution        
+/*
+/*	Return the frequency resolution (minimum instantaneous frequency  		
+	difference between Partials) for this Analyzer. 	
+
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+double analyzer_getFreqResolution( void )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return 0;
+	}
+
+	try  
+	{
+		return ptr_instance->freqResolution();
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_getFreqResolution(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	{
+		std::string s("std C++ exception in analyzer_getFreqResolution(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_setFreqResolution        
+/*
+/*	Set the frequency resolution (minimum instantaneous frequency  		
+	difference between Partials) for this Analyzer. (Does not cause 	
+	other parameters to be recomputed.) 									
+
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+void analyzer_setFreqResolution( double x )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try  
+	{
+		ptr_instance->setFreqResolution( x );
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_setFreqResolution(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	{
+		std::string s("std C++ exception in analyzer_setFreqResolution(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_getAmpFloor        
+/*
+/*	Return the amplitude floor (lowest detected spectral amplitude),  			
+	in (negative) dB, for this Analyzer. 				
+
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+double analyzer_getAmpFloor( void )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return 0;
+	}
+
+	try  
+	{
+		return ptr_instance->ampFloor();
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_getAmpFloor(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	{
+		std::string s("std C++ exception in analyzer_getAmpFloor(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_setAmpFloor        
+/*
+/*	Set the amplitude floor (lowest detected spectral amplitude), in  			
+	(negative) dB, for this Analyzer. 				
+
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+void analyzer_setAmpFloor( double x )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try  
+	{
+		ptr_instance->setAmpFloor( x );
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_setAmpFloor(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	{
+		std::string s("std C++ exception in analyzer_setAmpFloor(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_getWindowWidth        
+/*
+/*	Return the frequency-domain main lobe width (measured between 
+	zero-crossings) of the analysis window used by this Analyzer. 				
+
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+double analyzer_getWindowWidth( void )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return 0;
+	}
+
+	try  
+	{
+		return ptr_instance->windowWidth();
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_getWindowWidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	{
+		std::string s("std C++ exception in analyzer_getWindowWidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_setWindowWidth        
+/*
+/*	Set the frequency-domain main lobe width (measured between 
+	zero-crossings) of the analysis window used by this Analyzer. 				
+
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+void analyzer_setWindowWidth( double x )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try  
+	{
+		ptr_instance->setWindowWidth( x );
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_setWindowWidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	{
+		std::string s("std C++ exception in analyzer_setWindowWidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_getSidelobeLevel        
+/*
+/*	Return the sidelobe attenutation level for the Kaiser analysis window in
+	negative dB. More negative numbers (e.g. -90) give very good sidelobe 
+	rejection but cause the window to be longer in time. Less negative 
+	numbers raise the level of the sidelobes, increasing the liklihood
+	of frequency-domain interference, but allow the window to be shorter
+	in time.
+
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+double analyzer_getSidelobeLevel( void )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return 0;
+	}
+
+	try  
+	{
+		return ptr_instance->sidelobeLevel();
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_getSidelobeLevel(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	{
+		std::string s("std C++ exception in analyzer_getSidelobeLevel(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_setSidelobeLevel        
+/*
+/*	Set the sidelobe attenutation level for the Kaiser analysis window in
+	negative dB. More negative numbers (e.g. -90) give very good sidelobe 
+	rejection but cause the window to be longer in time. Less negative 
+	numbers raise the level of the sidelobes, increasing the liklihood
+	of frequency-domain interference, but allow the window to be shorter
+	in time.
+
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+void analyzer_setSidelobeLevel( double x )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try  
+	{
+		ptr_instance->setSidelobeLevel( x );
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_setSidelobeLevel(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	{
+		std::string s("std C++ exception in analyzer_setSidelobeLevel(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_getFreqFloor        
+/*
+/*	Return the frequency floor (minimum instantaneous Partial  				
+	frequency), in Hz, for this Analyzer. 				
+   
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+double analyzer_getFreqFloor( void )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return 0;
+	}
+
+	try  
+	{
+      return ptr_instance->freqFloor();
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_getFreqFloor(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	{
+		std::string s("std C++ exception in analyzer_getFreqFloor(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_setFreqFloor        
+/*
+/*	Set the amplitude floor (minimum instantaneous Partial  				
+	frequency), in Hz, for this Analyzer.
+   
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+void analyzer_setFreqFloor( double x )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try  
+	{
+		ptr_instance->setFreqFloor( x );
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_setFreqFloor(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	{
+		std::string s("std C++ exception in analyzer_setFreqFloor(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_getFreqDrift        
+/*
+/*	Return the maximum allowable frequency difference between 					
+	consecutive Breakpoints in a Partial envelope for this Analyzer. 				
+   
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+double analyzer_getFreqDrift( void )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return 0;
+	}
+
+	try  
+	{
+		return ptr_instance->freqDrift();
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_getFreqDrift(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	{
+		std::string s("std C++ exception in analyzer_getFreqDrift(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_setFreqDrift        
+/*
+/*	Set the maximum allowable frequency difference between 					
+	consecutive Breakpoints in a Partial envelope for this Analyzer. 				
+   
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+void analyzer_setFreqDrift( double x )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try  
+	{
+		ptr_instance->setFreqDrift( x );
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_setFreqDrift(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	{
+		std::string s("std C++ exception in analyzer_setFreqDrift(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_getHopTime        
+/*
+/*	Return the hop time (which corresponds approximately to the 
+	average density of Partial envelope Breakpoint data) for this 
+	Analyzer.
+   
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+double analyzer_getHopTime( void )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return 0;
+	}
+
+	try  
+	{
+		return ptr_instance->hopTime();
+	}
+	catch( Exception & ex )  
+	{
+		std::string s("Loris exception in analyzer_getHopTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex )  
+	 
+	{
+		std::string s("std C++ exception in analyzer_getHopTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_setHopTime        
+/*
+/*	Set the hop time (which corresponds approximately to the average
+	density of Partial envelope Breakpoint data) for this Analyzer.
+   
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+void analyzer_setHopTime( double x )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try 
+	{
+		ptr_instance->setHopTime( x );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in analyzer_setHopTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in analyzer_setHopTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+/* ---------------------------------------------------------------- */
+/*        analyzer_getCropTime        
+/*
+/*	Return the crop time (maximum temporal displacement of a time-
+	frequency data point from the time-domain center of the analysis
+	window, beyond which data points are considered "unreliable")
+	for this Analyzer.
+   
+	analyzer_configure must be called before any other analyzer 
+	function.
+ */
+extern "C"
+double analyzer_getCropTime( void )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return 0;
+	}
+
+	try 
+	{
+		return ptr_instance->cropTime();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in analyzer_getCropTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in analyzer_getCropTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_setCropTime        
+/*
+/*	Set the crop time (maximum temporal displacement of a time-
+	frequency data point from the time-domain center of the analysis
+	window, beyond which data points are considered "unreliable")
+	for this Analyzer.
+   
+   	analyzer_configure must be called before any other analyzer 
+   	function.
+ */
+extern "C"
+void analyzer_setCropTime( double x )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try 
+	{
+		ptr_instance->setCropTime( x );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in analyzer_setCropTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in analyzer_setCropTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_getBwRegionWidth        
+/*
+/*	Return the width (in Hz) of the Bandwidth Association regions
+	used by this Analyzer.
+
+   	analyzer_configure must be called before any other analyzer 
+   	function.
+ */
+extern "C"
+double analyzer_getBwRegionWidth( void )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return 0;
+	}
+
+	try 
+	{
+		return ptr_instance->bwRegionWidth();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in analyzer_getBwRegionWidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in analyzer_getBwRegionWidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_setBwRegionWidth        
+/*
+/*	Set the width (in Hz) of the Bandwidth Association regions
+	used by this Analyzer.
+
+   	analyzer_configure must be called before any other analyzer 
+   	function.
+ */
+extern "C"
+void analyzer_setBwRegionWidth( double x )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try 
+	{
+		ptr_instance->setBwRegionWidth( x );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in analyzer_setBwRegionWidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in analyzer_setBwRegionWidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_storeResidueBandwidth
+/*
+/*	Construct Partial bandwidth envelopes during analysis
+	by associating residual energy in the spectrum (after
+	peak extraction) with the selected spectral peaks that
+	are used to construct Partials. 
+	
+	regionWidth is the width (in Hz) of the bandwidth 
+	association regions used by this process, must be positive.
+
+   	analyzer_configure must be called before any other analyzer 
+   	function.
+ */
+extern "C"
+void analyzer_storeResidueBandwidth( double regionWidth )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try 
+	{
+		ptr_instance->storeResidueBandwidth( regionWidth );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in analyzer_storeResidueBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in analyzer_storeResidueBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_storeConvergenceBandwidth
+/*
+/*	Construct Partial bandwidth envelopes during analysis
+	by storing the mixed derivative of short-time phase, 
+	scaled and shifted so that a value of 0 corresponds
+	to a pure sinusoid, and a value of 1 corresponds to a
+	bandwidth-enhanced sinusoid with maximal energy spread
+	(minimum sinusoidal convergence).
+	
+	tolerance is the amount of range over which the 
+	mixed derivative indicator should be allowed to drift away 
+	from a pure sinusoid before saturating. This range is mapped
+	to bandwidth values on the range [0,1]. Must be positive and 
+	not greater than 1.
+
+   	analyzer_configure must be called before any other analyzer 
+   	function.
+ */
+extern "C"
+void analyzer_storeConvergenceBandwidth( double tolerance )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try 
+	{
+		ptr_instance->storeConvergenceBandwidth( tolerance );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in analyzer_storeConvergenceBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in analyzer_storeConvergenceBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_storeNoBandwidth
+/*
+/*	Disable bandwidth envelope construction. Bandwidth 
+	will be zero for all Breakpoints in all Partials.
+
+   	analyzer_configure must be called before any other analyzer 
+   	function.
+ */
+extern "C"
+void analyzer_storeNoBandwidth( void )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return;
+	}
+
+	try 
+	{
+		ptr_instance->storeNoBandwidth();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in analyzer_storeNoBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in analyzer_storeNoBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        analyzer_getBwConvergenceTolerance
+/*
+/*	Return the mixed derivative convergence tolerance
+	only if the convergence indicator is used to compute
+	bandwidth envelopes. Return zero if the spectral residue
+	method is used or if no bandwidth is computed.
+ */
+extern "C"
+double analyzer_getBwConvergenceTolerance( void )
+{
+	if ( 0 == ptr_instance )
+	{
+		handleException( "analyzer_configure must be called before any other analyzer function." );
+		return 0;
+	}
+
+	try 
+	{
+		return ptr_instance->bwConvergenceTolerance();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in analyzer_getBwConvergenceTolerance(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in analyzer_getBwConvergenceTolerance(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+
+    return 0;
+}
+
+
+
+
+
diff --git a/src/loris/lorisBpEnvelope_pi.C b/src/loris/lorisBpEnvelope_pi.C
new file mode 100644
index 0000000..8015006
--- /dev/null
+++ b/src/loris/lorisBpEnvelope_pi.C
@@ -0,0 +1,224 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ *	lorisBpEnvelope_pi.C
+ *
+ *	A component of the C-linkable procedural interface for Loris. 
+ *
+ *    Main components of this interface:
+ *    - version identification symbols
+ *    - type declarations
+ *    - Analyzer configuration
+ *    - LinearEnvelope (formerly BreakpointEnvelope) operations
+ *    - PartialList operations
+ *    - Partial operations
+ *    - Breakpoint operations
+ *    - sound modeling functions for preparing PartialLists
+ *    - utility functions for manipulating PartialLists
+ *    - notification and exception handlers (all exceptions must be caught and
+ *        handled internally, clients can specify an exception handler and 
+ *        a notification function. The default one in Loris uses printf()).
+ *
+ *	This file defines the procedural interface for the Loris 
+ *	BreakpointEnvelope class.
+ *
+ * Kelly Fitz, 10 Nov 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "loris.h"
+#include "lorisException_pi.h"
+
+#include "LinearEnvelope.h"
+#include "Notifier.h"
+
+using namespace Loris;
+
+/* ---------------------------------------------------------------- */
+/*		LinearEnvelope object interface								
+/*
+/*	A LinearEnvelope represents a linear segment breakpoint 
+	function with infinite extension at each end (that is, the 
+	values past either end of the breakpoint function have the 
+	values at the nearest end).
+ */
+ 
+/* ---------------------------------------------------------------- */
+/*        createLinearEnvelope
+/*
+/*	Construct and return a new LinearEnvelope having no 
+	breakpoints and an implicit value of 0. everywhere, 
+	until the first breakpoint is inserted.			
+ */
+extern "C"
+LinearEnvelope * createLinearEnvelope( void )
+{
+	try 
+	{
+		debugger << "creating LinearEnvelope" << endl;
+		return new LinearEnvelope();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in createLinearEnvelope(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in createLinearEnvelope(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return NULL;
+}
+
+/* ---------------------------------------------------------------- */
+/*        copyLinearEnvelope
+/*
+/*	Construct and return a new LinearEnvelope that is an
+	exact copy of the specified LinearEnvelopes, having 
+	an identical set of breakpoints.	
+ */
+extern "C"
+LinearEnvelope * copyLinearEnvelope( const LinearEnvelope * ptr_this )
+{
+	try 
+	{
+		debugger << "copying LinearEnvelope" << endl;
+		return new LinearEnvelope( *ptr_this );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in copyLinearEnvelope(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in copyLinearEnvelope(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return NULL;
+}
+
+/* ---------------------------------------------------------------- */
+/*        destroyLinearEnvelope       
+/*
+/*	Destroy this LinearEnvelope. 								
+ */
+extern "C"
+void destroyLinearEnvelope( LinearEnvelope * ptr_this )
+{
+	try 
+	{
+		ThrowIfNull((LinearEnvelope *) ptr_this);
+		
+		debugger << "deleting LinearEnvelope" << endl;
+		delete ptr_this;
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in destroyLinearEnvelope(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in destroyLinearEnvelope(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        linearEnvelope_insertBreakpoint      
+/*
+/*	Insert a breakpoint representing the specified (time, value) 
+	pair into this LinearEnvelope. If there is already a 
+	breakpoint at the specified time, it will be replaced with 
+	the new breakpoint.
+ */
+extern "C"
+void linearEnvelope_insertBreakpoint( LinearEnvelope * ptr_this,
+                                      double time, double val )
+{
+	try 
+	{
+		ThrowIfNull((LinearEnvelope *) ptr_this);
+		
+		debugger << "inserting point (" << time << ", " << val 
+				   << ") into LinearEnvelope" << endl;
+		ptr_this->insertBreakpoint(time, val);
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in linearEnvelope_insertBreakpoint(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in linearEnvelope_insertBreakpoint(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        linearEnvelope_valueAt     
+/*
+/*	Return the interpolated value of this LinearEnvelope at the 
+	specified time.							
+ */
+extern "C"
+double linearEnvelope_valueAt( const LinearEnvelope * ptr_this, 
+                               double time )
+{
+	try 
+	{
+		ThrowIfNull((LinearEnvelope *) ptr_this);
+		return ptr_this->valueAt(time);
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in linearEnvelope_valueAt(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in linearEnvelope_valueAt(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return 0;
+}
+
diff --git a/src/loris/lorisException_pi.C b/src/loris/lorisException_pi.C
new file mode 100644
index 0000000..86a6398
--- /dev/null
+++ b/src/loris/lorisException_pi.C
@@ -0,0 +1,115 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ *	lorisException_pi.C
+ *
+ *	A component of the C-linkable procedural interface for Loris. 
+ *
+ *	Main components of the Loris procedural interface:
+ *	- object interfaces - Analyzer, Synthesizer, Partial, PartialIterator, 
+ *		PartialList, PartialListIterator, Breakpoint, BreakpointEnvelope,  
+ *		and SampleVector need to be (opaque) objects in the interface, 
+ * 		either because they hold state (e.g. Analyzer) or because they are 
+ *		fundamental data types (e.g. Partial), so they need a procedural 
+ *		interface to their member functions. All these things need to be 
+ *		opaque pointers for the benefit of C.
+ *	- non-object-based procedures - other classes in Loris are not so stateful,
+ *		and have sufficiently narrow functionality that they need only 
+ *		procedures, and no object representation.
+ *	- utility functions - some procedures that are generally useful but are
+ *		not yet part of the Loris core are also defined.
+ *	- notification and exception handlers - all exceptions must be caught and
+ *		handled internally, clients can specify an exception handler and 
+ *		a notification function (the default one in Loris uses printf()).
+ *
+ *	This file defines the exception and notification handling functions 
+ *	used in the Loris procedural interface.
+ *
+ * Kelly Fitz, 10 Nov 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "lorisException_pi.h"
+
+
+#include "loris.h"
+#include "Notifier.h"
+
+using namespace Loris;
+
+/* ---------------------------------------------------------------- */
+/*		notification and exception handlers							
+/*
+/*
+	An exception handler and a notifier may be specified. Both 
+	are functions taking a const char * argument and returning
+	void.
+ */
+
+/* ---------------------------------------------------------------- */
+/*        handleException        
+/*
+/*	Report exceptions thrown out of Loris. If no handler is 
+	specified, report them using Loris' notifier and return
+	without further incident.
+ */
+static void(*ex_handler)(const char *) = NULL;
+void handleException( const char * s )
+{
+	if ( ex_handler )
+		ex_handler( s );
+	else
+		notifier << s << endl;
+}
+
+/* ---------------------------------------------------------------- */
+/*        setExceptionHandler        
+/*
+/*	Specify a function to call when reporting exceptions. The 
+	function takes a const char * argument, and returns void.
+ */
+extern "C" 
+void setExceptionHandler( void(*f)(const char *) )
+{
+	ex_handler = f;
+}
+
+/* ---------------------------------------------------------------- */
+/*        setNotifier
+/*                                                                  */
+/*	Specify a notification function. The function takes a 
+	const char * argument, and returns void.
+ */
+extern "C" 
+void setNotifier( void(*f)(const char *) )
+{
+	//	these are guaranteed not to throw:
+	setNotifierHandler( f );
+	setDebuggerHandler( f );
+}
+
diff --git a/src/loris/lorisException_pi.h b/src/loris/lorisException_pi.h
new file mode 100644
index 0000000..8dddc2a
--- /dev/null
+++ b/src/loris/lorisException_pi.h
@@ -0,0 +1,77 @@
+#ifndef INCLUDE_LORISEXCEPTION_PI_H
+#define INCLUDE_LORISEXCEPTION_PI_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ *	lorisException_pi.h
+ *
+ *	A component of the C-linkable procedural interface for Loris. 
+ *
+ *	Main components of the Loris procedural interface:
+ *	- object interfaces - Analyzer, Synthesizer, Partial, PartialIterator, 
+ *		PartialList, PartialListIterator, Breakpoint, BreakpointEnvelope,  
+ *		and SampleVector need to be (opaque) objects in the interface, 
+ * 		either because they hold state (e.g. Analyzer) or because they are 
+ *		fundamental data types (e.g. Partial), so they need a procedural 
+ *		interface to their member functions. All these things need to be 
+ *		opaque pointers for the benefit of C.
+ *	- non-object-based procedures - other classes in Loris are not so stateful,
+ *		and have sufficiently narrow functionality that they need only 
+ *		procedures, and no object representation.
+ *	- utility functions - some procedures that are generally useful but are
+ *		not yet part of the Loris core are also defined.
+ *	- notification and exception handlers - all exceptions must be caught and
+ *		handled internally, clients can specify an exception handler and 
+ *		a notification function (the default one in Loris uses printf()).
+ *
+ *	This file declares the exception handling functions used in the
+ *	Loris procedural interface.
+ *
+ * Kelly Fitz, 10 Nov 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+ 
+#include "LorisExceptions.h"
+#include <string>
+
+//	forward-declare local exception handler:
+void handleException( const char * s );
+
+/* ---------------------------------------------------------------- */
+/*		class NullPointer
+/*
+/*	Exception subclass for catching NULL pointers:
+ */
+class NullPointer : public Loris::Exception
+{
+public: 
+	NullPointer( const std::string & str, const std::string & where = "" ) : 
+		Exception( std::string("NULL pointer exception -- ").append( str ), where ) {}
+};	//	end of class NullPointer
+
+#define ThrowIfNull(ptr) if ((ptr)==NULL) Throw( NullPointer, #ptr );	
+
+
+#endif	/* ndef INCLUDE_LORISEXCEPTION_PI_H */
diff --git a/src/loris/lorisNonObj_pi.C b/src/loris/lorisNonObj_pi.C
new file mode 100644
index 0000000..605d19c
--- /dev/null
+++ b/src/loris/lorisNonObj_pi.C
@@ -0,0 +1,1090 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ *	lorisNonObj_pi.C
+ *
+ *	A component of the C-linkable procedural interface for Loris. 
+ *
+ *    Main components of this interface:
+ *    - version identification symbols
+ *    - type declarations
+ *    - Analyzer configuration
+ *    - LinearEnvelope (formerly BreakpointEnvelope) operations
+ *    - PartialList operations
+ *    - Partial operations
+ *    - Breakpoint operations
+ *    - sound modeling functions for preparing PartialLists
+ *    - utility functions for manipulating PartialLists
+ *    - notification and exception handlers (all exceptions must be caught and
+ *        handled internally, clients can specify an exception handler and 
+ *        a notification function. The default one in Loris uses printf()).
+ *
+ *	This file defines the non-object-based component of the Loris
+ *	procedural interface.
+ *
+ * Kelly Fitz, 10 Nov 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "loris.h"
+#include "lorisException_pi.h"
+
+#include "AiffFile.h"
+#include "Analyzer.h"
+#include "BreakpointEnvelope.h"
+#include "Channelizer.h"
+#include "Collator.h"
+#include "Dilator.h"
+#include "Distiller.h"
+#include "LorisExceptions.h"
+#include "FrequencyReference.h"
+#include "Fundamental.h"
+#include "Harmonifier.h"
+#include "ImportLemur.h"
+#include "Morpher.h"
+#include "Notifier.h"
+#include "Partial.h"
+#include "PartialUtils.h"
+#include "Resampler.h"
+#include "SdifFile.h"
+#include "Sieve.h"
+#include "SpcFile.h"
+#include "SpectralSurface.h"
+#include "Synthesizer.h"
+
+#include <cmath>
+#include <functional>
+#include <list>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <fstream>
+#include <set>
+
+
+using namespace Loris;
+
+/* ---------------------------------------------------------------- */
+/*		non-object-based procedures
+/*
+/*	Operations in Loris that need not be accessed though object
+	interfaces are represented as simple functions.
+ */
+
+/* ---------------------------------------------------------------- */
+/*        channelize        
+/*
+/*	Label Partials in a PartialList with the integer nearest to
+	the amplitude-weighted average ratio of their frequency envelope
+	to a reference frequency envelope. The frequency spectrum is 
+	partitioned into non-overlapping channels whose time-varying 
+	center frequencies track the reference frequency envelope. 
+	The reference label indicates which channel's center frequency
+	is exactly equal to the reference envelope frequency, and other
+	channels' center frequencies are multiples of the reference 
+	envelope frequency divided by the reference label. Each Partial 
+	in the PartialList is labeled with the number of the channel
+	that best fits its frequency envelope. The quality of the fit
+	is evaluated at the breakpoints in the Partial envelope and
+	weighted by the amplitude at each breakpoint, so that high-
+	amplitude breakpoints contribute more to the channel decision.
+	Partials are labeled, but otherwise unmodified. In particular, 
+	their frequencies are not modified in any way.
+ */
+extern "C"
+void channelize( PartialList * partials, 
+				 LinearEnvelope * refFreqEnvelope, int refLabel )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		ThrowIfNull((LinearEnvelope *) refFreqEnvelope);
+
+		if ( refLabel <= 0 )
+		{
+			Throw( InvalidArgument, "Channelization reference label must be positive." );
+		}
+		notifier << "channelizing " << partials->size() << " Partials" << endl;
+
+		Channelizer::channelize( *partials, *refFreqEnvelope, refLabel );		
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in channelize(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in channelize(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        collate        
+/*
+/*  Collate unlabeled (zero-labeled) Partials into the smallest-possible 
+    number of Partials that does not combine any overlapping Partials.
+    Collated Partials assigned labels higher than any label in the original 
+    list, and appear at the end of the sequence, after all previously-labeled
+    Partials.
+ */
+extern "C"
+void collate( PartialList * partials )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+
+		notifier << "collating " << partials->size() << " Partials" << endl;
+		
+		// Uses default fade time of 1 ms, and .1 ms gap, 
+		// should be parameters.
+		Collator::collate( *partials, 0.001, 0.0001 );
+		
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in collate(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in collate(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        createFreqReference        
+/*
+/*	Return a newly-constructed LinearEnvelope using the legacy 
+    FrequencyReference class. The envelope will have approximately
+    the specified number of samples. The specified number of samples 
+    must be greater than 1. Uses the FundamentalEstimator 
+    (FundamentalFromPartials) class to construct an estimator of 
+    fundamental frequency, configured to emulate the behavior of
+    the FrequencyReference class in Loris 1.4-1.5.2. If numSamps 
+    is zero, construct the reference envelope from fundamental 
+    estimates taken every five milliseconds.
+
+	
+	For simple sounds, this frequency reference may be a 
+	good first approximation to a reference envelope for
+	channelization (see channelize()).
+	
+	Clients are responsible for disposing of the newly-constructed 
+	LinearEnvelope.
+ */
+extern "C"
+LinearEnvelope * 
+createFreqReference( PartialList * partials, double minFreq, double maxFreq, 
+                     long numSamps )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		
+		//	use auto_ptr to manage memory in case 
+		//	an exception is generated (hard to imagine):
+		std::auto_ptr< LinearEnvelope > env_ptr;
+		if ( numSamps != 0 )
+		{
+			env_ptr.reset( new LinearEnvelope( 
+								FrequencyReference( partials->begin(), partials->end(), 
+													minFreq, maxFreq, numSamps ).envelope() ) );
+		}
+		else
+		{
+			env_ptr.reset( new LinearEnvelope( 
+								FrequencyReference( partials->begin(), partials->end(), 
+													minFreq, maxFreq ).envelope() ) );
+		}
+		
+		return env_ptr.release();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in createFreqReference(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in createFreqReference(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return NULL;
+}
+
+/* ---------------------------------------------------------------- */
+/*        createF0Estimate        
+/*
+/* Return a newly-constructed LinearEnvelope that estimates
+   the time-varying fundamental frequency of the sound
+   represented by the Partials in a PartialList. This uses
+   the FundamentalEstimator (FundamentalFromPartials) 
+   class to construct an estimator of fundamental frequency, 
+   and returns a LinearEnvelope that samples the estimator at the 
+   specified time interval (in seconds). Default values are used 
+   to configure the estimator. Only estimates in the specified 
+   frequency range will be considered valid, estimates outside this 
+   range will be ignored.
+   
+   Clients are responsible for disposing of the newly-constructed 
+   LinearEnvelope.
+ */
+extern "C"
+LinearEnvelope * 
+createF0Estimate( PartialList * partials, double minFreq, double maxFreq, 
+                  double interval )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+        
+        const double Precision = 0.1;
+        const double Confidence = 0.9;
+        FundamentalFromPartials est( Precision );
+        
+        std::pair< double, double > span = 
+            PartialUtils::timeSpan( partials->begin(), partials->end() );
+            
+        LinearEnvelope * env_ptr = 
+         new LinearEnvelope( est.buildEnvelope( partials->begin(), 
+                                                partials->end(), 
+                                                span.first, span.second, interval,
+                                                minFreq, maxFreq,
+                                                Confidence ) );                                            
+		return env_ptr;
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in createF0Estimate(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in createF0Estimate(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return NULL;
+}
+
+/* ---------------------------------------------------------------- */
+/*        dilate        
+/*
+/*	Dilate Partials in a PartialList according to the given 
+	initial and target time points. Partial envelopes are 
+	stretched and compressed so that temporal features at
+	the initial time points are aligned with the final time
+	points. Time points are sorted, so Partial envelopes are 
+	are only stretched and compressed, but breakpoints are not
+	reordered. Duplicate time points are allowed. There must be
+	the same number of initial and target time points.
+ */
+extern "C"
+void dilate( PartialList * partials, 
+			    const double * initial, const double * target, int npts )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		ThrowIfNull((double *) initial);
+		ThrowIfNull((double *) target);
+
+		notifier << "dilating " << partials->size() << " Partials" << endl;
+		Dilator::dilate( partials->begin(), partials->end(),
+      		           initial, initial + npts, target );
+
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in dilate(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in dilate(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        distill        
+/*
+/*  Distill labeled (channelized) Partials in a PartialList into a 
+    PartialList containing at most one Partial per label. Unlabeled 
+    (zero-labeled) Partials are left unmodified at the end of the 
+    distilled Partials.
+ */
+extern "C"
+void distill( PartialList * partials )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+
+		notifier << "distilling " << partials->size() << " Partials" << endl;
+		
+		// uses default fade time of 1 ms, should be parameter
+		Distiller::distill( *partials, 0.001 );
+		
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in distill(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in distill(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        exportAiff        
+/*
+/*	Export mono audio samples stored in an array of size bufferSize to 
+	an AIFF file having the specified sample rate at the given file path 
+	(or name). The floating point samples in the buffer are clamped to the 
+	range (-1.,1.) and converted to integers having bitsPerSamp bits.
+ */
+extern "C"
+void exportAiff( const char * path, const double * buffer, 
+				     unsigned int bufferSize, double samplerate, int bitsPerSamp )
+{
+	try 
+	{
+		ThrowIfNull((double *) buffer);
+	
+		// do nothing if there are no samples:
+		if ( bufferSize == 0 )
+		{
+			notifier << "no samples to write to " << path << endl;
+			return;
+		}
+
+		//	write out samples:
+		notifier << "writing " << bufferSize << " samples to " << path << endl;
+		AiffFile fout( buffer, bufferSize, samplerate );
+		fout.write( path, bitsPerSamp );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in exportAiff(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in exportAiff(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+
+}
+
+/* ---------------------------------------------------------------- */
+/*        exportSdif        
+/*
+/*	Export Partials in a PartialList to a SDIF file at the specified
+	file path (or name). SDIF data is written in the 1TRC format.  
+	For more information about SDIF, see the SDIF web site at:
+		www.ircam.fr/equipes/analyse-synthese/sdif/  
+ */
+extern "C"
+void exportSdif( const char * path, PartialList * partials )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+
+		if ( partials->size() == 0 ) 
+		{
+			Throw( Loris::InvalidObject, "No Partials in PartialList to export to sdif file." );
+		}
+	
+		notifier << "exporting sdif partial data to " << path << endl;		
+		
+		SdifFile fout( partials->begin(), partials->end() );
+		fout.write( path );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in exportSdif(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in exportSdif(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+
+}
+
+/* ---------------------------------------------------------------- */
+/*        exportSpc        
+/*
+/*	Export Partials in a PartialList to a Spc file at the specified file
+	path (or name). The fractional MIDI pitch must be specified. The 
+	enhanced parameter defaults to true (for bandwidth-enhanced spc files), 
+	but an be specified false for pure-sines spc files. The endApproachTime 
+	parameter is in seconds. A nonzero endApproachTime indicates that the plist does 
+	not include a release, but rather ends in a static spectrum corresponding 
+	to the final breakpoint values of the partials. The endApproachTime
+	specifies how long before the end of the sound the amplitude, frequency, 
+	and bandwidth values are to be modified to make a gradual transition to 
+	the static spectrum.
+ */
+extern "C"
+void exportSpc( const char * path, PartialList * partials, double midiPitch, 
+				int enhanced, double endApproachTime )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+
+		if ( partials->size() == 0 )
+		{
+			Throw( InvalidObject, "No Partials in PartialList to export to Spc file." );
+		}
+		
+		notifier << "exporting Spc partial data to " << path << endl;
+
+		SpcFile fout( midiPitch );
+		PartialList::size_type countPartials = 0;
+		for ( PartialList::iterator iter = partials->begin(); iter != partials->end(); ++iter )
+		{
+			if ( iter->label() > 0 && iter->label() < 512 ) 
+				 // should have a symbol defined for 512!!!
+			{
+				fout.addPartial( *iter );
+				++countPartials;
+			}
+		}
+		
+		if ( countPartials != partials->size() )
+		{
+			notifier << "exporting " << countPartials << " of " 
+					 << partials->size() << " Partials having labels less than 512." << endl;
+		}
+		if ( countPartials == 0 )
+		{
+			Throw( InvalidObject, "No Partials in PartialList have valid Spc labels (1-511)." );
+		}
+		
+		if ( 0 == enhanced )
+		{
+			fout.writeSinusoidal( path, endApproachTime );
+		}
+		else
+		{
+			fout.write( path, endApproachTime );
+		}
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in exportSpc(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in exportSdif(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+
+}
+
+/* ---------------------------------------------------------------- */
+/*        harmonify        
+/*
+/*  Apply a reference Partial to fix the frequencies of Breakpoints
+    whose amplitude is below threshold_dB. 0 harmonifies full-amplitude
+    Partials, to apply only to quiet Partials, specify a lower 
+    threshold like -90). The reference Partial is the first Partial
+    in the PartialList labeled refLabel (usually 1). The Envelope 
+    is a time-varying weighting on the harmonifing process. When 1, 
+    harmonic frequencies are used, when 0, breakpoint frequencies are 
+    unmodified. 
+ */
+extern "C"
+void harmonify( PartialList * partials, long refLabel,
+                const LinearEnvelope * env, double threshold_dB )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		ThrowIfNull((LinearEnvelope *) env);
+
+		if ( partials->size() == 0 )
+		{
+			Throw( InvalidObject, "No Partials in PartialList to harmonify." );
+		}
+		
+		notifier << "harmonifying " << partials->size() << " Partials" << endl;
+
+        Harmonifier::harmonify( partials->begin(), partials->end(), refLabel,
+                                *env, threshold_dB );
+                                
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in harmonify(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in harmonify(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+
+}
+
+/* ---------------------------------------------------------------- */
+/*        importAiff        
+/*
+/*	Import audio samples stored in an AIFF file at the given file
+	path (or name). The samples are converted to floating point 
+	values on the range (-1.,1.) and stored in an array of doubles. 
+	The value returned is the number of samples in buffer, and it is at
+	most bufferSize. If samplerate is not a NULL pointer, 
+	then, on return, it points to the value of the sample rate (in
+	Hz) of the AIFF samples. The AIFF file must contain only a single
+	channel of audio data. The prior contents of buffer, if any, are 
+	overwritten.
+ */
+extern "C"
+unsigned int 
+importAiff( const char * path, double * buffer, unsigned int bufferSize, 
+            double * samplerate )
+{
+	unsigned int howMany = 0; 
+	try 
+	{
+		//	read samples:
+		notifier << "reading samples from " << path << endl;
+		AiffFile f( path );
+		notifier << "read " << f.samples().size() << " frames at " 
+				 << f.sampleRate() << " Hz" << endl;
+				
+		howMany = std::min( f.samples().size(), 
+							std::vector< double >::size_type( bufferSize ) );
+		if ( howMany < f.samples().size() )
+		{
+			notifier << "returning " << howMany << " samples" << endl;
+		}
+
+		std::copy( f.samples().begin(), f.samples().begin() + howMany,
+				   buffer );
+		std::fill( buffer + howMany,  buffer + bufferSize, 0. );
+
+				
+		if ( samplerate )
+		{
+			*samplerate = f.sampleRate();
+		}
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in importAiff(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in importAiff(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return howMany;
+}
+
+/* ---------------------------------------------------------------- */
+/*        importSdif 
+/*       
+/*	Import Partials from an SDIF file at the given file path (or 
+	name), and append them to a PartialList. Loris reads SDIF
+	files in the 1TRC format. For more information about SDIF, 
+	see the SDIF web site at:
+		www.ircam.fr/equipes/analyse-synthese/sdif/ 
+ */	
+extern "C"
+void importSdif( const char * path, PartialList * partials )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+
+		notifier << "importing Partials from " << path << endl;
+		SdifFile imp( path );
+		partials->splice( partials->end(), imp.partials() );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in importSdif(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in importSdif(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        importSpc 
+/*       
+/*	Import Partials from an Spc file at the given file path (or 
+	name), and return them in a PartialList.
+ */	
+extern "C"
+void importSpc( const char * path, PartialList * partials )
+{
+	try 
+	{
+		Loris::notifier << "importing Partials from " << path << Loris::endl;
+		Loris::SpcFile imp( path );
+		partials->insert( partials->end(), imp.partials().begin(), imp.partials().end() );
+
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in importSpc(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in importSpc(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        morpher_setAmplitudeShape        
+/*
+/* Set the shaping parameter for the amplitude morphing
+   function. This shaping parameter controls the 
+   slope of the amplitude morphing function,
+   for values greater than 1, this function
+   gets nearly linear (like the old amplitude
+   morphing function), for values much less 
+   than 1 (e.g. 1E-5) the slope is gently
+   curved and sounds pretty "linear", for 
+   very small values (e.g. 1E-12) the curve
+   is very steep and sounds un-natural because
+   of the huge jump from zero amplitude to
+   very small amplitude.
+
+   Use LORIS_DEFAULT_AMPMORPHSHAPE to obtain the 
+   default amplitude morphing shape for Loris, 
+   (equal to 1E-5, which works well for many musical 
+   instrument morphs, unless Loris was compiled
+   with the symbol LINEAR_AMP_MORPHS defined, in
+   which case LORIS_DEFAULT_AMPMORPHSHAPE is equal 
+   to LORIS_LINEAR_AMPMORPHSHAPE).
+   
+   Use LORIS_LINEAR_AMPMORPHSHAPE to approximate 
+   the linear amplitude morphs performed by older
+   versions of Loris.
+
+   The amplitude shape must be positive.
+ */
+#if !defined(LINEAR_AMP_MORPHS) || !LINEAR_AMP_MORPHS
+   const double LORIS_DEFAULT_AMPMORPHSHAPE = 1E-5;    
+#else  
+   const double LORIS_DEFAULT_AMPMORPHSHAPE = 1E5;    
+#endif
+
+const double LORIS_LINEAR_AMPMORPHSHAPE = 1E5;
+
+static double PI_ampMorphShape = LORIS_DEFAULT_AMPMORPHSHAPE;
+extern "C"
+void morpher_setAmplitudeShape( double x )
+{
+   if ( x <= 0. )
+   {
+     std::string s("Loris exception in morpher_setAmplitudeShape(): " );
+     s.append( "Invalid Argument: the amplitude morph shaping parameter must be positive" );
+     handleException( s.c_str() );
+   }
+   PI_ampMorphShape = x;
+}
+
+/* ---------------------------------------------------------------- */
+/*        morph        
+/*
+/*	Morph labeled Partials in two PartialLists according to the
+	given frequency, amplitude, and bandwidth (noisiness) morphing
+	envelopes, and append the morphed Partials to the destination 
+	PartialList. Loris morphs Partials by interpolating frequency,
+	amplitude, and bandwidth envelopes of corresponding Partials in 
+	the source PartialLists. For more information about the Loris
+	morphing algorithm, see the Loris website: 
+	www.cerlsoundgroup.org/Loris/
+ */
+extern "C"
+void morph( const PartialList * src0, const PartialList * src1, 
+            const LinearEnvelope * ffreq, 
+            const LinearEnvelope * famp, 
+            const LinearEnvelope * fbw, 
+            PartialList * dst )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) src0);
+		ThrowIfNull((PartialList *) src1);
+		ThrowIfNull((PartialList *) dst);
+		ThrowIfNull((LinearEnvelope *) ffreq);
+		ThrowIfNull((LinearEnvelope *) famp);
+		ThrowIfNull((LinearEnvelope *) fbw);
+
+		notifier << "morphing " << src0->size() << " Partials with " <<
+					src1->size() << " Partials" << endl;
+					
+		//	make a Morpher object and do it:
+		Morpher m( *ffreq, *famp, *fbw );
+		m.morph( src0->begin(), src0->end(), src1->begin(), src1->end() );
+				
+		//	splice the morphed Partials into dst:
+		dst->splice( dst->end(), m.partials() );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in morph(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in morph(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        morphWithReference        
+/*
+/*	Morph labeled Partials in two PartialLists according to the
+	given frequency, amplitude, and bandwidth (noisiness) morphing
+	envelopes, and append the morphed Partials to the destination 
+	PartialList. Specify the labels of the Partials to be used as 
+	reference Partial for the two morph sources. The reference 
+	partial is used to compute frequencies for very low-amplitude 
+	Partials whose frequency estimates are not considered reliable. 
+	The reference Partial is considered to have good frequency 
+	estimates throughout. A reference label of 0 indicates that 
+	no reference Partial should be used for the corresponding
+	morph source.
+   
+	Loris morphs Partials by interpolating frequency,
+	amplitude, and bandwidth envelopes of corresponding Partials in 
+	the source PartialLists. For more information about the Loris
+	morphing algorithm, see the Loris website: 
+	www.cerlsoundgroup.org/Loris/
+ */
+extern "C"
+void morphWithReference( const PartialList * src0, 
+                         const PartialList * src1,
+                         long src0RefLabel, 
+                         long src1RefLabel,
+                         const LinearEnvelope * ffreq, 
+                         const LinearEnvelope * famp, 
+                         const LinearEnvelope * fbw, 
+                         PartialList * dst )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) src0);
+		ThrowIfNull((PartialList *) src1);
+		ThrowIfNull((PartialList *) dst);
+		ThrowIfNull((LinearEnvelope *) ffreq);
+		ThrowIfNull((LinearEnvelope *) famp);
+		ThrowIfNull((LinearEnvelope *) fbw);
+
+		notifier << "morphing " << src0->size() << " Partials with " 
+		         << src1->size() << " Partials" << endl;
+		         
+		//	make a Morpher object and do it:
+		Morpher m( *ffreq, *famp, *fbw );
+		
+		if ( src0RefLabel != 0 )
+		{
+		   notifier << "using Partial labeled " << src0RefLabel;
+		   notifier << " as reference Partial for first morph source" << endl;
+		   m.setSourceReferencePartial( *src0, src0RefLabel );
+		}
+		else
+		{
+		   notifier << "using no reference Partial for first morph source" << endl;
+		}
+
+		if ( src1RefLabel != 0 )
+		{
+		   notifier << "using Partial labeled " << src1RefLabel;
+		   notifier << " as reference Partial for second morph source" << endl;
+		   m.setTargetReferencePartial( *src1, src1RefLabel );
+		}
+		else
+		{
+		   notifier << "using no reference Partial for second morph source" << endl;
+		}
+			
+		m.morph( src0->begin(), src0->end(), src1->begin(), src1->end() );
+				
+		//	splice the morphed Partials into dst:
+		dst->splice( dst->end(), m.partials() );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in morphWithReference(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in morphWithReference(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+
+/* ---------------------------------------------------------------- */
+/*        resample
+/*
+/*  Resample all Partials in a PartialList using the specified
+	sampling interval, so that the Breakpoints in the Partial 
+	envelopes will all lie on a common temporal grid.
+	The Breakpoint times in resampled Partials will comprise a  
+	contiguous sequence of integer multiples of the sampling interval,
+	beginning with the multiple nearest to the Partial's start time and
+	ending with the multiple nearest to the Partial's end time. Resampling
+	is performed in-place. 
+
+ */
+extern "C"
+void resample( PartialList * partials, double interval )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		
+		notifier << "resampling " << partials->size() << " Partials" << Loris::endl;
+
+      	Resampler::resample( partials->begin(), partials->end(), interval );
+
+        //  remove any resulting empty Partials
+        PartialList::iterator it = partials->begin();
+        while ( it != partials->end() )
+        {
+            if ( 0 == it->numBreakpoints() )
+            {
+                it = partials->erase( it );
+            }
+            else
+            {
+                ++it;
+            }
+        }
+
+	}
+	catch( Exception & ex )
+    {
+        std::string s( "Loris exception in resample(): " );
+        s.append( ex.what() );
+        handleException( s.c_str() );
+    }
+    catch( std::exception & ex )
+    {
+        std::string s( "std C++ exception in resample(): " );
+        s.append( ex.what() );
+        handleException( s.c_str() );
+    }
+}
+
+/* ---------------------------------------------------------------- */
+/*        shapeSpectrum
+/*  Scale the amplitudes of a set of Partials by applying 
+    a spectral suface constructed from another set.
+    Strecth the spectral surface in time and frequency
+    using the specified stretch factors. 
+ */
+extern "C"
+void shapeSpectrum( PartialList * partials, PartialList * surface,
+                    double stretchFreq, double stretchTime )
+{
+	try 
+	{
+        ThrowIfNull((PartialList *) partials);
+        ThrowIfNull((PartialList *) surface);
+		
+        notifier << "shaping " << partials->size() << " Partials using "
+                 << "spectral surface created from " << surface->size() 
+                 << " Partials" << Loris::endl;
+
+        // uses default fade time of 1 ms, should be parameter
+        SpectralSurface surf( surface->begin(), surface->end() );
+        surf.setFrequencyStretch( stretchFreq );
+        surf.setTimeStretch( stretchTime );
+        surf.setEffect( 1.0 );  // should this be a parameter?
+        surf.scaleAmplitudes( partials->begin(), partials->end() );
+	}
+	catch( Exception & ex )
+    {
+        std::string s("Loris exception in shapeSpectrum(): " );
+        s.append( ex.what() );
+        handleException( s.c_str() );
+    }
+    catch( std::exception & ex )
+    {
+        std::string s("std C++ exception in shapeSpectrum(): " );
+        s.append( ex.what() );
+        handleException( s.c_str() );
+    }
+}
+/* ---------------------------------------------------------------- */
+/*        sift
+/*  Eliminate overlapping Partials having the same label
+	(except zero). If any two partials with same label
+	overlap in time, keep only the longer of the two.
+	Set the label of the shorter duration partial to zero.
+
+ */
+extern "C"
+void sift( PartialList * partials )
+{
+	try 
+	{
+        ThrowIfNull((PartialList *) partials);
+		
+        notifier << "sifting " << partials->size() << " Partials" << Loris::endl;
+
+        // uses default fade time of 1 ms, should be parameter
+        Sieve::sift( partials->begin(), partials->end(), 0.001 );
+	}
+	catch( Exception & ex )
+    {
+        std::string s("Loris exception in sift(): " );
+        s.append( ex.what() );
+        handleException( s.c_str() );
+    }
+    catch( std::exception & ex )
+    {
+        std::string s("std C++ exception in sift(): " );
+        s.append( ex.what() );
+        handleException( s.c_str() );
+    }
+}
+
+/* ---------------------------------------------------------------- */
+/*        synthesize        
+/*
+/*	Synthesize Partials in a PartialList at the given sample
+	rate, and store the (floating point) samples in a buffer of
+	size bufferSize. The buffer is neither resized nor 
+	cleared before synthesis, so newly synthesized samples are
+	added to any previously computed samples in the buffer, and
+	samples beyond the end of the buffer are lost. Return the
+	number of samples synthesized, that is, the index of the
+	latest sample in the buffer that was modified.
+ */
+extern "C"
+unsigned int synthesize( const PartialList * partials, 
+				 double * buffer, unsigned int bufferSize,  
+				 double srate )
+{
+	unsigned int howMany = 0;
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		ThrowIfNull((double *) buffer);
+
+		notifier << "synthesizing " << partials->size() 
+				   << " Partials at " << srate << " Hz" << endl;
+
+		//	synthesize:
+		std::vector< double > vec;
+		Synthesizer synth( srate, vec );
+		synth.synthesize( partials->begin(), partials->end() );
+		
+		// determine the number of synthesized samples
+		// that will be stored:
+		howMany = vec.size();
+		if ( howMany > bufferSize )
+		{
+			howMany = bufferSize;
+		}
+
+		//	accumulate into the buffer:
+		std::transform( buffer, buffer + howMany, vec.begin(), 
+						buffer, std::plus< double >() );
+						    
+
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in synthesize(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in synthesize(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return howMany;
+}
+
+
+
+
diff --git a/src/loris/lorisPartialList_pi.C b/src/loris/lorisPartialList_pi.C
new file mode 100644
index 0000000..c99c77c
--- /dev/null
+++ b/src/loris/lorisPartialList_pi.C
@@ -0,0 +1,839 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ *	lorisPartialList_pi.C
+ *
+ *	A component of the C-linkable procedural interface for Loris. 
+ *
+ *	Main components of the Loris procedural interface:
+ *	- object interfaces - Analyzer, Synthesizer, Partial, PartialIterator, 
+ *		PartialList, PartialListIterator, Breakpoint, BreakpointEnvelope,  
+ *		and SampleVector need to be (opaque) objects in the interface, 
+ * 		either because they hold state (e.g. Analyzer) or because they are 
+ *		fundamental data types (e.g. Partial), so they need a procedural 
+ *		interface to their member functions. All these things need to be 
+ *		opaque pointers for the benefit of C.
+ *	- non-object-based procedures - other classes in Loris are not so stateful,
+ *		and have sufficiently narrow functionality that they need only 
+ *		procedures, and no object representation.
+ *	- utility functions - some procedures that are generally useful but are
+ *		not yet part of the Loris core are also defined.
+ *	- notification and exception handlers - all exceptions must be caught and
+ *		handled internally, clients can specify an exception handler and 
+ *		a notification function (the default one in Loris uses printf()).
+ *
+ *	This file contains the procedural interface for the Loris 
+ *	PartialList (std::list< Partial >) class.
+ *
+ * Kelly Fitz, 10 Nov 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "loris.h"
+#include "lorisException_pi.h"
+
+#include "Partial.h"
+#include "Notifier.h"
+
+#include <list>
+
+using namespace Loris;
+
+
+/* ---------------------------------------------------------------- */
+/*		PartialList object interface								
+/*
+/*	A PartialList represents a collection of Bandwidth-Enhanced 
+	Partials, each having a trio of synchronous, non-uniformly-
+	sampled breakpoint envelopes representing the time-varying 
+	frequency, amplitude, and noisiness of a single bandwidth-
+	enhanced sinusoid.
+
+	For more information about Bandwidth-Enhanced Partials and the  
+	Reassigned Bandwidth-Enhanced Additive Sound Model, refer to
+	the Loris website: www.cerlsoundgroup.org/Loris/.
+
+	In C++, a PartialList * is a Loris::PartialList *.
+ */ 
+
+/* ---------------------------------------------------------------- */
+/*        createPartialList        
+/*
+/*	Return a new empty PartialList.
+ */
+extern "C"
+PartialList * createPartialList( void )
+{
+	try 
+	{
+		debugger << "creating empty PartialList" << endl;
+		return new std::list< Partial >;
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in createPartialList(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in createPartialList(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return NULL;
+}
+
+/* ---------------------------------------------------------------- */
+/*        destroyPartialList        
+/*
+/*	Destroy this PartialList.
+ */
+extern "C"
+void destroyPartialList( PartialList * ptr_this )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) ptr_this);
+
+		debugger << "deleting PartialList containing " << ptr_this->size() << " Partials" << endl;
+		delete ptr_this;
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in destroyPartialList(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in destroyPartialList(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        partialList_clear        
+/*
+/*	Remove (and destroy) all the Partials from this PartialList,
+	leaving it empty.
+ */
+extern "C"
+void partialList_clear( PartialList * ptr_this )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) ptr_this);
+		ptr_this->clear();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partialList_clear(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partialList_clear(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        partialList_copy        
+/*
+/*	Make this PartialList a copy of the source PartialList by making
+	copies of all of the Partials in the source and adding them to 
+	this PartialList.
+ */
+extern "C"
+void partialList_copy( PartialList * dst, const PartialList * src )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) dst);
+		ThrowIfNull((PartialList *) src);
+
+		debugger << "copying PartialList containing " << src->size() << " Partials" << endl;
+		*dst = *src;
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partialList_copy(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partialList_copy(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        partialList_size        
+/*
+/*	Return the number of Partials in this PartialList.
+ */
+extern "C"
+unsigned long partialList_size( const PartialList * ptr_this )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) ptr_this);
+		return ptr_this->size();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partialList_size(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partialList_size(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/*        partialList_splice        
+/*
+/*	Splice all the Partials in the source PartialList onto the end of
+	this PartialList, leaving the source empty.
+ */
+extern "C"
+void partialList_splice( PartialList * dst, PartialList * src )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) dst);
+		ThrowIfNull((PartialList *) src);
+
+		debugger << "splicing PartialList containing " << src->size() << " Partials" 
+				 << " into PartialList containing " << dst->size() << " Partials"<< endl;
+		dst->splice( dst->end(), *src );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partialList_splice(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partialList_splice(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*		Partial object interface
+/*
+/*	A Partial represents a single component in the
+	reassigned bandwidth-enhanced additive model. A Partial consists of a
+	chain of Breakpoints describing the time-varying frequency, amplitude,
+	and bandwidth (or noisiness) envelopes of the component, and a 4-byte
+	label. The Breakpoints are non-uniformly distributed in time. For more
+	information about Reassigned Bandwidth-Enhanced Analysis and the
+	Reassigned Bandwidth-Enhanced Additive Sound Model, refer to the Loris
+	website: www.cerlsoundgroup.org/Loris/.
+ */ 
+
+/* ---------------------------------------------------------------- */
+/*        partial_startTime        
+/*
+/*	Return the start time (seconds) for the specified Partial.
+ */
+double partial_startTime( const Partial * p )
+{
+    double ret = 0;
+	try 
+	{
+		ThrowIfNull((Partial *) p);
+
+		ret = p->startTime();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partial_startTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partial_startTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        partial_endTime        
+/*
+/*	Return the end time (seconds) for the specified Partial.
+ */
+double partial_endTime( const Partial * p )
+{
+    double ret = 0;
+	try 
+	{
+		ThrowIfNull((Partial *) p);
+
+		ret = p->endTime();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partial_endTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partial_endTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        partial_duration        
+/*
+/*	Return the duration (seconds) for the specified Partial.
+ */
+double partial_duration( const Partial * p )
+{
+    double ret = 0;
+	try 
+	{
+		ThrowIfNull((Partial *) p);
+
+		ret = p->duration();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partial_duration(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partial_duration(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        partial_initialPhase        
+/*
+/*	Return the initial phase (radians) for the specified Partial.
+ */
+double partial_initialPhase( const Partial * p )
+{
+    double ret = 0;
+	try 
+	{
+		ThrowIfNull((Partial *) p);
+
+		ret = p->initialPhase();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partial_initialPhase(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partial_initialPhase(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        partial_label        
+/*
+/*	Return the integer label for the specified Partial.
+ */
+int partial_label( const Partial * p )
+{
+    int ret = 0;
+	try 
+	{
+		ThrowIfNull((Partial *) p);
+
+		ret = p->label();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partial_label(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partial_label(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        partial_numBreakpoints        
+/*
+/*	Return the number of Breakpoints in the specified Partial.
+ */
+unsigned long partial_numBreakpoints( const Partial * p )
+{
+    unsigned long ret = 0;
+	try 
+	{
+		ThrowIfNull((Partial *) p);
+
+		ret = p->size();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partial_numBreakpoints(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partial_numBreakpoints(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        partial_frequencyAt        
+/*
+/*	Return the frequency (Hz) of the specified Partial interpolated
+	at a particular time. It is an error to apply this function to
+	a Partial having no Breakpoints.
+ */
+double partial_frequencyAt( const Partial * p, double t )
+{
+    double ret = 0;
+	try 
+	{
+		ThrowIfNull((Partial *) p);
+
+		ret = p->frequencyAt( t );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partial_frequencyAt(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partial_frequencyAt(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        partial_bandwidthAt        
+/*
+/*	Return the bandwidth of the specified Partial interpolated
+	at a particular time. It is an error to apply this function to
+	a Partial having no Breakpoints.
+ */
+double partial_bandwidthAt( const Partial * p, double t )
+{
+    double ret = 0;
+	try 
+	{
+		ThrowIfNull((Partial *) p);
+
+		ret = p->bandwidthAt( t );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partial_bandwidthAt(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partial_bandwidthAt(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        partial_phaseAt        
+/*
+/*	Return the phase (radians) of the specified Partial interpolated
+	at a particular time. It is an error to apply this function to
+	a Partial having no Breakpoints.
+ */
+double partial_phaseAt( const Partial * p, double t )
+{
+    double ret = 0;
+	try 
+	{
+		ThrowIfNull((Partial *) p);
+
+		ret = p->phaseAt( t );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partial_phaseAt(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partial_phaseAt(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        partial_amplitudeAt        
+/*
+/*	Return the (absolute) amplitude of the specified Partial interpolated
+	at a particular time. Partials are assumed to fade out
+	over 1 millisecond at the ends (rather than instantaneously).
+	It is an error to apply this function to a Partial having no Breakpoints.
+ */
+double partial_amplitudeAt( const Partial * p, double t )
+{
+    double ret = 0;
+	try 
+	{
+		ThrowIfNull((Partial *) p);
+
+		ret = p->amplitudeAt( t, 0.001 );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partial_amplitudeAt(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partial_amplitudeAt(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        partial_setLabel        
+/*
+/* 	Assign a new integer label to the specified Partial.
+ */
+void partial_setLabel( Partial * p, int label )
+{
+	try 
+	{
+		ThrowIfNull((Partial *) p);
+
+		p->setLabel( label );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in partial_setLabel(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in partial_setLabel(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*		Breakpoint object interface
+/*
+/*	A Breakpoint represents a single breakpoint in the
+	Partial parameter (frequency, amplitude, bandwidth) envelope.
+	Instantaneous phase is also stored, but is only used at the onset of 
+	a partial, or when it makes a transition from zero to nonzero amplitude.
+	
+	Loris Partials represent reassigned bandwidth-enhanced model components.
+	A Partial consists of a chain of Breakpoints describing the time-varying
+	frequency, amplitude, and bandwidth (noisiness) of the component.
+	For more information about Reassigned Bandwidth-Enhanced 
+	Analysis and the Reassigned Bandwidth-Enhanced Additive Sound 
+	Model, refer to the Loris website: 
+	www.cerlsoundgroup.org/Loris/.
+ */ 
+
+/* ---------------------------------------------------------------- */
+/*        breakpoint_getFrequency        
+/*
+/*	Return the frequency (Hz) of the specified Breakpoint.
+ */
+double breakpoint_getFrequency( const Breakpoint * bp )
+{
+    double ret = 0;
+	try 
+	{
+		ThrowIfNull((Breakpoint *) bp);
+
+		ret = bp->frequency();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in breakpoint_getFrequency(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in breakpoint_getFrequency(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        breakpoint_getAmplitude        
+/*
+/* 	Return the (absolute) amplitude of the specified Breakpoint.
+ */
+double breakpoint_getAmplitude( const Breakpoint * bp )
+{
+    double ret = 0;
+	try 
+	{
+		ThrowIfNull((Breakpoint *) bp);
+
+		ret = bp->amplitude();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in breakpoint_getAmplitude(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in breakpoint_getAmplitude(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        breakpoint_getBandwidth        
+/*
+/*	Return the bandwidth coefficient of the specified Breakpoint.
+ */
+double breakpoint_getBandwidth( const Breakpoint * bp )
+{
+    double ret = 0;
+	try 
+	{
+		ThrowIfNull((Breakpoint *) bp);
+
+		ret = bp->bandwidth();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in breakpoint_getBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in breakpoint_getBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        breakpoint_getPhase        
+/*
+/*	Return the phase (radians) of the specified Breakpoint.
+ */
+double breakpoint_getPhase( const Breakpoint * bp )
+{
+    double ret = 0;
+	try 
+	{
+		ThrowIfNull((Breakpoint *) bp);
+
+		ret = bp->phase();
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in breakpoint_getPhase(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in breakpoint_getPhase(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	return ret;
+}
+
+/* ---------------------------------------------------------------- */
+/*        breakpoint_setFrequency        
+/*
+/*	Assign a new frequency (Hz) to the specified Breakpoint.
+ */
+void breakpoint_setFrequency( Breakpoint * bp, double f )
+{
+	try 
+	{
+		ThrowIfNull((Breakpoint *) bp);
+
+		bp->setFrequency( f );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in breakpoint_setFrequency(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in breakpoint_setFrequency(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        breakpoint_setAmplitude        
+/*
+/* 	Assign a new (absolute) amplitude to the specified Breakpoint.
+ */
+void breakpoint_setAmplitude( Breakpoint * bp, double a )
+{
+	try 
+	{
+		ThrowIfNull((Breakpoint *) bp);
+
+		bp->setAmplitude( a );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in breakpoint_setAmplitude(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in breakpoint_setAmplitude(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        breakpoint_setBandwidth        
+/*
+/*	Assign a new bandwidth coefficient to the specified Breakpoint.
+ */
+void breakpoint_setBandwidth( Breakpoint * bp, double bw )
+{
+	try 
+	{
+		ThrowIfNull((Breakpoint *) bp);
+
+		bp->setBandwidth( bw );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in breakpoint_setBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in breakpoint_setBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        breakpoint_setPhase        
+/*
+/*	Assign a new phase (radians) to the specified Breakpoint.
+ */
+void breakpoint_setPhase( Breakpoint * bp, double phi )
+{
+	try 
+	{
+		ThrowIfNull((Breakpoint *) bp);
+
+		bp->setPhase( phi );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in breakpoint_setPhase(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in breakpoint_setPhase(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
diff --git a/src/loris/lorisUtilities_pi.C b/src/loris/lorisUtilities_pi.C
new file mode 100644
index 0000000..0b401a4
--- /dev/null
+++ b/src/loris/lorisUtilities_pi.C
@@ -0,0 +1,1075 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ *	lorisUtilities_pi.C
+ *
+ *	A component of the C-linkable procedural interface for Loris. 
+ *
+ *	Main components of the Loris procedural interface:
+ *	- object interfaces - Analyzer, Synthesizer, Partial, PartialIterator, 
+ *		PartialList, PartialListIterator, Breakpoint, BreakpointEnvelope,  
+ *		and SampleVector need to be (opaque) objects in the interface, 
+ * 		either because they hold state (e.g. Analyzer) or because they are 
+ *		fundamental data types (e.g. Partial), so they need a procedural 
+ *		interface to their member functions. All these things need to be 
+ *		opaque pointers for the benefit of C.
+ *	- non-object-based procedures - other classes in Loris are not so stateful,
+ *		and have sufficiently narrow functionality that they need only 
+ *		procedures, and no object representation.
+ *	- utility functions - some procedures that are generally useful but are
+ *		not yet part of the Loris core are also defined.
+ *	- notification and exception handlers - all exceptions must be caught and
+ *		handled internally, clients can specify an exception handler and 
+ *		a notification function (the default one in Loris uses printf()).
+ *
+ *	This file defines the utility functions that are useful, and in many 
+ *	cases trivial in C++ (usign the STL for example) but are not represented
+ *	by classes in the Loris core.
+ *
+ * Kelly Fitz, 10 Nov 2000
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "loris.h"
+#include "lorisException_pi.h"
+
+#include "BreakpointEnvelope.h"
+#include "LorisExceptions.h"
+#include "Notifier.h"
+#include "Partial.h"
+#include "PartialUtils.h"
+
+#include <algorithm>
+#include <cmath>
+#include <functional>
+#include <iterator>
+#include <list>
+#include <memory>
+
+using namespace Loris;
+
+// ---------------------------------------------------------------------------
+//	Functors to help apply C-callbacks to lists of Partials
+//	by converting Partial references to pointer arguments.
+//
+
+struct CallWithPointer : public std::unary_function< Partial, void >
+{
+	typedef void (* Func)( Partial *, void * );
+	Func func;
+	void * data;
+	
+	CallWithPointer( Func f, void * d ) : func( f ), data( d ) {}
+	
+	void operator()( Partial & partial ) const
+	{
+		func( &partial, data );
+	}
+};
+
+struct PredWithPointer : public std::unary_function< const Partial, bool >
+{
+	typedef int (* Pred)( const Partial *, void * );
+	Pred pred;
+	void * data;
+	
+	PredWithPointer( Pred p, void * d ) : pred( p ), data( d ) {}
+	
+	bool operator()( const Partial & partial ) const
+	{
+		return 0 != pred( &partial, data );
+	}
+};
+
+/* ---------------------------------------------------------------- */
+/*		utility functions
+/*
+/*	Operations for transforming and manipulating collections
+   of Partials.
+ */
+
+/* ---------------------------------------------------------------- */
+/*        avgAmplitude 
+/*       
+/*  Return the average amplitude over all Breakpoints in this Partial.
+    Return zero if the Partial has no Breakpoints.
+ */
+extern "C"
+double avgAmplitude( const Partial * p )
+{
+    try
+    {
+        ThrowIfNull((Partial *) p);
+        return PartialUtils::avgAmplitude( *p );
+    }
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in avgAmplitude(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in avgAmplitude(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}    
+
+    return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/*        avgFrequency 
+/*       
+/*  Return the average frequency over all Breakpoints in this Partial.
+    Return zero if the Partial has no Breakpoints.
+ */
+extern "C"
+double avgFrequency( const Partial * p )
+{
+    try
+    {
+        ThrowIfNull((Partial *) p);
+        return PartialUtils::avgFrequency( *p );
+    }
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in avgFrequency(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in avgFrequency(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}    
+
+    return 0;}
+
+ 
+/* ---------------------------------------------------------------- */
+/*        copyIf        
+/*
+/*	Append copies of Partials in the source PartialList satisfying the
+	specified predicate to the destination PartialList. The source list
+	is unmodified. The data parameter can be used to 
+   supply extra user-defined data to the function. Pass 0 if no 
+   additional data is needed.
+ */
+extern "C"
+void copyIf( const PartialList * src, PartialList * dst, 
+			    int ( * predicate )( const Partial * p, void * data ),
+			    void * data )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) src);
+		ThrowIfNull((PartialList *) dst);
+		
+		std::remove_copy_if( src->begin(), src->end(), std::back_inserter( *dst ),
+							 std::not1( PredWithPointer( predicate, data ) ) );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in copyIf(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in copyIf(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+			 
+/* ---------------------------------------------------------------- */
+/*        copyLabeled        
+/*
+/*	Append copies of Partials in the source PartialList having the
+	specified label to the destination PartialList. The source list
+	is unmodified.
+ */
+extern "C"
+void copyLabeled( const PartialList * src, long label, PartialList * dst )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) src);
+		ThrowIfNull((PartialList *) dst);
+		
+		std::remove_copy_if( src->begin(), src->end(), std::back_inserter( *dst ),
+							 std::not1( PartialUtils::isLabelEqual(label) ) );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in copyLabeled(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in copyLabeled(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+ 
+/* ---------------------------------------------------------------- */
+/*        crop        
+/*
+/*	Trim Partials by removing Breakpoints outside a specified time span.
+	Insert a Breakpoint at the boundary when cropping occurs. Remove
+	any Partials that are left empty after cropping (Partials having no
+	Breakpoints between t1 and t2).
+ */
+extern "C"
+void crop( PartialList * partials, double t1, double t2 )
+{
+	try
+	{
+		ThrowIfNull((PartialList *) partials);
+
+		notifier << "cropping " << partials->size() << " Partials" << endl;
+
+		PartialUtils::crop( partials->begin(), partials->end(), t1, t2 );	
+		
+		//  remove empty Partials:
+		PartialList::iterator it = partials->begin();
+		while ( it != partials->end() )
+		{
+		    if ( 0 == it->numBreakpoints() )
+		    {
+		        it = partials->erase( it );
+		    }
+		    else
+		    {
+		        ++it;
+		    }
+		}
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in crop(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in crop(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        extractIf      
+/*
+/*	Remove Partials in the source PartialList satisfying the
+	specified predicate from the source list and append them to
+    the destination PartialList. The data parameter can be used to 
+    supply extra user-defined data to the function. Pass 0 if no 
+    additional data is needed.
+ */
+extern "C"
+void extractIf( PartialList * src, PartialList * dst, 
+                int ( * predicate )( const Partial * p, void * data ),
+			 	    void * data )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) src);
+		ThrowIfNull((PartialList *) dst);
+        
+        /*
+		std::list< Partial >::iterator it = 
+			std::stable_partition( src->begin(), src->end(), 
+								   std::not1( PredWithPointer( predicate, data ) ) );
+		
+		stable_partition should work, but seems sometimes to hang, 
+		especially when there are lots and lots of Partials. Do it
+		efficiently by hand instead.
+		
+		dst->splice( dst->end(), *src, it, src->end() );
+		*/
+		std::list< Partial >::iterator it;
+		for ( it = std::find_if( src->begin(), src->end(), PredWithPointer( predicate, data ) );
+		      it != src->end(); 
+		      it = std::find_if( it, src->end(), PredWithPointer( predicate, data ) ) )
+	    {
+	        //  the iterator passed to splice is a copy of it
+	        //  before the increment, so it is not corrupted
+	        //  by the splice, it is advanced to the next
+	        //  position before the splice is performed.
+	        dst->splice( dst->end(), *src, it++ );
+	    }
+		
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in extractIf(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in extractIf(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        extractLabeled        
+/*
+/*	Remove Partials in the source PartialList having the specified
+    label from the source list and append them to the destination 
+    PartialList.
+ */
+extern "C"
+void extractLabeled( PartialList * src, long label, PartialList * dst )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) src);
+		ThrowIfNull((PartialList *) dst);
+    
+        /*
+		std::list< Partial >::iterator it = 
+			std::stable_partition( src->begin(), src->end(), 
+								        std::not1( PartialUtils::isLabelEqual(label) ) );
+		
+		stable_partition should work, but seems sometimes to hang, 
+		especially when there are lots and lots of Partials. Do it
+		efficiently by hand instead.
+		
+		dst->splice( dst->end(), *src, it, src->end() );
+		*/
+		std::list< Partial >::iterator it;
+		for ( it = std::find_if( src->begin(), src->end(), PartialUtils::isLabelEqual(label) );
+		      it != src->end(); 
+		      it = std::find_if( it, src->end(), PartialUtils::isLabelEqual(label) ) )
+	    {
+	        //  the iterator passed to splice is a copy of it
+	        //  before the increment, so it is not corrupted
+	        //  by the splice, it is advanced to the next
+	        //  position before the splice is performed.
+	        dst->splice( dst->end(), *src, it++ );
+	    }
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in extractLabeled(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in extractLabeled(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        fixPhaseAfter 
+/*
+/*  Recompute phases of all Breakpoints later than the specified 
+    time so that the synthesized phases of those later Breakpoints 
+    matches the stored phase, as long as the synthesized phase at 
+    the specified time matches the stored (not recomputed) phase.
+    
+    Phase fixing is only applied to non-null (nonzero-amplitude) 
+    Breakpoints, because null Breakpoints are interpreted as phase 
+    reset points in Loris. If a null is encountered, its phase is 
+    simply left unmodified, and future phases wil be recomputed 
+    from that one.
+ */
+extern "C"
+void fixPhaseAfter( PartialList * partials, double time )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		PartialUtils::fixPhaseAfter( partials->begin(), partials->end(), time );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in fixPhaseAfter(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in fixPhaseAfter(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+ 
+/* ---------------------------------------------------------------- */
+/*        fixPhaseAt 
+/*
+/*  Recompute phases of all Breakpoints in a Partial
+    so that the synthesized phases match the stored phases, 
+    and the synthesized phase at (nearest) the specified
+    time matches the stored (not recomputed) phase.
+    
+    Backward phase-fixing stops if a null (zero-amplitude) 
+    Breakpoint is encountered, because nulls are interpreted as 
+    phase reset points in Loris. If a null is encountered, the 
+    remainder of the Partial (the front part) is fixed in the 
+    forward direction, beginning at the start of the Partial. 
+    Forward phase fixing is only applied to non-null 
+    (nonzero-amplitude) Breakpoints. If a null is encountered, 
+    its phase is simply left unmodified, and future phases wil be 
+    recomputed from that one.
+ */
+extern "C"
+void fixPhaseAt( PartialList * partials, double time )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		PartialUtils::fixPhaseAt( partials->begin(), partials->end(), time );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in fixPhaseAt(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in fixPhaseAt(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+ 
+/* ---------------------------------------------------------------- */
+/*        fixPhaseBefore 
+/*
+/*  Recompute phases of all Breakpoints earlier than the specified 
+    time so that the synthesized phases of those earlier Breakpoints 
+    matches the stored phase, and the synthesized phase at the 
+    specified time matches the stored (not recomputed) phase.
+
+    Backward phase-fixing stops if a null (zero-amplitude) Breakpoint
+    is encountered, because nulls are interpreted as phase reset 
+    points in Loris. If a null is encountered, the remainder of the 
+    Partial (the front part) is fixed in the forward direction, 
+    beginning at the start of the Partial.
+ */
+extern "C"
+void fixPhaseBefore( PartialList * partials, double time )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		PartialUtils::fixPhaseBefore( partials->begin(), partials->end(), time );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in fixPhaseBefore(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in fixPhaseBefore(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        fixPhaseBetween 
+/*
+    Fix the phase travel between two times by adjusting the
+    frequency and phase of Breakpoints between those two times.
+    
+    This algorithm assumes that there is nothing interesting 
+    about the phases of the intervening Breakpoints, and modifies 
+    their frequencies as little as possible to achieve the correct 
+    amount of phase travel such that the frequencies and phases at 
+    the specified times match the stored values. The phases of all 
+    the Breakpoints between the specified times are recomputed.
+ */
+extern "C"
+void fixPhaseBetween( PartialList * partials, double tbeg, double tend )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		PartialUtils::fixPhaseBetween( partials->begin(), partials->end(), 
+		                               tbeg, tend );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in fixPhaseBetween(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in fixPhaseBetween(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+ 
+ 
+/* ---------------------------------------------------------------- */
+/*        fixPhaseForward
+/*
+/*  Recompute phases of all Breakpoints later than the specified 
+    time so that the synthesized phases of those later Breakpoints 
+    matches the stored phase, as long as the synthesized phase at 
+    the specified time matches the stored (not recomputed) phase. 
+    Breakpoints later than tend are unmodified.
+    
+    Phase fixing is only applied to non-null (nonzero-amplitude) 
+    Breakpoints, because null Breakpoints are interpreted as phase 
+    reset points in Loris. If a null is encountered, its phase is 
+    simply left unmodified, and future phases wil be recomputed 
+    from that one.
+ */
+extern "C"
+void fixPhaseForward( PartialList * partials, double tbeg, double tend )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		PartialUtils::fixPhaseForward( partials->begin(), partials->end(), 
+		                               tbeg, tend );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in fixPhaseForward(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in fixPhaseForward(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+ 
+ 
+/* ---------------------------------------------------------------- */
+/*        forEachBreakpoint        
+/*
+/*	Apply a function to each Breakpoint in a Partial. The function
+	is called once for each Breakpoint in the source Partial. The
+	function may modify the Breakpoint (but should not otherwise attempt 
+	to modify the Partial). The data parameter can be used to supply extra
+	user-defined data to the function. Pass 0 if no additional data is needed.
+	The function should return 0 if successful. If the function returns
+	a non-zero value, then forEachBreakpoint immediately returns that value
+	without applying the function to any other Breakpoints in the Partial.
+	forEachBreakpoint returns zero if all calls to func return zero.
+ */
+int forEachBreakpoint( Partial * p,
+		 			   int ( * func )( Breakpoint * p, double time, void * data ),
+			 		   void * data )
+{
+	int result = 0;
+	try 
+	{
+		ThrowIfNull((Partial *) p);
+
+		Partial::iterator it;
+		for ( it = p->begin(); 0 == result && it != p->end(); ++it )
+		{
+			result = func( &(it.breakpoint()), it.time(), data );
+		}
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in forEachBreakpoint(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in forEachBreakpoint(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	
+	return result;
+}
+
+			 			
+/* ---------------------------------------------------------------- */
+/*        forEachPartial        
+/*
+/*	Apply a function to each Partial in a PartialList. The function
+	is called once for each Partial in the source PartialList. The
+	function may modify the Partial (but should not attempt to modify
+	the PartialList). The data parameter can be used to supply extra
+	user-defined data to the function. Pass 0 if no additional data 
+	is needed. The function should return 0 if successful. If the 
+	function returns a non-zero value, then forEachPartial immediately 
+	returns that value without applying the function to any other 
+	Partials in the PartialList. forEachPartial returns zero if all 
+	calls to func return zero.
+ */
+int forEachPartial( PartialList * src,
+			 		int ( * func )( Partial * p, void * data ),
+			 		void * data )
+{
+	int result = 0;
+	try 
+	{
+		ThrowIfNull((PartialList *) src);
+		
+		PartialList::iterator it;
+		for ( it = src->begin(); 0 == result && it != src->end(); ++it )
+		{
+			result = func( &(*it), data );
+		}
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in forEachPartial(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in forEachPartial(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+
+	return result;
+}
+			 		
+
+/* ---------------------------------------------------------------- */
+/*        peakAmplitude        
+/*
+/*  Return the maximum amplitude achieved by a Partial.
+ */
+extern "C"
+double peakAmplitude( const Partial * p )
+{
+    try
+    {
+        ThrowIfNull((Partial *) p);
+        return PartialUtils::peakAmplitude( *p );
+    }
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in peakAmplitude(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in peakAmplitude(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}    
+
+    return 0;
+}
+
+/* ---------------------------------------------------------------- */
+/*        removeIf        
+/*
+/*	Remove from a PartialList all Partials satisfying the
+	specified predicate. The data parameter can be used to 
+    supply extra user-defined data to the function. Pass 0 if no 
+    additional data is needed.
+ */
+extern "C"
+void removeIf( PartialList * src, 
+			      int ( * predicate )( const Partial * p, void * data ),
+			      void * data )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) src);
+		std::list< Partial >::iterator it = 
+			std::remove_if( src->begin(), src->end(), 
+							PredWithPointer( predicate, data ) );
+		src->erase( it, src->end() );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in removeIf(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in removeIf(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+			 
+/* ---------------------------------------------------------------- */
+/*        removeLabeled        
+/*
+/*	Remove from a PartialList all Partials having the specified label. 
+ */
+extern "C"
+void removeLabeled( PartialList * src, long label )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) src);
+		std::list< Partial >::iterator it = 
+			std::remove_if( src->begin(), src->end(), 
+							    PartialUtils::isLabelEqual( label ) );
+		src->erase( it, src->end() );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in removeLabeled(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in removeLabeled(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        scaleAmp        
+/*
+/*	Bad old name for scaleAmplitude.
+ */
+extern "C"
+void scaleAmp( PartialList * partials, BreakpointEnvelope * ampEnv )
+{
+    scaleAmplitude( partials, ampEnv );
+}
+
+/* ---------------------------------------------------------------- */
+/*        scaleAmplitude        
+/*
+/*	Scale the amplitude of the Partials in a PartialList according 
+	to an envelope representing a time-varying amplitude scale value.
+ */
+extern "C"
+void scaleAmplitude( PartialList * partials, BreakpointEnvelope * ampEnv )
+{
+	try
+	{
+		ThrowIfNull((PartialList *) partials);
+		ThrowIfNull((BreakpointEnvelope *) ampEnv);
+
+		notifier << "scaling amplitude of " << partials->size() << " Partials" << endl;
+
+		PartialUtils::scaleAmplitude( partials->begin(), partials->end(), *ampEnv );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in scaleAmplitude(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in scaleAmplitude(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        scaleBandwidth        
+/*
+/*	Scale the bandwidth of the Partials in a PartialList according 
+	to an envelope representing a time-varying bandwidth scale value.
+ */
+extern "C"
+void scaleBandwidth( PartialList * partials, BreakpointEnvelope * bwEnv )
+{
+	try
+	{
+		ThrowIfNull((PartialList *) partials);
+		ThrowIfNull((BreakpointEnvelope *) bwEnv);
+
+		notifier << "scaling bandwidth of " << partials->size() << " Partials" << endl;
+
+		PartialUtils::scaleBandwidth( partials->begin(), partials->end(), *bwEnv );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in scaleBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in scaleBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        setBandwidth        
+/*
+/*	Assign the bandwidth of the Partials in a PartialList according 
+	to an envelope representing a time-varying bandwidth scale value.
+ */
+extern "C"
+void setBandwidth( PartialList * partials, BreakpointEnvelope * bwEnv )
+{
+	try
+	{
+		ThrowIfNull((PartialList *) partials);
+		ThrowIfNull((BreakpointEnvelope *) bwEnv);
+
+		notifier << "setting bandwidth of " << partials->size() << " Partials" << endl;
+
+		PartialUtils::setBandwidth( partials->begin(), partials->end(), *bwEnv );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in setBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in setBandwidth(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        scaleFrequency        
+/*
+/*	Scale the frequency of the Partials in a PartialList according 
+	to an envelope representing a time-varying frequency scale value.
+ */
+extern "C"
+void scaleFrequency( PartialList * partials, BreakpointEnvelope * freqEnv )
+{
+	try
+	{
+		ThrowIfNull((PartialList *) partials);
+		ThrowIfNull((BreakpointEnvelope *) freqEnv);
+
+		notifier << "scaling frequency of " << partials->size() << " Partials" << endl;
+
+      	PartialUtils::scaleFrequency( partials->begin(), partials->end(), *freqEnv );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in scaleFrequency(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in scaleFrequency(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        scaleNoiseRatio        
+/*
+/*	Scale the relative noise content of the Partials in a PartialList 
+	according to an envelope representing a (time-varying) noise energy 
+	scale value.
+ */
+extern "C"
+void scaleNoiseRatio( PartialList * partials, BreakpointEnvelope * noiseEnv )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		ThrowIfNull((BreakpointEnvelope *) noiseEnv);
+
+		notifier << "scaling noise ratio of " << partials->size() << " Partials" << endl;
+
+		PartialUtils::scaleNoiseRatio( partials->begin(), partials->end(), *noiseEnv );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in scaleNoiseRatio(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in scaleNoiseRatio(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        shiftPitch        
+/*
+/*	Shift the pitch of all Partials in a PartialList according to 
+	the given pitch envelope. The pitch envelope is assumed to have 
+	units of cents (1/100 of a halfstep).
+ */
+extern "C"
+void shiftPitch( PartialList * partials, BreakpointEnvelope * pitchEnv )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+		ThrowIfNull((BreakpointEnvelope *) pitchEnv);
+
+		notifier << "shifting pitch of " << partials->size() << " Partials" << endl;
+		
+		PartialUtils::shiftPitch( partials->begin(), partials->end(), *pitchEnv );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in shiftPitch(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in shiftPitch(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        shiftTime       
+/*
+/*	Shift the time of all the Breakpoints in all Partials in a 
+	PartialList by a constant amount.
+ */
+extern "C"
+void shiftTime( PartialList * partials, double offset )
+{
+	try 
+	{
+		ThrowIfNull((PartialList *) partials);
+
+		notifier << "shifting time of " << partials->size() << " Partials" << endl;
+		
+		PartialUtils::shiftTime( partials->begin(), partials->end(), offset );
+	}
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in shiftTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in shiftTime(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+}
+
+/* ---------------------------------------------------------------- */
+/*        sortByLabel        
+/*
+/*	Sort the Partials in a PartialList in order of increasing label.
+ * 	The sort is stable; Partials having the same label are not 
+ * 	reordered.
+ */
+extern "C"
+void sortByLabel( PartialList * partials )
+{
+	partials->sort( PartialUtils::compareLabelLess() );	
+}
+
+/* ---------------------------------------------------------------- */
+/*        timeSpan        
+/*
+/*	Return the minimum start time and maximum end time
+ *  in seconds of all Partials in this PartialList. The v
+ *  times are returned in the (non-null) pointers tmin
+ *  and tmax.
+ */
+extern "C"
+void timeSpan( PartialList * partials, double * tmin, double * tmax )
+{
+    std::pair< double, double > times = 
+        PartialUtils::timeSpan( partials->begin(), partials->end() );	
+    if ( 0 != tmin )
+    {
+        *tmin = times.first;
+    }
+    if ( 0 != tmax )
+    {
+        *tmax = times.second;
+    }
+}
+
+/* ---------------------------------------------------------------- */
+/*        weightedAvgFrequency 
+/*       
+/*  Return the average frequency over all Breakpoints in this Partial, 
+    weighted by the Breakpoint amplitudes. Return zero if the Partial 
+    has no Breakpoints.
+ */
+extern "C"
+double weightedAvgFrequency( const Partial * p )
+{
+    try
+    {
+        ThrowIfNull((Partial *) p);
+        return PartialUtils::weightedAvgFrequency( *p );
+    }
+	catch( Exception & ex ) 
+	{
+		std::string s("Loris exception in weightedAvgFrequency(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}
+	catch( std::exception & ex ) 
+	{
+		std::string s("std C++ exception in weightedAvgFrequency(): " );
+		s.append( ex.what() );
+		handleException( s.c_str() );
+	}    
+
+    return 0;
+}
diff --git a/src/loris/phasefix.C b/src/loris/phasefix.C
new file mode 100644
index 0000000..b26deab
--- /dev/null
+++ b/src/loris/phasefix.C
@@ -0,0 +1,470 @@
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * phasefix.C
+ *
+ * Implements a phase correction algorithm that perturbs slightly the 
+ * frequencies or Breakpoints in a Partial so that the rendered Partial 
+ * will achieve (or be closer to) the analyzed Breakpoint phases.
+ *
+ * Kelly Fitz, 23 Sept 04
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#if HAVE_CONFIG_H
+	#include "config.h"
+#endif
+
+#include "phasefix.h"
+
+#include "Breakpoint.h"
+#include "BreakpointUtils.h"
+#include "LorisExceptions.h"
+#include "Notifier.h"
+#include "Partial.h"
+
+
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include <utility>
+
+#if defined(HAVE_M_PI) && (HAVE_M_PI)
+	const double Pi = M_PI;
+#else
+	const double Pi = 3.14159265358979324;
+#endif
+
+
+//	begin namespace
+namespace Loris {
+
+// -- local helpers -- 
+
+
+// ---------------------------------------------------------------------------
+//  wrapPi
+//	Wrap an unwrapped phase value to the range [-pi,pi] using
+//  O'Donnell's phase wrapping function.
+//
+double wrapPi( double x )
+{
+    using namespace std; // floor should be in std
+    #define ROUND(x) (floor(.5 + (x)))
+    const double TwoPi = 2.0*Pi;
+    return x + ( TwoPi * ROUND(-x/TwoPi) );
+}
+
+
+
+// ---------------------------------------------------------------------------
+//	phaseTravel
+//
+//	Compute the sinusoidal phase travel between two Breakpoints.
+//	Return the total unwrapped phase travel.
+//
+double phaseTravel( const Breakpoint & bp0, const Breakpoint & bp1, 
+					double dt )
+{
+	double f0 = bp0.frequency();
+	double f1 = bp1.frequency();
+	double favg = .5 * ( f0 + f1 );
+	return 2 * Pi * favg * dt;
+}
+
+// ---------------------------------------------------------------------------
+//	phaseTravel
+//
+//	Compute the sinusoidal phase travel between two Breakpoints.
+//	Return the total unwrapped phase travel.
+//
+static double phaseTravel( Partial::const_iterator bp0, Partial::const_iterator bp1 )
+{
+	return phaseTravel( bp0.breakpoint(), bp1.breakpoint(), 
+	                    bp1.time() - bp0.time() );
+}
+
+// -- phase correction -- 
+
+// ---------------------------------------------------------------------------
+//	fixPhaseBackward
+//
+//! Recompute phases of all Breakpoints on the half-open range [stopHere, pos)
+//! so that the synthesized phases of those Breakpoints matches 
+//! the stored phase, as long as the synthesized phase at stopHere
+//! matches the stored (not recomputed) phase.
+//!
+//! The phase is corrected beginning at the end of the range, maintaining
+//! the stored phase in the Breakpoint at pos.
+//!
+//! Backward phase-fixing stops if a null (zero-amplitude) Breakpoint
+//! is encountered, because nulls are interpreted as phase reset points
+//! in Loris. If a null is encountered, the remainder of the range
+//! (the front part) is fixed in the forward direction, beginning at
+//! the start of the stopHere.
+//!
+//! \pre    pos and stopHere are iterators on the same Partial, and
+//!         pos must be not later than stopHere.
+//! \pre    pos cannot be end of the Partial, it must be the postion
+//!         of a valid Breakpoint.
+//! \param  stopHere the position of the earliest Breakpoint whose phase might be
+//!         recomputed.
+//! \param  pos the position of a (later) Breakpoint whose phase is to be matched.
+//!         The phase at pos is not modified.
+//
+void fixPhaseBackward( Partial::iterator stopHere, Partial::iterator pos )
+{
+    while ( pos != stopHere && 
+            BreakpointUtils::isNonNull( pos.breakpoint() ) )
+    {
+        // pos is not the first Breakpoint in the Partial, 
+        // and pos is not a Null Breakpoint.
+        // Compute the correct phase for the
+        // predecessor of pos.
+        Partial::iterator posFwd = pos--;
+        double travel = phaseTravel( pos, posFwd );
+        pos.breakpoint().setPhase( wrapPi( posFwd.breakpoint().phase() - travel ) );
+    }
+    
+    // if a null was encountered, then stop fixing backwards,
+    // and fix the front of the Partial in the forward direction:
+    if ( pos != stopHere )
+    {
+        // pos is not the first Breakpoint in the Partial,
+        // and it is a Null Breakpoint (zero amplitude),
+        // so it will be used to reset the phase during 
+        // synthesis. 
+        // The phase of all Breakpoints starting with pos
+        // and ending with the Breakpoint nearest to time t
+        // has been corrected. 
+        // Fix phases before pos starting at the beginning
+        // of the Partial.
+        //
+        // Dont fix pos, it has already been fixed.
+        fixPhaseForward( stopHere, --pos );
+    }
+}
+
+// ----------------------------------------------------------------------- ----
+//	fixPhaseForward
+//
+//! Recompute phases of all Breakpoints on the closed range [pos, stopHere]
+//! so that the synthesized phases of those Breakpoints matches 
+//! the stored phase, as long as the synthesized phase at pos
+//! matches the stored (not recomputed) phase. The phase at pos 
+//! is modified only if pos is the position of a null Breakpoint
+//! and the Breakpoint that follows is non-null.
+//! 
+//! Phase fixing is only applied to non-null (nonzero-amplitude) Breakpoints,
+//! because null Breakpoints are interpreted as phase reset points in 
+//! Loris. If a null is encountered, its phase is corrected from its non-Null
+//! successor, if it has one, otherwise it is unmodified.
+//!
+//! \pre    pos and stopHere are iterators on the same Partial, and
+//!         pos must be not later than stopHere.
+//! \pre    stopHere cannot be end of the Partial, it must be the postion
+//!         of a valid Breakpoint.
+//! \param  pos the position of the first Breakpoint whose phase might be
+//!         recomputed.
+//! \param  stopHere the position of the last Breakpoint whose phase might
+//!         be modified.
+//
+void fixPhaseForward( Partial::iterator pos, Partial::iterator stopHere )
+{
+    while ( pos != stopHere )
+    {
+        Partial::iterator posPrev = pos++;
+        
+        //  update phase based on the phase travel between 
+        //  posPrev and pos UNLESS pos is Null:
+        if ( BreakpointUtils::isNonNull( pos.breakpoint() ) )
+        {
+            // pos is the position of a non-Null Breakpoint, 
+            // posPrev is its predecessor:            
+            double travel = phaseTravel( posPrev, pos );
+            
+            if ( BreakpointUtils::isNonNull( posPrev.breakpoint() ) )
+            {                        
+                // if its predecessor of pos is non-Null, then fix
+                // the phase of the Breakpoint at pos.
+                pos.breakpoint().setPhase( wrapPi( posPrev.breakpoint().phase() + travel ) );
+            }
+            else
+            {
+                // if the predecessor of pos is Null, then
+                // correct the predecessor's phase so that 
+                // it correctly resets the synthesis phase 
+                // so that the phase of the Breakpoint at 
+                // pos is achieved in synthesis.
+                posPrev.breakpoint().setPhase( wrapPi( pos.breakpoint().phase() - travel ) );
+            }
+        }
+    }
+}
+
+
+// ---------------------------------------------------------------------------
+//  fixPhaseBetween
+//
+//!	Fix the phase travel between two Breakpoints by adjusting the
+//!	frequency and phase of Breakpoints between those two.
+//!
+//!	This algorithm assumes that there is nothing interesting about the
+//!	phases of the intervening Breakpoints, and modifies their frequencies 
+//!	as little as possible to achieve the correct amount of phase travel 
+//!	such that the frequencies and phases at the specified times
+//!	match the stored values. The phases of all the Breakpoints between 
+//! the specified times are recomputed.
+//!
+//! Null Breakpoints are treated the same as non-null Breakpoints.
+//!
+//! \pre        b and e are iterators on the same Partials, and
+//!             e must not preceed b in that Partial.
+//! \pre        There must be at least one Breakpoint in the
+//!             Partial between b and e.
+//! \post       The phases and frequencies of the Breakpoints in the 
+//!             range have been recomputed such that an oscillator
+//!             initialized to the parameters of the first Breakpoint
+//!             will arrive at the parameters of the last Breakpoint,
+//!             and all the intervening Breakpoints will be matched.
+//! \param b    The phases and frequencies of Breakpoints later than
+//!             this one may be modified.
+//! \param e    The phases and frequencies of Breakpoints earlier than  
+//!             this one may be modified.
+//
+void fixPhaseBetween( Partial::iterator b, Partial::iterator e )
+{  
+    if ( 1 < std::distance( b, e ) )
+    {
+        //	Accumulate the actual phase travel over the Breakpoint
+        //	span, and count the envelope segments.
+        double travel = 0;
+        Partial::iterator next = b;
+        do
+        {
+            Partial::iterator prev = next++;
+            travel += phaseTravel( prev, next );
+        } while( next != e );
+
+        //	Compute the desired amount of phase travel:
+        double deviation = wrapPi( e.breakpoint().phase() - ( b.breakpoint().phase() + travel ) );
+        double desired = travel + deviation;
+        
+        //	Compute the amount by which to perturb the frequencies of
+        //	all the null Breakpoints between b and e.
+        //
+        //	The accumulated phase travel is the sum of the average frequency
+        //	(in radians) of each segment times the duration of each segment
+        //	(the actual phase travel is computed this way). If this sum is
+        //	computed with each Breakpoint frequency perturbed (additively) 
+        //	by delta, and set equal to the desired phase travel, then it
+        //	can be simplified to:
+        //		delta = 2 * ( phase error ) / ( tN + tN-1 - t1 - t0 )
+        //	where tN is the time of e, tN-1 is the time of its predecessor,
+        //	t0 is the time of b, and t1 is the time of b's successor.
+        //
+        Partial::iterator iter = b;
+        double t0 = iter.time();
+        ++iter;
+        double t1 = iter.time();
+        iter = e;
+        double tN = iter.time();
+        --iter;
+        double tNm1 = iter.time();
+        
+        Assert( t1 < tN );	//	else there were no Breakpoints in between
+        
+        double delta = ( 2 * ( desired - travel ) / ( tN + tNm1 - t1 - t0 ) ) / ( 2 * Pi );
+        
+        //	Perturb the Breakpoint frequencies.
+        next = b;
+        Partial::iterator prev = next++;
+        while ( next != e )
+        {
+            next.breakpoint().setFrequency( next.breakpoint().frequency() + delta );
+            
+            double newtravel = phaseTravel( prev, next );            
+            next.breakpoint().setPhase( wrapPi( prev.breakpoint().phase() + newtravel ) );
+            
+            prev = next++;
+        }
+    }
+    else
+    {
+        // Preconditions not met, cannot fix the phase travel.
+        // Should raise exception?
+        debugger << "cannot fix phase between " << b.time() << " and " << e.time()
+                 << ", there are no Breakpoints between those times" << endl;
+    }
+
+}
+
+// ---------------------------------------------------------------------------
+//	matchPhaseFwd
+//
+//!	Compute the target frequency that will affect the
+//!	predicted (by the Breakpoint phases) amount of
+//!	sinusoidal phase travel between two breakpoints, 
+//!	and assign that frequency to the target Breakpoint.
+//!	After computing the new frequency, update the phase of
+//!	the later Breakpoint.
+//!
+//! If the earlier Breakpoint is null and the later one
+//! is non-null, then update the phase of the earlier
+//! Breakpoint, and do not modify its frequency or the 
+//! later Breakpoint.
+//!
+//! The most common kinds of errors are local (or burst) errors in 
+//! frequency and phase. These errors are best corrected by correcting
+//! less than half the detected error at any time. Correcting more
+//! than that will produce frequency oscillations for the remainder of
+//! the Partial, in the case of a single bad frequency (as is common
+//! at the onset of a tone). Any damping factor less then one will 
+//! converge eventually, .5 or less will converge without oscillating.
+//! Use the damping argument to control the damping of the correction.
+//!	Specify 1 for no damping.
+//!
+//! \pre		The two Breakpoints are assumed to be consecutive in
+//!				a Partial.
+//! \param		bp0	The earlier Breakpoint.
+//! \param		bp1	The later Breakpoint.
+//! \param		dt The time (in seconds) between bp0 and bp1.
+//! \param		damping The fraction of the amount of phase error that will
+//!				be corrected (.5 or less will prevent frequency oscilation 
+//!				due to burst errors in phase). 
+//! \param		maxFixPct The maximum amount of frequency adjustment
+//!				that can be made to the frequency of bp1, expressed
+//!				as a precentage of the unmodified frequency of bp1.
+//!				If the necessary amount of frequency adjustment exceeds
+//!				this amount, then the phase will not be matched, 
+//!				but will be updated as well to be consistent with
+//!				the frequencies. (default is 0.2%)
+//
+void matchPhaseFwd( Breakpoint & bp0, Breakpoint & bp1,
+				    double dt, double damping, double maxFixPct )
+{
+	double travel = phaseTravel( bp0, bp1, dt );
+    
+    if ( ! BreakpointUtils::isNonNull( bp1 ) )
+    {
+        // if bp1 is null, DON'T compute a new phase,
+        // because Nulls are phase reset points.
+
+        // bp1.setPhase( wrapPi( bp0.phase() + travel ) );
+    }
+    else if ( ! BreakpointUtils::isNonNull( bp0 ) )
+    {
+        // if bp0 is null, and bp1 is not, then bp0
+        // should be a phase reset Breakpoint during
+        // rendering, so compute a new phase for
+        // bp0 that achieves bp1's phase.
+        bp0.setPhase( wrapPi( bp1.phase() - travel ) ) ;
+    } 
+    else
+    {
+        // invariant:
+        // neither bp0 nor bp1 is null
+        //
+        // modify frequecies to match phases as nearly as possible
+        double err = wrapPi( bp1.phase() - ( bp0.phase() + travel ) );
+        
+        //  The most common kinds of errors are local (or burst) errors in 
+        //  frequency and phase. These errors are best corrected by correcting
+        //  less than half the detected error at any time. Correcting more
+        //  than that will produce frequency oscillations for the remainder of
+        //  the Partial, in the case of a single bad frequency (as is common
+        //  at the onset of a tone). Any damping factor less then one will 
+        //  converge eventually, .5 or less will converge without oscillating.
+        //  #define DAMPING .5
+        travel += damping * err;
+        
+        double f0 = bp0.frequency();
+        double ftgt = ( travel / ( Pi * dt ) ) - f0;
+        
+        #ifdef Loris_Debug
+        debugger << "matchPhaseFwd: correcting " << bp1.frequency() << " to " << ftgt 
+                 << " (phase " << wrapPi( bp1.phase() ) << "), ";
+        #endif
+        
+        //	If the target is not a null breakpoint, may need to 
+        //	clamp the amount of frequency modification.
+        if ( ftgt > bp1.frequency() * ( 1 + (maxFixPct*.01) ) )
+        {
+            ftgt = bp1.frequency() * ( 1 + (maxFixPct*.01) );
+        }
+        else if ( ftgt < bp1.frequency() * ( 1 - (maxFixPct*.01) ) )
+        {
+            ftgt = bp1.frequency() * ( 1 - (maxFixPct*.01) );
+        }
+
+        bp1.setFrequency( ftgt );
+        
+        //	Recompute the phase according to the new frequency.
+        double phi = wrapPi( bp0.phase() + phaseTravel( bp0, bp1, dt ) );
+        bp1.setPhase( phi );
+
+        #ifdef Loris_Debug
+        debugger << "achieved " << ftgt << " (phase " << phi << ")" << endl;
+        #endif
+    }
+}
+
+// ---------------------------------------------------------------------------
+//	fixFrequency
+//
+//!	Adjust frequencies of the Breakpoints in the 
+//! specified Partial such that the rendered Partial 
+//!	achieves (or matches as nearly as possible, within 
+//!	the constraint of the maximum allowable frequency
+//! alteration) the analyzed phases. 
+//!
+//! This just iterates over the Partial calling
+//! matchPhaseFwd, should probably name those similarly.
+//!
+//!  \param     partial The Partial whose frequencies,
+//!             and possibly phases (if the frequencies
+//!             cannot be sufficiently altered to match
+//!             the phases), will be recomputed.
+//!  \param     maxFixPct The maximum allowable frequency 
+//!             alteration, default is 0.2%.
+//
+void fixFrequency( Partial & partial, double maxFixPct )
+{	
+	if ( partial.numBreakpoints() > 1 )
+	{	
+		Partial::iterator next = partial.begin();
+		Partial::iterator prev = next++;
+		while ( next != partial.end() )		
+		{
+		    if ( BreakpointUtils::isNonNull( next.breakpoint() ) )
+		    {
+			    matchPhaseFwd( prev.breakpoint(), next.breakpoint(), 
+				    		   next.time() - prev.time(), 0.5, maxFixPct );
+		    }
+			prev = next++;
+		}
+    }
+}
+
+}	//	end of namespace Loris
diff --git a/src/loris/phasefix.h b/src/loris/phasefix.h
new file mode 100644
index 0000000..016983d
--- /dev/null
+++ b/src/loris/phasefix.h
@@ -0,0 +1,237 @@
+#ifndef PHASEFIX_H
+#define PHASEFIX_H
+/*
+ * This is the Loris C++ Class Library, implementing analysis, 
+ * manipulation, and synthesis of digitized sounds using the Reassigned 
+ * Bandwidth-Enhanced Additive Sound Model.
+ *
+ * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY, without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * phasefix.h
+ *
+ * Functions for correcting Breakpoint phases and frequencies so that
+ * stored phases match the phases that would be synthesized using the
+ * Loris Synthesizer.
+ *
+ * Kelly Fitz, 23 Sept 04
+ * loris@cerlsoundgroup.org
+ *
+ * http://www.cerlsoundgroup.org/Loris/
+ *
+ */
+#include "Partial.h"
+
+//	begin namespace
+namespace Loris {
+
+//  FUNCTION PROTOYPES
+
+//	fixPhaseBackward
+//
+//! Recompute phases of all Breakpoints on the half-open range [stopHere, pos)
+//! so that the synthesized phases of those Breakpoints matches 
+//! the stored phase, as long as the synthesized phase at stopHere
+//! matches the stored (not recomputed) phase.
+//!
+//! The phase is corrected beginning at the end of the range, maintaining
+//! the stored phase in the Breakpoint at pos.
+//!
+//! Backward phase-fixing stops if a null (zero-amplitude) Breakpoint
+//! is encountered, because nulls are interpreted as phase reset points
+//! in Loris. If a null is encountered, the remainder of the range
+//! (the front part) is fixed in the forward direction, beginning at
+//! the start of the stopHere.
+//!
+//! \pre    pos and stopHere are iterators on the same Partial, and
+//!         pos must be not later than stopHere.
+//! \pre    pos cannot be end of the Partial, it must be the postion
+//!         of a valid Breakpoint.
+//! \param  stopHere the position of the earliest Breakpoint whose phase might be
+//!         recomputed.
+//! \param  pos the position of a (later) Breakpoint whose phase is to be matched.
+//!         The phase at pos is not modified.
+//
+void fixPhaseBackward( Partial::iterator stopHere, Partial::iterator pos );
+
+//	fixPhaseForward
+//
+//! Recompute phases of all Breakpoints on the closed range [pos, stopHere]
+//! so that the synthesized phases of those Breakpoints matches 
+//! the stored phase, as long as the synthesized phase at pos
+//! matches the stored (not recomputed) phase. The phase at pos 
+//! is modified only if pos is the position of a null Breakpoint
+//! and the Breakpoint that follows is non-null.
+//! 
+//! Phase fixing is only applied to non-null (nonzero-amplitude) Breakpoints,
+//! because null Breakpoints are interpreted as phase reset points in 
+//! Loris. If a null is encountered, its phase is corrected from its non-Null
+//! successor, if it has one, otherwise it is unmodified.
+//!
+//! \pre    pos and stopHere are iterators on the same Partial, and
+//!         pos must be not later than stopHere.
+//! \pre    stopHere cannot be end of the Partial, it must be the postion
+//!         of a valid Breakpoint.
+//! \param  pos the position of the first Breakpoint whose phase might be
+//!         recomputed.
+//! \param  stopHere the position of the last Breakpoint whose phase might
+//!         be modified.
+//
+void fixPhaseForward( Partial::iterator pos, Partial::iterator stopHere );
+
+// ---------------------------------------------------------------------------
+//  fixPhaseBetween
+//
+//!	Fix the phase travel between two Breakpoints by adjusting the
+//!	frequency and phase of Breakpoints between those two.
+//!
+//!	This algorithm assumes that there is nothing interesting about the
+//!	phases of the intervening Breakpoints, and modifies their frequencies 
+//!	as little as possible to achieve the correct amount of phase travel 
+//!	such that the frequencies and phases at the specified times
+//!	match the stored values. The phases of all the Breakpoints between 
+//! the specified times are recomputed.
+//!
+//! Null Breakpoints are treated the same as non-null Breakpoints.
+//!
+//! \pre        b and e are iterators on the same Partials, and
+//!             e must not preceed b in that Partial.
+//! \pre        There must be at least one Breakpoint in the
+//!             Partial between b and e.
+//! \post       The phases and frequencies of the Breakpoints in the 
+//!             range have been recomputed such that an oscillator
+//!             initialized to the parameters of the first Breakpoint
+//!             will arrive at the parameters of the last Breakpoint,
+//!             and all the intervening Breakpoints will be matched.
+//! \param b    The phases and frequencies of Breakpoints later than
+//!             this one may be modified.
+//! \param e    The phases and frequencies of Breakpoints earlier than  
+//!             this one may be modified.
+//
+void fixPhaseBetween( Partial::iterator b, Partial::iterator e );
+
+//	fixFrequency
+//
+//!	Adjust frequencies of the Breakpoints in the 
+//! specified Partial such that the rendered Partial 
+//!	achieves (or matches as nearly as possible, within 
+//!	the constraint of the maximum allowable frequency
+//! alteration) the analyzed phases. 
+//!
+//!  \param     partial The Partial whose frequencies,
+//!             and possibly phases (if the frequencies
+//!             cannot be sufficiently altered to match
+//!             the phases), will be recomputed.
+//!  \param     maxFixPct The maximum allowable frequency 
+//!             alteration, default is 0.2%.
+//
+void fixFrequency( Partial & partial, double maxFixPct = 0.2 );
+
+//	fixFrequency
+//
+//!	Adjust frequencies of the Breakpoints in the 
+//! specified Partials such that the rendered Partial 
+//!	achieves (or matches as nearly as possible, within 
+//!	the constraint of the maximum allowable frequency
+//! alteration) the analyzed phases. 
+//!
+//! \param		b The beginning of a range of Partials whose 
+//!             frequencies should be fixed.
+//! \param		e The end of a range of Partials whose frequencies 
+//!             should be fixed.
+//! \param		maxFixPct The maximum allowable frequency 
+//!             alteration, default is 0.2%.
+//
+template < class Iter >
+void fixFrequency( Iter b, Iter e, double maxFixPct = 0.2 )
+{
+    while ( b != e )
+    {
+        fixFrequency( *b, maxFixPct );
+        ++b;
+    }
+}
+
+// --------------------- useful phase maintenance utilities ---------------------
+
+//	matchPhaseFwd
+//
+//!	Compute the target frequency that will affect the
+//!	predicted (by the Breakpoint phases) amount of
+//!	sinusoidal phase travel between two breakpoints, 
+//!	and assign that frequency to the target Breakpoint.
+//!	After computing the new frequency, update the phase of
+//!	the later Breakpoint.
+//!
+//! The most common kinds of errors are local (or burst) errors in 
+//! frequency and phase. These errors are best corrected by correcting
+//! less than half the detected error at any time. Correcting more
+//! than that will produce frequency oscillations for the remainder of
+//! the Partial, in the case of a single bad frequency (as is common
+//! at the onset of a tone). Any damping factor less then one will 
+//! converge eventually, .5 or less will converge without oscillating.
+//! Use the damping argument to control the damping of the correction.
+//!	Specify 1 for no damping.
+//!
+//!
+//! \pre		The two Breakpoints are assumed to be consecutive in
+//!				a Partial.
+//! \param		bp0	The earlier Breakpoint.
+//! \param		bp1	The later Breakpoint.
+//! \param		dt The time (in seconds) between bp0 and bp1.
+//! \param		damping The fraction of the amount of phase error that will
+//!				be corrected (.5 or less will prevent frequency oscilation 
+//!				due to burst errors in phase). 
+//! \param		maxFixPct The maximum amount of frequency adjustment
+//!				that can be made to the frequency of bp1, expressed
+//!				as a precentage of the unmodified frequency of bp1.
+//!				If the necessary amount of frequency adjustment exceeds
+//!				this amount, then the phase will not be matched, 
+//!				but will be updated as well to be consistent with
+//!				the frequencies. (default is 0.2%)
+//
+void matchPhaseFwd( Breakpoint & bp0, Breakpoint & bp1,
+				    double dt, double damping, double maxFixPct = 0.2 );
+
+//	phaseTravel
+//
+//!	Compute the sinusoidal phase travel between two Breakpoints.
+//!	Return the total unwrapped phase travel.
+//!
+//! \pre		The two Breakpoints are assumed to be consecutive in
+//!				a Partial.
+//! \param		bp0	The earlier Breakpoint.
+//! \param		bp1	The later Breakpoint.
+//! \param		dt The time (in seconds) between bp0 and bp1.
+//! \return		The total unwrapped phase travel in radians.
+//
+double phaseTravel( const Breakpoint & bp0, const Breakpoint & bp1, double dt );
+
+//	wrapPi
+//
+//!	Wrap an unwrapped phase value to the range (-pi,pi].
+//!
+//! \param		x The unwrapped phase in radians.
+//! \return		The phase (in radians) wrapped to the range (-Pi,Pi].
+//
+double wrapPi( double x );
+
+
+}	//	end of namespace Loris
+
+#endif // ndef PHASEFIX_H
+