/Users/kfitz/Projects/Loris/Loris development/src/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-2010 by Kelly Fitz and Lippold Haken
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY, without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 * AiffFile.h
 *
 * Definition of AiffFile class for sample import and export in Loris.
 *
 * Kelly Fitz, 8 Jan 2003 
 * loris@cerlsoundgroup.org
 *
 * http://www.cerlsoundgroup.org/Loris/
 *
 */
#include "Marker.h"
#include "Synthesizer.h"

#if defined(NO_TEMPLATE_MEMBERS)
#include "PartialList.h"
#endif

#include <memory>
#include <string>
#include <vector>

//  begin namespace
namespace Loris {

class Partial;

// ---------------------------------------------------------------------------
//  class AiffFile
//
//  
class AiffFile
{
//  -- 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 = FadeTimeUnspecified );
#else
    AiffFile( PartialList::const_iterator begin_partials, 
              PartialList::const_iterator end_partials,
              double samplerate, double fadeTime = FadeTimeUnspecified ); 
#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 = FadeTimeUnspecified );
     
#if !defined(NO_TEMPLATE_MEMBERS)
    template<typename Iter>
    void addPartials( Iter begin_partials, Iter end_partials, 
                                  double fadeTime = FadeTimeUnspecified  );
#else
    void addPartials( PartialList::const_iterator begin_partials, 
                      PartialList::const_iterator end_partials,
                      double fadeTime = FadeTimeUnspecified  );
#endif

    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]


//  -- helpers --

        //      Construct a Synthesizer for rendering Partials and set its fadeTime.
        //      Modify the default synthesizer parameters with this file's sample rate
        //      and, if specified (not equal to FadeTimeUnspecified), the fade time.
        Synthesizer configureSynthesizer( double fadeTime );

        //      Import data from an AIFF file on disk.
    void readAiffData( const std::string & filename );
    
    enum { FadeTimeUnspecified = -9999999 };
    //  This is not pretty, but it is better (perhaps) than defining two 
    //  of every member having an optional fade time parameter.

};  //  end of class AiffFile

// -- template members --

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

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

}   //  end of namespace Loris

---