Start adding Loris files

1 files changed, 1597 insertions, 0 deletions

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