8 files changed, 1506 insertions, 0 deletions
diff --git a/pysoundtouch/src/WavFile.cpp b/pysoundtouch/src/WavFile.cpp
new file mode 100644
index 0000000..47af5a2
--- /dev/null
+++ b/pysoundtouch/src/WavFile.cpp
@@ -0,0 +1,745 @@
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Classes for easy reading & writing of WAV sound files. 
+///
+/// For big-endian CPU, define _BIG_ENDIAN_ during compile-time to correctly
+/// parse the WAV files with such processors.
+/// 
+/// Admittingly, more complete WAV reader routines may exist in public domain,
+/// but the reason for 'yet another' one is that those generic WAV reader 
+/// libraries are exhaustingly large and cumbersome! Wanted to have something
+/// simpler here, i.e. something that's not already larger than rest of the
+/// SoundTouch/SoundStretch program...
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// Last changed  : $Date$
+// File revision : $Revision: 4 $
+//
+// $Id$
+//
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library 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
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+#include <stdexcept>
+#include <string>
+#include <cstring>
+#include <assert.h>
+#include <limits.h>
+
+#include "WavFile.h"
+
+using namespace std;
+
+static const char riffStr[] = "RIFF";
+static const char waveStr[] = "WAVE";
+static const char fmtStr[]  = "fmt ";
+static const char dataStr[] = "data";
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Helper functions for swapping byte order to correctly read/write WAV files 
+// with big-endian CPU's: Define compile-time definition _BIG_ENDIAN_ to
+// turn-on the conversion if it appears necessary. 
+//
+// For example, Intel x86 is little-endian and doesn't require conversion,
+// while PowerPC of Mac's and many other RISC cpu's are big-endian.
+
+#ifdef BYTE_ORDER
+    // In gcc compiler detect the byte order automatically
+    #if BYTE_ORDER == BIG_ENDIAN
+        // big-endian platform.
+        #define _BIG_ENDIAN_
+    #endif
+#endif
+    
+#ifdef _BIG_ENDIAN_
+    // big-endian CPU, swap bytes in 16 & 32 bit words
+
+    // helper-function to swap byte-order of 32bit integer
+    static inline void _swap32(unsigned int &dwData)
+    {
+        dwData = ((dwData >> 24) & 0x000000FF) | 
+                 ((dwData >> 8)  & 0x0000FF00) | 
+                 ((dwData << 8)  & 0x00FF0000) | 
+                 ((dwData << 24) & 0xFF000000);
+    }   
+
+    // helper-function to swap byte-order of 16bit integer
+    static inline void _swap16(unsigned short &wData)
+    {
+        wData = ((wData >> 8) & 0x00FF) | 
+                ((wData << 8) & 0xFF00);
+    }
+
+    // helper-function to swap byte-order of buffer of 16bit integers
+    static inline void _swap16Buffer(unsigned short *pData, unsigned int dwNumWords)
+    {
+        unsigned long i;
+
+        for (i = 0; i < dwNumWords; i ++)
+        {
+            _swap16(pData[i]);
+        }
+    }
+
+#else   // BIG_ENDIAN
+    // little-endian CPU, WAV file is ok as such
+
+    // dummy helper-function
+    static inline void _swap32(unsigned int &dwData)
+    {
+        // do nothing
+    }   
+
+    // dummy helper-function
+    static inline void _swap16(unsigned short &wData)
+    {
+        // do nothing
+    }
+
+    // dummy helper-function
+    static inline void _swap16Buffer(unsigned short *pData, unsigned int dwNumBytes)
+    {
+        // do nothing
+    }
+
+#endif  // BIG_ENDIAN
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Class WavInFile
+//
+
+WavInFile::WavInFile(const char *fileName)
+{
+    // Try to open the file for reading
+    fptr = fopen(fileName, "rb");
+    if (fptr == NULL) 
+    {
+        // didn't succeed
+        string msg = "Error : Unable to open file \"";
+        msg += fileName;
+        msg += "\" for reading.";
+        throw runtime_error(msg);
+    }
+
+    init();
+}
+
+
+WavInFile::WavInFile(FILE *file)
+{
+    // Try to open the file for reading
+    fptr = file;
+    if (!file) 
+    {
+        // didn't succeed
+        string msg = "Error : Unable to access input stream for reading";
+        throw runtime_error(msg);
+    }
+
+    init();
+}
+
+
+/// Init the WAV file stream
+void WavInFile::init()
+{
+    int hdrsOk;
+
+    // assume file stream is already open
+    assert(fptr);
+
+    // Read the file headers
+    hdrsOk = readWavHeaders();
+    if (hdrsOk != 0) 
+    {
+        // Something didn't match in the wav file headers 
+        string msg = "Input file is corrupt or not a WAV file";
+        throw runtime_error(msg);
+    }
+
+    if (header.format.fixed != 1)
+    {
+        string msg = "Input file uses unsupported encoding.";
+        throw runtime_error(msg);
+    }
+
+    dataRead = 0;
+}
+
+
+
+WavInFile::~WavInFile()
+{
+    if (fptr) fclose(fptr);
+    fptr = NULL;
+}
+
+
+
+void WavInFile::rewind()
+{
+    int hdrsOk;
+
+    fseek(fptr, 0, SEEK_SET);
+    hdrsOk = readWavHeaders();
+    assert(hdrsOk == 0);
+    dataRead = 0;
+}
+
+
+int WavInFile::checkCharTags() const
+{
+    // header.format.fmt should equal to 'fmt '
+    if (memcmp(fmtStr, header.format.fmt, 4) != 0) return -1;
+    // header.data.data_field should equal to 'data'
+    if (memcmp(dataStr, header.data.data_field, 4) != 0) return -1;
+
+    return 0;
+}
+
+
+int WavInFile::read(char *buffer, int maxElems)
+{
+    int numBytes;
+    uint afterDataRead;
+
+    // ensure it's 8 bit format
+    if (header.format.bits_per_sample != 8)
+    {
+        throw runtime_error("Error: WavInFile::read(char*, int) works only with 8bit samples.");
+    }
+    assert(sizeof(char) == 1);
+
+    numBytes = maxElems;
+    afterDataRead = dataRead + numBytes;
+    if (afterDataRead > header.data.data_len) 
+    {
+        // Don't read more samples than are marked available in header
+        numBytes = (int)header.data.data_len - (int)dataRead;
+        assert(numBytes >= 0);
+    }
+
+    assert(buffer);
+    numBytes = fread(buffer, 1, numBytes, fptr);
+    dataRead += numBytes;
+
+    return numBytes;
+}
+
+
+int WavInFile::read(short *buffer, int maxElems)
+{
+    unsigned int afterDataRead;
+    int numBytes;
+    int numElems;
+
+    assert(buffer);
+    if (header.format.bits_per_sample == 8)
+    {
+        // 8 bit format
+        char *temp = new char[maxElems];
+        int i;
+
+        numElems = read(temp, maxElems);
+        // convert from 8 to 16 bit
+        for (i = 0; i < numElems; i ++)
+        {
+            buffer[i] = temp[i] << 8;
+        }
+        delete[] temp;
+    }
+    else
+    {
+        // 16 bit format
+        assert(header.format.bits_per_sample == 16);
+        assert(sizeof(short) == 2);
+
+        numBytes = maxElems * 2;
+        afterDataRead = dataRead + numBytes;
+        if (afterDataRead > header.data.data_len) 
+        {
+            // Don't read more samples than are marked available in header
+            numBytes = (int)header.data.data_len - (int)dataRead;
+            assert(numBytes >= 0);
+        }
+
+        numBytes = fread(buffer, 1, numBytes, fptr);
+        dataRead += numBytes;
+        numElems = numBytes / 2;
+
+        // 16bit samples, swap byte order if necessary
+        _swap16Buffer((unsigned short *)buffer, numElems);
+    }
+
+    return numElems;
+}
+
+
+
+int WavInFile::read(float *buffer, int maxElems)
+{
+    short *temp = new short[maxElems];
+    int num;
+    int i;
+    double fscale;
+
+    num = read(temp, maxElems);
+
+    fscale = 1.0 / 32768.0;
+    // convert to floats, scale to range [-1..+1[
+    for (i = 0; i < num; i ++)
+    {
+        buffer[i] = (float)(fscale * (double)temp[i]);
+    }
+
+    delete[] temp;
+
+    return num;
+}
+
+
+int WavInFile::eof() const
+{
+    // return true if all data has been read or file eof has reached
+    return (dataRead == header.data.data_len || feof(fptr));
+}
+
+
+
+// test if character code is between a white space ' ' and little 'z'
+static int isAlpha(char c)
+{
+    return (c >= ' ' && c <= 'z') ? 1 : 0;
+}
+
+
+// test if all characters are between a white space ' ' and little 'z'
+static int isAlphaStr(const char *str)
+{
+    char c;
+
+    c = str[0];
+    while (c) 
+    {
+        if (isAlpha(c) == 0) return 0;
+        str ++;
+        c = str[0];
+    }
+
+    return 1;
+}
+
+
+int WavInFile::readRIFFBlock()
+{
+    if (fread(&(header.riff), sizeof(WavRiff), 1, fptr) != 1) return -1;
+
+    // swap 32bit data byte order if necessary
+    _swap32((unsigned int &)header.riff.package_len);
+
+    // header.riff.riff_char should equal to 'RIFF');
+    if (memcmp(riffStr, header.riff.riff_char, 4) != 0) return -1;
+    // header.riff.wave should equal to 'WAVE'
+    if (memcmp(waveStr, header.riff.wave, 4) != 0) return -1;
+
+    return 0;
+}
+
+
+
+
+int WavInFile::readHeaderBlock()
+{
+    char label[5];
+    string sLabel;
+
+    // lead label string
+    if (fread(label, 1, 4, fptr) !=4) return -1;
+    label[4] = 0;
+
+    if (isAlphaStr(label) == 0) return -1;    // not a valid label
+
+    // Decode blocks according to their label
+    if (strcmp(label, fmtStr) == 0)
+    {
+        int nLen, nDump;
+
+        // 'fmt ' block 
+        memcpy(header.format.fmt, fmtStr, 4);
+
+        // read length of the format field
+        if (fread(&nLen, sizeof(int), 1, fptr) != 1) return -1;
+        // swap byte order if necessary
+        _swap32((unsigned int &)nLen); // int format_len;
+        header.format.format_len = nLen;
+
+        // calculate how much length differs from expected
+        nDump = nLen - ((int)sizeof(header.format) - 8);
+
+        // if format_len is larger than expected, read only as much data as we've space for
+        if (nDump > 0)
+        {
+            nLen = sizeof(header.format) - 8;
+        }
+
+        // read data
+        if (fread(&(header.format.fixed), nLen, 1, fptr) != 1) return -1;
+
+        // swap byte order if necessary
+        _swap16((unsigned short &)header.format.fixed);            // short int fixed;
+        _swap16((unsigned short &)header.format.channel_number);   // short int channel_number;
+        _swap32((unsigned int   &)header.format.sample_rate);      // int sample_rate;
+        _swap32((unsigned int   &)header.format.byte_rate);        // int byte_rate;
+        _swap16((unsigned short &)header.format.byte_per_sample);  // short int byte_per_sample;
+        _swap16((unsigned short &)header.format.bits_per_sample);  // short int bits_per_sample;
+
+        // if format_len is larger than expected, skip the extra data
+        if (nDump > 0)
+        {
+            fseek(fptr, nDump, SEEK_CUR);
+        }
+
+        return 0;
+    }
+    else if (strcmp(label, dataStr) == 0)
+    {
+        // 'data' block
+        memcpy(header.data.data_field, dataStr, 4);
+        if (fread(&(header.data.data_len), sizeof(uint), 1, fptr) != 1) return -1;
+
+        // swap byte order if necessary
+        _swap32((unsigned int &)header.data.data_len);
+
+        return 1;
+    }
+    else
+    {
+        uint len, i;
+        uint temp;
+        // unknown block
+
+        // read length
+        if (fread(&len, sizeof(len), 1, fptr) != 1) return -1;
+        // scan through the block
+        for (i = 0; i < len; i ++)
+        {
+            if (fread(&temp, 1, 1, fptr) != 1) return -1;
+            if (feof(fptr)) return -1;   // unexpected eof
+        }
+    }
+    return 0;
+}
+
+
+int WavInFile::readWavHeaders()
+{
+    int res;
+
+    memset(&header, 0, sizeof(header));
+
+    res = readRIFFBlock();
+    if (res) return 1;
+    // read header blocks until data block is found
+    do
+    {
+        // read header blocks
+        res = readHeaderBlock();
+        if (res < 0) return 1;  // error in file structure
+    } while (res == 0);
+    // check that all required tags are legal
+    return checkCharTags();
+}
+
+
+uint WavInFile::getNumChannels() const
+{
+    return header.format.channel_number;
+}
+
+
+uint WavInFile::getNumBits() const
+{
+    return header.format.bits_per_sample;
+}
+
+
+uint WavInFile::getBytesPerSample() const
+{
+    return getNumChannels() * getNumBits() / 8;
+}
+
+
+uint WavInFile::getSampleRate() const
+{
+    return header.format.sample_rate;
+}
+
+
+
+uint WavInFile::getDataSizeInBytes() const
+{
+    return header.data.data_len;
+}
+
+
+uint WavInFile::getNumSamples() const
+{
+    if (header.format.byte_per_sample == 0) return 0;
+    return header.data.data_len / (unsigned short)header.format.byte_per_sample;
+}
+
+
+uint WavInFile::getLengthMS() const
+{
+   uint numSamples;
+   uint sampleRate;
+
+   numSamples = getNumSamples();
+   sampleRate = getSampleRate();
+
+   assert(numSamples < UINT_MAX / 1000);
+   return (1000 * numSamples / sampleRate);
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Class WavOutFile
+//
+
+WavOutFile::WavOutFile(const char *fileName, int sampleRate, int bits, int channels)
+{
+    bytesWritten = 0;
+    fptr = fopen(fileName, "wb");
+    if (fptr == NULL) 
+    {
+        string msg = "Error : Unable to open file \"";
+        msg += fileName;
+        msg += "\" for writing.";
+        //pmsg = msg.c_str;
+        throw runtime_error(msg);
+    }
+
+    fillInHeader(sampleRate, bits, channels);
+    writeHeader();
+}
+
+
+WavOutFile::WavOutFile(FILE *file, int sampleRate, int bits, int channels)
+{
+    bytesWritten = 0;
+    fptr = file;
+    if (fptr == NULL) 
+    {
+        string msg = "Error : Unable to access output file stream.";
+        throw runtime_error(msg);
+    }
+
+    fillInHeader(sampleRate, bits, channels);
+    writeHeader();
+}
+
+
+
+WavOutFile::~WavOutFile()
+{
+    finishHeader();
+    if (fptr) fclose(fptr);
+    fptr = NULL;
+}
+
+
+
+void WavOutFile::fillInHeader(uint sampleRate, uint bits, uint channels)
+{
+    // fill in the 'riff' part..
+
+    // copy string 'RIFF' to riff_char
+    memcpy(&(header.riff.riff_char), riffStr, 4);
+    // package_len unknown so far
+    header.riff.package_len = 0;
+    // copy string 'WAVE' to wave
+    memcpy(&(header.riff.wave), waveStr, 4);
+
+
+    // fill in the 'format' part..
+
+    // copy string 'fmt ' to fmt
+    memcpy(&(header.format.fmt), fmtStr, 4);
+
+    header.format.format_len = 0x10;
+    header.format.fixed = 1;
+    header.format.channel_number = (short)channels;
+    header.format.sample_rate = (int)sampleRate;
+    header.format.bits_per_sample = (short)bits;
+    header.format.byte_per_sample = (short)(bits * channels / 8);
+    header.format.byte_rate = header.format.byte_per_sample * (int)sampleRate;
+    header.format.sample_rate = (int)sampleRate;
+
+    // fill in the 'data' part..
+
+    // copy string 'data' to data_field
+    memcpy(&(header.data.data_field), dataStr, 4);
+    // data_len unknown so far
+    header.data.data_len = 0;
+}
+
+
+void WavOutFile::finishHeader()
+{
+    // supplement the file length into the header structure
+    header.riff.package_len = bytesWritten + 36;
+    header.data.data_len = bytesWritten;
+
+    writeHeader();
+}
+
+
+
+void WavOutFile::writeHeader()
+{
+    WavHeader hdrTemp;
+    int res;
+
+    // swap byte order if necessary
+    hdrTemp = header;
+    _swap32((unsigned int   &)hdrTemp.riff.package_len);
+    _swap32((unsigned int   &)hdrTemp.format.format_len);
+    _swap16((unsigned short &)hdrTemp.format.fixed);
+    _swap16((unsigned short &)hdrTemp.format.channel_number);
+    _swap32((unsigned int   &)hdrTemp.format.sample_rate);
+    _swap32((unsigned int   &)hdrTemp.format.byte_rate);
+    _swap16((unsigned short &)hdrTemp.format.byte_per_sample);
+    _swap16((unsigned short &)hdrTemp.format.bits_per_sample);
+    _swap32((unsigned int   &)hdrTemp.data.data_len);
+
+    // write the supplemented header in the beginning of the file
+    fseek(fptr, 0, SEEK_SET);
+    res = fwrite(&hdrTemp, sizeof(hdrTemp), 1, fptr);
+    if (res != 1)
+    {
+        throw runtime_error("Error while writing to a wav file.");
+    }
+
+    // jump back to the end of the file
+    fseek(fptr, 0, SEEK_END);
+}
+
+
+
+void WavOutFile::write(const char *buffer, int numElems)
+{
+    int res;
+
+    if (header.format.bits_per_sample != 8)
+    {
+        throw runtime_error("Error: WavOutFile::write(const char*, int) accepts only 8bit samples.");
+    }
+    assert(sizeof(char) == 1);
+
+    res = fwrite(buffer, 1, numElems, fptr);
+    if (res != numElems) 
+    {
+        throw runtime_error("Error while writing to a wav file.");
+    }
+
+    bytesWritten += numElems;
+}
+
+
+void WavOutFile::write(const short *buffer, int numElems)
+{
+    int res;
+
+    // 16 bit samples
+    if (numElems < 1) return;   // nothing to do
+
+    if (header.format.bits_per_sample == 8)
+    {
+        int i;
+        char *temp = new char[numElems];
+        // convert from 16bit format to 8bit format
+        for (i = 0; i < numElems; i ++)
+        {
+            temp[i] = buffer[i] >> 8;
+        }
+        // write in 8bit format
+        write(temp, numElems);
+        delete[] temp;
+    }
+    else
+    {
+        // 16bit format
+        unsigned short *pTemp = new unsigned short[numElems];
+
+        assert(header.format.bits_per_sample == 16);
+
+        // allocate temp buffer to swap byte order if necessary
+        memcpy(pTemp, buffer, numElems * 2);
+        _swap16Buffer(pTemp, numElems);
+
+        res = fwrite(pTemp, 2, numElems, fptr);
+
+        delete[] pTemp;
+
+        if (res != numElems) 
+        {
+            throw runtime_error("Error while writing to a wav file.");
+        }
+        bytesWritten += 2 * numElems;
+    }
+}
+
+
+void WavOutFile::write(const float *buffer, int numElems)
+{
+    int i;
+    short *temp = new short[numElems];
+    int iTemp;
+
+    // convert to 16 bit integer
+    for (i = 0; i < numElems; i ++)
+    {
+        // convert to integer
+        iTemp = (int)(32768.0f * buffer[i]);
+
+        // saturate
+        if (iTemp < -32768) iTemp = -32768;
+        if (iTemp > 32767)  iTemp = 32767;
+        temp[i] = (short)iTemp;
+    }
+
+    write(temp, numElems);
+
+    delete[] temp;
+}
diff --git a/pysoundtouch/src/WavFile.h b/pysoundtouch/src/WavFile.h
new file mode 100644
index 0000000..bf9b3bd
--- /dev/null
+++ b/pysoundtouch/src/WavFile.h
@@ -0,0 +1,250 @@
+////////////////////////////////////////////////////////////////////////////////
+///
+/// Classes for easy reading & writing of WAV sound files.
+///
+/// For big-endian CPU, define BIG_ENDIAN during compile-time to correctly
+/// parse the WAV files with such processors.
+/// 
+/// Admittingly, more complete WAV reader routines may exist in public domain, but 
+/// the reason for 'yet another' one is that those generic WAV reader libraries are
+/// exhaustingly large and cumbersome! Wanted to have something simpler here, i.e. 
+/// something that's not already larger than rest of the SoundTouch/SoundStretch program...
+///
+/// Author        : Copyright (c) Olli Parviainen
+/// Author e-mail : oparviai 'at' iki.fi
+/// SoundTouch WWW: http://www.surina.net/soundtouch
+///
+////////////////////////////////////////////////////////////////////////////////
+//
+// Last changed  : $Date$
+// File revision : $Revision: 4 $
+//
+// $Id$
+//
+////////////////////////////////////////////////////////////////////////////////
+//
+// License :
+//
+//  SoundTouch audio processing library
+//  Copyright (c) Olli Parviainen
+//
+//  This library is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU Lesser General Public
+//  License as published by the Free Software Foundation; either
+//  version 2.1 of the License, or (at your option) any later version.
+//
+//  This library 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
+//  Lesser General Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser General Public
+//  License along with this library; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef WAVFILE_H
+#define WAVFILE_H
+
+#include <stdio.h>
+
+#ifndef uint
+typedef unsigned int uint;
+#endif           
+
+
+/// WAV audio file 'riff' section header
+typedef struct 
+{
+    char riff_char[4];
+    int  package_len;
+    char wave[4];
+} WavRiff;
+
+/// WAV audio file 'format' section header
+typedef struct 
+{
+    char  fmt[4];
+    int   format_len;
+    short fixed;
+    short channel_number;
+    int   sample_rate;
+    int   byte_rate;
+    short byte_per_sample;
+    short bits_per_sample;
+} WavFormat;
+
+/// WAV audio file 'data' section header
+typedef struct 
+{
+    char  data_field[4];
+    uint  data_len;
+} WavData;
+
+
+/// WAV audio file header
+typedef struct 
+{
+    WavRiff   riff;
+    WavFormat format;
+    WavData   data;
+} WavHeader;
+
+
+/// Class for reading WAV audio files.
+class WavInFile
+{
+private:
+    /// File pointer.
+    FILE *fptr;
+
+    /// Counter of how many bytes of sample data have been read from the file.
+    uint dataRead;
+
+    /// WAV header information
+    WavHeader header;
+
+    /// Init the WAV file stream
+    void init();
+
+    /// Read WAV file headers.
+    /// \return zero if all ok, nonzero if file format is invalid.
+    int readWavHeaders();
+
+    /// Checks WAV file header tags.
+    /// \return zero if all ok, nonzero if file format is invalid.
+    int checkCharTags() const;
+
+    /// Reads a single WAV file header block.
+    /// \return zero if all ok, nonzero if file format is invalid.
+    int readHeaderBlock();
+
+    /// Reads WAV file 'riff' block
+    int readRIFFBlock();
+
+public:
+    /// Constructor: Opens the given WAV file. If the file can't be opened,
+    /// throws 'runtime_error' exception.
+    WavInFile(const char *filename);
+
+    WavInFile(FILE *file);
+
+    /// Destructor: Closes the file.
+    ~WavInFile();
+
+    /// Rewind to beginning of the file
+    void rewind();
+
+    /// Get sample rate.
+    uint getSampleRate() const;
+
+    /// Get number of bits per sample, i.e. 8 or 16.
+    uint getNumBits() const;
+
+    /// Get sample data size in bytes. Ahem, this should return same information as 
+    /// 'getBytesPerSample'...
+    uint getDataSizeInBytes() const;
+
+    /// Get total number of samples in file.
+    uint getNumSamples() const;
+
+    /// Get number of bytes per audio sample (e.g. 16bit stereo = 4 bytes/sample)
+    uint getBytesPerSample() const;
+    
+    /// Get number of audio channels in the file (1=mono, 2=stereo)
+    uint getNumChannels() const;
+
+    /// Get the audio file length in milliseconds
+    uint getLengthMS() const;
+
+    /// Reads audio samples from the WAV file. This routine works only for 8 bit samples.
+    /// Reads given number of elements from the file or if end-of-file reached, as many 
+    /// elements as are left in the file.
+    ///
+    /// \return Number of 8-bit integers read from the file.
+    int read(char *buffer, int maxElems);
+
+    /// Reads audio samples from the WAV file to 16 bit integer format. Reads given number 
+    /// of elements from the file or if end-of-file reached, as many elements as are 
+    /// left in the file.
+    ///
+    /// \return Number of 16-bit integers read from the file.
+    int read(short *buffer,     ///< Pointer to buffer where to read data.
+             int maxElems       ///< Size of 'buffer' array (number of array elements).
+             );
+
+    /// Reads audio samples from the WAV file to floating point format, converting 
+    /// sample values to range [-1,1[. Reads given number of elements from the file
+    /// or if end-of-file reached, as many elements as are left in the file.
+    ///
+    /// \return Number of elements read from the file.
+    int read(float *buffer,     ///< Pointer to buffer where to read data.
+             int maxElems       ///< Size of 'buffer' array (number of array elements).
+             );
+
+    /// Check end-of-file.
+    ///
+    /// \return Nonzero if end-of-file reached.
+    int eof() const;
+};
+
+
+
+/// Class for writing WAV audio files.
+class WavOutFile
+{
+private:
+    /// Pointer to the WAV file
+    FILE *fptr;
+
+    /// WAV file header data.
+    WavHeader header;
+
+    /// Counter of how many bytes have been written to the file so far.
+    int bytesWritten;
+
+    /// Fills in WAV file header information.
+    void fillInHeader(const uint sampleRate, const uint bits, const uint channels);
+
+    /// Finishes the WAV file header by supplementing information of amount of
+    /// data written to file etc
+    void finishHeader();
+
+    /// Writes the WAV file header.
+    void writeHeader();
+
+public:
+    /// Constructor: Creates a new WAV file. Throws a 'runtime_error' exception 
+    /// if file creation fails.
+    WavOutFile(const char *fileName,    ///< Filename
+               int sampleRate,          ///< Sample rate (e.g. 44100 etc)
+               int bits,                ///< Bits per sample (8 or 16 bits)
+               int channels             ///< Number of channels (1=mono, 2=stereo)
+               );
+
+    WavOutFile(FILE *file, int sampleRate, int bits, int channels);
+
+    /// Destructor: Finalizes & closes the WAV file.
+    ~WavOutFile();
+
+    /// Write data to WAV file. This function works only with 8bit samples. 
+    /// Throws a 'runtime_error' exception if writing to file fails.
+    void write(const char *buffer,     ///< Pointer to sample data buffer.
+               int numElems             ///< How many array items are to be written to file.
+               );
+
+    /// Write data to WAV file. Throws a 'runtime_error' exception if writing to
+    /// file fails.
+    void write(const short *buffer,     ///< Pointer to sample data buffer.
+               int numElems             ///< How many array items are to be written to file.
+               );
+
+    /// Write data to WAV file in floating point format, saturating sample values to range
+    /// [-1..+1[. Throws a 'runtime_error' exception if writing to file fails.
+    void write(const float *buffer,     ///< Pointer to sample data buffer.
+               int numElems             ///< How many array items are to be written to file.
+               );
+};
+
+#endif
diff --git a/pysoundtouch/src/pybpmdetect.cpp b/pysoundtouch/src/pybpmdetect.cpp
new file mode 100644
index 0000000..03a673f
--- /dev/null
+++ b/pysoundtouch/src/pybpmdetect.cpp
@@ -0,0 +1,122 @@
+/*
+ * python interface to soundtouch (the open-source audio processing library)
+ *
+ * The structure of this code was based on pymad-0.5.4
+ * This is a C++ file.
+ */
+
+#include <Python.h>
+
+extern "C" {
+  #include "soundtouchmodule.h"
+}
+#include "pybpmdetect.h"
+
+#if PY_VERSION_HEX < 0x01060000
+#define PyObject_DEL(op) PyMem_DEL((op))
+#endif
+
+PyTypeObject py_bpmdetect_t = {
+    PyObject_HEAD_INIT(&PyType_Type)
+    0,
+    "BPMDetect",
+    sizeof(py_bpmdetect),
+    0,
+    /* standard methods */
+    (destructor) py_bpmdetect_dealloc,
+    (printfunc) 0,
+    (getattrfunc) py_bpmdetect_getattr,
+    (setattrfunc) 0,
+    (cmpfunc) 0,
+    (reprfunc) 0,
+    /* type categories */
+    0, /* as number */
+    0, /* as sequence */
+    0, /* as mapping */
+    0, /* hash */
+    0, /* binary */
+    0, /* repr */
+    0, /* getattro */
+    0, /* setattro */
+    0, /* as buffer */
+    0, /* tp_flags */
+    NULL
+};
+
+// Constructor
+PyObject* py_bpmdetect_new(PyObject* self, PyObject* args) {
+  py_bpmdetect* ps = NULL;
+  uint sampleRate, channels;
+  
+  // Needs to be constructed with sampling rate and number of channels
+  if (!PyArg_ParseTuple(args, "II:Soundtouch", &sampleRate, &channels)) {
+    PyErr_SetString(PyExc_RuntimeError, "Requires sampling rate and number of channels (sample size must be 2)");
+    return NULL;
+  }
+
+  // Create the object
+  ps = PyObject_NEW(py_bpmdetect, &py_bpmdetect_t);
+  ps->bpmdetect = new soundtouch::BPMDetect((int) channels, (int) sampleRate);
+  ps->channels = (int) channels;
+
+  return (PyObject*) ps;
+}
+
+// Deallocate the BPMDetect object
+static void py_bpmdetect_dealloc(PyObject* self, PyObject* args) {
+  py_bpmdetect* ps = PY_BPMDETECT(self);
+
+  if (ps->bpmdetect) {
+    delete ps->bpmdetect;
+    ps->bpmdetect = NULL;
+  }
+
+  PyObject_DEL(self);
+}
+
+// Read in a number of samples for beat detection
+static PyObject* py_bpmdetect_put_samples(PyObject* self, PyObject* args) {
+  py_bpmdetect* ps = PY_BPMDETECT(self);
+  int buflen;
+  char* transfer;
+
+  // Needs to be called with a string of samples
+  if (!PyArg_ParseTuple(args, "s#", &transfer, &buflen)) {
+    PyErr_SetString(PyExc_TypeError, "invalid argument");
+	return NULL;
+  }
+
+  // Move all into our char-short union
+  for (int ii = 0; ii < buflen; ii++)
+    ps->buffer.chars[ii] = transfer[ii];
+
+  // Input them into the BMP detector
+  ps->bpmdetect->inputSamples(ps->buffer.shorts, (uint) buflen / (2 * ps->channels));
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+// Perform the beat detection algorithm
+// return the beats per minute
+static PyObject* py_bpmdetect_get_bpm(PyObject* self, PyObject* args) {
+  py_bpmdetect* ps = PY_BPMDETECT(self);
+
+  // Return the BPM of the input samples
+  float bpm = ps->bpmdetect->getBpm();
+  
+  return PyFloat_FromDouble(bpm);
+}
+
+/* housekeeping */
+
+static PyMethodDef bpmdetect_methods[] = {
+    { "put_samples", py_bpmdetect_put_samples, METH_VARARGS, "" },
+    { "get_bpm", py_bpmdetect_get_bpm, METH_VARARGS, "" },
+    { NULL, 0, 0, NULL }
+};
+
+// Extract information from the bpmdetect object
+static PyObject* py_bpmdetect_getattr(PyObject* self, char* name) {
+  return Py_FindMethod(bpmdetect_methods, self, name);
+}
diff --git a/pysoundtouch/src/pybpmdetect.h b/pysoundtouch/src/pybpmdetect.h
new file mode 100644
index 0000000..54438d0
--- /dev/null
+++ b/pysoundtouch/src/pybpmdetect.h
@@ -0,0 +1,41 @@
+/*
+ * python interface to soundtouch (the open-source audio processing library)
+ * BPM Detection
+ */
+
+#ifndef __PY_BMPDETECT_H__
+#define __PY_BMPDETECT_H__
+
+#include <Python.h>
+#include <BPMDetect.h>
+
+#define BUFFER_SIZE 44100
+
+// Definition of the bpmdetect object
+typedef struct {
+  PyObject_HEAD
+  soundtouch::BPMDetect* bpmdetect;
+  int channels; // 1 or 2
+  union {
+    char chars[BUFFER_SIZE];
+    short shorts[BUFFER_SIZE/2];
+  } buffer;
+} py_bpmdetect; /* Soundtouch */
+
+#define PY_BPMDETECT(x) ((py_bpmdetect *) x)
+
+extern PyTypeObject py_bpmdetect_t;
+
+// Deallocate the BPMDetect object
+static void py_bpmdetect_dealloc(PyObject* self, PyObject* args);
+
+// Read in a number of samples for beat detection
+static PyObject* py_bpmdetect_put_samples(PyObject* self, PyObject* args);
+
+// Perform the beat detection algorithm
+static PyObject* py_bpmdetect_get_bpm(PyObject* self, PyObject* args);
+
+// Extract information from the bpmdetect object
+static PyObject* py_bpmdetect_getattr(PyObject* self, char* name);
+
+#endif
diff --git a/pysoundtouch/src/pysoundtouch.cpp b/pysoundtouch/src/pysoundtouch.cpp
new file mode 100644
index 0000000..ddc832b
--- /dev/null
+++ b/pysoundtouch/src/pysoundtouch.cpp
@@ -0,0 +1,243 @@
+/*
+ * python interface to soundtouch (the open-source audio processing library)
+ *
+ * The structure of this code was based on pymad-0.5.4
+ * This is a C++ file.
+ */
+
+#include <Python.h>
+
+extern "C" {
+  #include "soundtouchmodule.h"
+}
+#include "pysoundtouch.h"
+
+#if PY_VERSION_HEX < 0x01060000
+#define PyObject_DEL(op) PyMem_DEL((op))
+#endif
+
+/* For debugging:
+#include "WavFile.h"
+WavOutFile* inputs = new WavOutFile("/Users/jrising/inputs.wav", 44100, 16, 1);
+WavOutFile* outputs = new WavOutFile("/Users/jrising/outputs.wav", 44100, 16, 1);*/
+
+PyTypeObject py_soundtouch_t = {
+    PyObject_HEAD_INIT(&PyType_Type)
+    0,
+    "Soundtouch",
+    sizeof(py_soundtouch),
+    0,
+    /* standard methods */
+    (destructor) py_soundtouch_dealloc,
+    (printfunc) 0,
+    (getattrfunc) py_soundtouch_getattr,
+    (setattrfunc) 0,
+    (cmpfunc) 0,
+    (reprfunc) 0,
+    /* type categories */
+    0, /* as number */
+    0, /* as sequence */
+    0, /* as mapping */
+    0, /* hash */
+    0, /* binary */
+    0, /* repr */
+    0, /* getattro */
+    0, /* setattro */
+    0, /* as buffer */
+    0, /* tp_flags */
+    NULL
+};
+
+// Constructor
+PyObject* py_soundtouch_new(PyObject* self, PyObject* args) {
+  py_soundtouch* ps = NULL;
+  uint sampleRate, channels;
+  
+  // Needs to be given the sampling rate and number of channels
+  if (!PyArg_ParseTuple(args, "II:Soundtouch", &sampleRate, &channels)) {
+    PyErr_SetString(PyExc_RuntimeError, "Requires sampling rate and number of channels (sample size must be 2)");
+    return NULL;
+  }
+
+  // Create the object
+  ps = PyObject_NEW(py_soundtouch, &py_soundtouch_t);
+  ps->soundtouch = new soundtouch::SoundTouch();
+  ps->channels = (int) channels;
+  ps->soundtouch->setSampleRate(sampleRate);
+  ps->soundtouch->setChannels(channels);
+
+  return (PyObject*) ps;
+}
+
+// Deallocate the SoundTouch object
+static void py_soundtouch_dealloc(PyObject* self, PyObject* args) {
+  py_soundtouch* ps = PY_SOUNDTOUCH(self);
+
+  if (ps->soundtouch) {
+    delete ps->soundtouch;
+    ps->soundtouch = NULL;
+  }
+
+  PyObject_DEL(self);
+}
+
+// Set the rate of playback
+static PyObject* py_soundtouch_set_rate(PyObject* self, PyObject* args) {
+  float rate;
+
+  // Given the rate as a fraction
+  if (!PyArg_ParseTuple(args, "f", &rate) || rate < 0) {
+    PyErr_SetString(PyExc_TypeError, "invalid argument");
+	return NULL;
+  }
+
+  PY_SOUNDTOUCH(self)->soundtouch->setRate(rate);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+// Set the tempo of playback
+static PyObject* py_soundtouch_set_tempo(PyObject* self, PyObject* args) {
+  float tempo;
+
+  // Given the tempo as a ratio
+  if (!PyArg_ParseTuple(args, "f", &tempo) || tempo < 0) {
+    PyErr_SetString(PyExc_TypeError, "invalid argument");
+	return NULL;
+  }
+
+  PY_SOUNDTOUCH(self)->soundtouch->setTempo(tempo);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+// Shift all pitches
+static PyObject* py_soundtouch_set_pitch(PyObject* self, PyObject* args) {
+  float pitch;
+
+  // Given the pitch adjustment as a fraction
+  if (!PyArg_ParseTuple(args, "f", &pitch) || pitch < 0) {
+    PyErr_SetString(PyExc_TypeError, "invalid argument");
+	return NULL;
+  }
+
+  PY_SOUNDTOUCH(self)->soundtouch->setPitch(pitch);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+static PyObject* py_soundtouch_set_pitch_shift(PyObject* self, PyObject* args) {
+  float pitch;
+
+  // Given the pitch adjustment in half-steps
+  if (!PyArg_ParseTuple(args, "f", &pitch) || pitch < -12 || pitch > 12) {
+    PyErr_SetString(PyExc_TypeError, "invalid argument: pitch must be between -12 and 12");
+	return NULL;
+  }
+
+  PY_SOUNDTOUCH(self)->soundtouch->setPitchSemiTones(pitch);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+// Flush all samples to the output
+static PyObject* py_soundtouch_flush(PyObject* self, PyObject* args) {
+  PY_SOUNDTOUCH(self)->soundtouch->flush();
+
+  // For debugging:
+  //delete inputs;
+  //delete outputs;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+// Clear all buffers
+static PyObject* py_soundtouch_clear(PyObject* self, PyObject* args) {
+  PY_SOUNDTOUCH(self)->soundtouch->clear();
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+// Add new samples
+static PyObject* py_soundtouch_put_samples(PyObject* self, PyObject* args) {
+  py_soundtouch* ps = PY_SOUNDTOUCH(self);
+  int buflen;
+  char* transfer;
+
+  // Given a string of samples to add
+  if (!PyArg_ParseTuple(args, "s#", &transfer, &buflen)) {
+    PyErr_SetString(PyExc_TypeError, "invalid argument");
+	return NULL;
+  }
+
+  // Move them into our char-short union
+  for (int ii = 0; ii < buflen; ii++)
+    ps->buffer.chars[ii] = transfer[ii];
+
+  // Add them
+  ps->soundtouch->putSamples(ps->buffer.shorts, (uint) buflen / (2 * ps->channels));
+
+  // For debugging:
+  //inputs->write(ps->buffer.shorts, buflen / 2);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+// Return the shifted samples
+static PyObject* py_soundtouch_get_samples(PyObject* self, PyObject* args) {
+  py_soundtouch* ps = PY_SOUNDTOUCH(self);
+  uint maxSamples;
+
+  // Given the number of samples to request
+  if (!PyArg_ParseTuple(args, "|I", &maxSamples)) {
+    PyErr_SetString(PyExc_TypeError, "invalid argument");
+	return NULL;
+  }
+  
+  // Move them into our char-short union
+  uint received = ps->soundtouch->receiveSamples(ps->buffer.shorts, maxSamples);
+
+  // For debugging:
+  //outputs->write(ps->buffer.shorts, received * ps->channels);
+
+  return PyString_FromStringAndSize(ps->buffer.chars, received * 2 * ps->channels);
+}
+
+// Return how many samples are available for output
+static PyObject* py_soundtouch_ready_count(PyObject* self, PyObject* args) {
+  return PyInt_FromLong(PY_SOUNDTOUCH(self)->soundtouch->numSamples());
+}
+
+// Return how many samples will be available given the current data
+static PyObject* py_soundtouch_waiting_count(PyObject* self, PyObject* args) {
+  return PyInt_FromLong(PY_SOUNDTOUCH(self)->soundtouch->numUnprocessedSamples());
+}
+
+/* housekeeping */
+
+static PyMethodDef soundtouch_methods[] = {
+    { "set_rate", py_soundtouch_set_rate, METH_VARARGS, "" },
+    { "set_tempo", py_soundtouch_set_tempo, METH_VARARGS, "" },
+    { "set_pitch", py_soundtouch_set_pitch, METH_VARARGS, "" },
+    { "set_pitch_shift", py_soundtouch_set_pitch_shift, METH_VARARGS, "" },
+    { "flush", py_soundtouch_flush, METH_VARARGS, "" },
+    { "clear", py_soundtouch_clear, METH_VARARGS, "" },
+    { "put_samples", py_soundtouch_put_samples, METH_VARARGS, "" },
+    { "get_samples", py_soundtouch_get_samples, METH_VARARGS, "" },
+    { "ready_count", py_soundtouch_ready_count, METH_VARARGS, "" },
+    { "waiting_count", py_soundtouch_waiting_count, METH_VARARGS, "" },
+    { NULL, 0, 0, NULL }
+};
+
+// Get additional attributes from the SoundTouch object
+static PyObject* py_soundtouch_getattr(PyObject* self, char* name) {
+  // TODO: add soundtouch.getSetting here?  Add a setattr with soundtouch.setSetting?
+  return Py_FindMethod(soundtouch_methods, self, name);
+}
diff --git a/pysoundtouch/src/pysoundtouch.h b/pysoundtouch/src/pysoundtouch.h
new file mode 100644
index 0000000..e9790af
--- /dev/null
+++ b/pysoundtouch/src/pysoundtouch.h
@@ -0,0 +1,61 @@
+/*
+ * python interface to soundtouch (the open-source audio processing library)
+ * Pitch, tempo, and rate shifting
+ */
+
+#ifndef __PY_SOUNDTOUCH_H__
+#define __PY_SOUNDTOUCH_H__
+
+#define __cplusplus
+
+#include <Python.h>
+#include <SoundTouch.h>
+
+#define BUFFER_SIZE 44100
+
+// Definition of the soundtouch object
+typedef struct {
+  PyObject_HEAD
+  int channels; // 1 or 2
+  soundtouch::SoundTouch* soundtouch;
+  union {
+    char chars[BUFFER_SIZE];
+    short shorts[BUFFER_SIZE/2];
+  } buffer;
+} py_soundtouch; /* Soundtouch */
+
+#define PY_SOUNDTOUCH(x) ((py_soundtouch *) x)
+
+extern PyTypeObject py_soundtouch_t;
+
+// Deallocate the SoundTouch object
+static void py_soundtouch_dealloc(PyObject* self, PyObject* args);
+
+// Adjust attributes of samples that have been entered
+static PyObject* py_soundtouch_set_rate(PyObject* self, PyObject* args);
+static PyObject* py_soundtouch_set_tempo(PyObject* self, PyObject* args);
+static PyObject* py_soundtouch_set_pitch(PyObject* self, PyObject* args);
+static PyObject* py_soundtouch_set_pitch_shift(PyObject* self, PyObject* args);
+
+// Move all waiting samples to the output
+static PyObject* py_soundtouch_flush(PyObject* self, PyObject* args);
+
+// Clear the buffer of samples
+static PyObject* py_soundtouch_clear(PyObject* self, PyObject* args);
+
+// Add new samples to be processed
+static PyObject* py_soundtouch_put_samples(PyObject* self, PyObject* args);
+
+// Extract processed samples from the output
+static PyObject* py_soundtouch_get_samples(PyObject* self, PyObject* args);
+
+// Return how many samples are available for output
+static PyObject* py_soundtouch_ready_count(PyObject* self, PyObject* args);
+
+// Return how many samples will be available given the current data
+static PyObject* py_soundtouch_waiting_count(PyObject* self, PyObject* args);
+
+// Get additional attributes from the SoundTouch object
+static PyObject* py_soundtouch_getattr(PyObject* self, char* name);
+
+#endif
diff --git a/pysoundtouch/src/soundtouchmodule.c b/pysoundtouch/src/soundtouchmodule.c
new file mode 100644
index 0000000..361af6a
--- /dev/null
+++ b/pysoundtouch/src/soundtouchmodule.c
@@ -0,0 +1,27 @@
+/*
+ * python interface to soundtouch (the open-source audio processing library)
+ * Expose BMP detection and Shifting to python
+ */
+
+#include <SoundTouch.h>
+#include "soundtouchmodule.h"
+
+static PyMethodDef soundtouch_methods[] = {
+    { "SoundTouch", py_soundtouch_new, METH_VARARGS, "" },
+    { "BPMDetect", py_bpmdetect_new, METH_VARARGS, "" },
+    { NULL, 0, 0, NULL }
+};
+
+PyMODINIT_FUNC
+initsoundtouch(void) {
+    PyObject *module, *dict;
+
+    module = Py_InitModule("soundtouch", soundtouch_methods);
+    dict = PyModule_GetDict(module);
+
+    PyDict_SetItemString(dict, "__version__",
+			 PyString_FromString(VERSION));
+
+    if (PyErr_Occurred())
+      PyErr_SetString(PyExc_ImportError, "soundtouch: init failed");
+}
diff --git a/pysoundtouch/src/soundtouchmodule.h b/pysoundtouch/src/soundtouchmodule.h
new file mode 100644
index 0000000..6f533eb
--- /dev/null
+++ b/pysoundtouch/src/soundtouchmodule.h
@@ -0,0 +1,17 @@
+/* 
+ * python interface to soundtouch (the open-source audio processing library)
+ * Expose BMP detection and Shifting to python
+ */
+
+#ifndef __SOUNDTOUCH_MODULE_H__
+#define __SOUNDTOUCH_MODULE_H__
+
+#include <Python.h>
+
+/* module accessible functions */
+extern "C" {
+  PyObject* py_soundtouch_new(PyObject* self, PyObject* args);
+  PyObject* py_bpmdetect_new(PyObject* self, PyObject* args);
+}
+
+#endif