diff options
Diffstat (limited to 'src/loris/lorisAnalyzer_pi.C')
| -rw-r--r-- | src/loris/lorisAnalyzer_pi.C | 1014 |
1 files changed, 1014 insertions, 0 deletions
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; +} + + + + + |