sample.h

Go to the documentation of this file.

/* $Id: sample.h 191 2005-08-05 00:55:59Z tapted $ $URL: svn+ssh://pc-g33-9.it.usyd.edu.au/var/svn/pub/taptaudio/trunk/src/sample.h $ */
#ifndef SAMPLE_DOT_AITCH
#define SAMPLE_DOT_AITCH

#include "taptaudio.h"

/**\file sample.h
 * Decs for PCM Audio Samples
 * \author Trent Apted <tapted@it.usyd.edu.au>
 * $Revision: 191 $
 * $Date: 2005-08-05 10:55:59 +1000 (Fri, 05 Aug 2005) $
 */

#include <SDL.h>

#include "sndfile.h"
#include "taptdebug.h"

/** An ASSample using Pulse Code Modulation (PCM) */
class PCMSample : public ASSample {
protected:
    void *data;               ///< The audio data
    int channels;             ///< The number of channels in the sample
    unsigned long bytes_size; ///< The size of \a data
    double rate;              ///< The sample rate
    AUDIO_FORMAT fmt;         ///< The audio format

    /** Protected constructor for subclasses */
    PCMSample() : data(0) {}

public:
    PCMSample(void* data_, unsigned channels_, unsigned long bytes_size_, double rate_, AUDIO_FORMAT fmt_)
        :
    data(data_), channels(channels_), bytes_size(bytes_size_), rate(rate_), fmt(fmt_) {}

    virtual unsigned getChannels() {return channels;}
    virtual AUDIO_FORMAT getFormat() {return fmt;}
    virtual unsigned long numBytes() {return bytes_size;}
    virtual const void* getBytes() {return data;}
    virtual double getSamRate() {return rate;}

    static void mono2stereo(void *newdata,
                            const void *olddata,
                            unsigned long olddata_bytes,
                            unsigned oldframesize);

    static void stereo2mono(Uint8 *newdata,
                            const Uint8 *olddata,
                            unsigned long olddata_bytes,
                            unsigned framesize);

};

/** A PCMSample loaded from a file (e.g. .wav)
 * Will always load the format that is native to the sound <em>file</em>.
 */
class FileSample : public PCMSample {
protected:
    virtual void load_sndfile(SNDFILE* sf, SF_INFO &sfinfo, bool forcestereo);
    virtual ~FileSample();
public:
    FileSample (const std::string& path, bool forcestereo = false);
//    FileSample (const Uint8* data, const Uint32 bytes);
};

/** A FileSample that reads from the file using the specified type (i.e. not
 * the native type for the file).
 */
template <class T>
class FileSampleT : public FileSample {
protected:
    virtual ~FileSampleT();
    virtual void load_sndfile(SNDFILE* sf, SF_INFO &sfinfo, bool forcestereo);
public:
    FileSampleT (const std::string& path, bool forcestereo = false)
    :
    FileSample(path, forcestereo) {}
};

/** A PCMSample recorded from audio input (microphone) */
class Recording : public PCMSample {
protected:
    virtual ~Recording();
    unsigned long reserved;
public:
    Recording(unsigned long initial_size = 28672,
              unsigned chans = 2,
              AUDIO_FORMAT format = AF_Int16,
              double samplerate = 44100);

    /**
     * Append -- note that this cannot be called in the audio thread --
     * it occurs at a kernel interrupt level and we cannot allocate memory there!
     */
    void append(void *more, unsigned long sz);

    void fill(const void *more, unsigned long sz);
    void skipfill(const void *more, unsigned long sz, unsigned block);
    void trim();
    void fillSilence(unsigned long sz);
    bool save(const std::string &path);

    virtual bool isFull() {return false;}

};


/**
 * A templatized version of libsndfile's sf_read() -- read PCM
 * data from an audio file.
 *
 * \param sndfile the (opened) sound file handle
 * \param data the target buffer to store the data read from the file. Must
 *        have space allocated for at least sizeof(data)*items bytes
 * \param items the number of items to read
 */
template <class T>
    sf_count_t lsf_read(SNDFILE *sndfile, T* data, sf_count_t items) {
        return sf_read_raw(sndfile, data, sizeof(T) * items);
    }

template <>
    sf_count_t lsf_read(SNDFILE *sndfile, short* data, sf_count_t items);
template <>
    sf_count_t lsf_read(SNDFILE *sndfile, int* data, sf_count_t items);
template <>
    sf_count_t lsf_read(SNDFILE *sndfile, float* data, sf_count_t items);
template <>
    sf_count_t lsf_read(SNDFILE *sndfile, double* data, sf_count_t items);

template <class T>
void FileSampleT<T>::load_sndfile(SNDFILE* sf, SF_INFO &sfinfo, bool forcestereo) {
    T* tdata;
    channels = sfinfo.channels;
    unsigned frame_sz = sizeof(T) * channels;
    bytes_size = frame_sz * sfinfo.frames;
    rate = sfinfo.samplerate;
    data = tdata = new T[sfinfo.frames * channels];

    sf_count_t numread = lsf_read(sf, tdata, channels * sfinfo.frames );

    if (numread != channels * sfinfo.frames) {
        //error -- do something?
    }

    if (channels == 1 && forcestereo) {
        T *newdata = new T[sfinfo.frames * 2];
        mono2stereo(newdata, data, bytes_size, frame_sz /* == sizeof(T) */);
        delete[] tdata;
        data = newdata;
        bytes_size *= 2;
        channels = 2;
    }
}

template <class T>
FileSampleT<T>::~FileSampleT() {
    delete[] static_cast<T*>(data);
    data = 0;
}

#endif

---