AiffFile.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-2007 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
{
//  -- public interface --
public:

//  -- types --

    typedef std::vector< double > samples_type;
    
    typedef samples_type::size_type size_type;
    
    typedef std::vector< Marker > markers_type;

//  -- construction --

    explicit AiffFile( const std::string & filename );

#if !defined(NO_TEMPLATE_MEMBERS)
    template<typename Iter>
    AiffFile( Iter begin_partials, Iter end_partials, 
              double samplerate, double fadeTime = .001 ); // default fade is 1ms
#else
    AiffFile( PartialList::const_iterator begin_partials, 
              PartialList::const_iterator end_partials,
              double samplerate, double fadeTime = .001 ); // default fade is 1ms
#endif

    AiffFile( double samplerate, size_type numFrames = 0, 
              unsigned int numChannels = 1 );
    
    AiffFile( const double * buffer, size_type bufferlength, double samplerate );

    //
    AiffFile( const double * buffer_left, const double * buffer_right, 
              size_type bufferlength, double samplerate );
     
    AiffFile( const std::vector< double > & vec, double samplerate );
    
    //
    AiffFile( const std::vector< double > & vec_left,
              const std::vector< double > & vec_right, 
              double samplerate );    
     
    AiffFile( const AiffFile & other );
     
    AiffFile & operator= ( const AiffFile & rhs );

//  -- access --

    markers_type & markers( void );

    const markers_type & markers( void ) const;
     
    double midiNoteNumber( void ) const;

    unsigned int numChannels( void ) const;

    size_type numFrames( void ) const;

    size_type sampleFrames( void ) const { return numFrames(); }

    double sampleRate( void ) const;
    
    samples_type & samples( void );

    const samples_type & samples( void ) const;

//  -- mutation --

    void addPartial( const Loris::Partial & p, double fadeTime = .001 /* 1 ms */ );
     
#if !defined(NO_TEMPLATE_MEMBERS)
    template<typename Iter>
    void addPartials( Iter begin_partials, Iter end_partials, double fadeTime = .001 /* 1 ms */  );
#else
    void addPartials( PartialList::const_iterator begin_partials, 
                      PartialList::const_iterator end_partials,
                      double fadeTime = .001 /* 1 ms */  );
#endif

    void setMidiNoteNumber( double nn );
     
//  -- export --

    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]

    std::auto_ptr< Synthesizer > psynth_;   //  Synthesizer for rendering Partials,
                                            //  lazy-initialized (not until needed)

//  -- helpers --
    void configureSynthesizer( double fadeTime );
    void readAiffData( const std::string & filename );

};  //  end of class AiffFile

// -- template members --

// ---------------------------------------------------------------------------
//  constructor from Partial range
// ---------------------------------------------------------------------------
//
#if !defined(NO_TEMPLATE_MEMBERS)
template< typename Iter >
 AiffFile::AiffFile( Iter begin_partials, Iter end_partials, 
                     double samplerate, double fadeTime ) : // default fade is 1ms
#else
 AiffFile::AiffFile( PartialList::const_iterator begin_partials, 
                     PartialList::const_iterator end_partials,
                     double samplerate, double fadeTime ) : // default fade is 1ms
#endif
//  initializers:
    notenum_( 60 ),
    rate_( samplerate ),
    numchans_( 1 )
{
    addPartials( begin_partials, end_partials, fadeTime );
}

// ---------------------------------------------------------------------------
//  addPartials 
// ---------------------------------------------------------------------------
//
#if !defined(NO_TEMPLATE_MEMBERS)
template< typename Iter >
void 
 AiffFile::addPartials( Iter begin_partials, Iter end_partials, double fadeTime /*= .001  1 ms */  )
#else
void 
 AiffFile::addPartials( PartialList::const_iterator begin_partials, 
                        PartialList::const_iterator end_partials,
                        double fadeTime /* = .001 1 ms */  )
#endif
{ 
    configureSynthesizer( fadeTime );
    psynth_->synthesize( begin_partials, end_partials );
} 

}   //  end of namespace Loris

---