taptaudio_paimpl.h

Go to the documentation of this file.

/* $Id: taptaudio_paimpl.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/taptaudio_paimpl.h $ */
#ifndef TAPTAUDIO_PAIMPL_DOT_AITCH
#define TAPTAUDIO_PAIMPL_DOT_AITCH

#include "taptaudio.h"

/**\file taptaudio_paimpl.h
 * Header for portaudio implementation of taptaudio
 * \author Trent Apted <tapted@it.usyd.edu.au>
 * $Revision: 191 $
 * $Date: 2005-08-05 10:55:59 +1000 (Fri, 05 Aug 2005) $
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <map>
#include <SDL_thread.h>
#include <limits>
#include <math.h>

#include "sample.h"

/**\def PAV19
 * If this is defined, we will try to use the version 1.9 of portaudio.
 * \note the API is very different -- we will look for the header at
 * portaudio_v19.h, wherever that may be..
 */

#ifndef PAV19
#include "portaudio.h"
#else
#include "portaudio_v19.h"
#endif

/** The portaudio implementation of the audio system */
class AudioSystemImpl {
private:
    AudioSystemImpl(const AudioSystemImpl&) {}
    AudioSystemImpl& operator=(const AudioSystemImpl&) {return *this;}
public:
    typedef std::map<std::string, ASSample*> REGISTRY; ///< Type for WAV file registry
    static SDL_mutex *as_mutex;                        ///< Audio System mutex
    static SDL_mutex *registry_mutex;                  ///< Registry mutex
protected:
    REGISTRY registry;             ///< The registy of loaded WAV files
#ifndef PAV19
    PortAudioStream *stream;       ///< The portaudio strem handle
    typedef PaTimestamp Timestamp; ///< The type used for time stamps in this version of portaudio
#else
    PaStream *stream;
    typedef PaTime Timestamp;
#endif
    bool stopping;        ///< Are we trying to stop the audio system
    bool fakeMonoMic;     ///< Are we "faking" a Mono input stream by averaging stereo channels
    unsigned inChannels;  ///< Number of input channels
    unsigned outChannels; ///< Number of output channels
    double sampRate;      ///< The sample rate of the audio stream
    AUDIO_FORMAT fmt;     ///< The audio format

    unsigned iframe_size; ///< The size (in bytes) of an input frame
    unsigned oframe_size; ///< The size (in bytes) of an output frame

    Recording *cur_rec;           ///< The current recording (e.g. we are recording if this is non-null)
    Recording *record_after_play; ///< The recording we will start as soon as no samples are playing

    ASSample *cur_play;           ///< For non-tracked implementations, the currently playing sample
    unsigned long play_offset;    ///< The current offset into \a cur_play

    /** Perform the "record" portion of the callback */
    virtual void doRecord(const void *inputBuffer,
                          unsigned long framesPerBuffer);

    /** Perform the "play" portion of the callback */
    virtual void doPlay(void *outputBuffer,
                        unsigned long framesPerBuffer,
                        Timestamp outTime);

public:
    /** Virtual destructor, free the portaudio handles and clear the registry (?) */
    virtual ~AudioSystemImpl();

    /** Create an AudioSystemImpl */
    AudioSystemImpl(unsigned inputChannels = 1,
                    unsigned outputChannels = 2,
                    double sampleRate = 44100,
                    AUDIO_FORMAT format = AF_Int16,
                    int deviceIDin = 0,
                    int deviceIDout = 0);

    /** Portaudio callback
     * \note occurs at interrupt level so we CAN NOT ALLOCATE MEMORY
     */
    virtual int callback(const void *inputBuffer,
                         void *outputBuffer,
                         unsigned long framesPerBuffer,
                         Timestamp outTime);

    /**
     * Get a holder (e.g. a track reference) in which to load a sample.
     */
    virtual ASSample** getSampleHolder(bool loop = false, float vol = 1.0f, unsigned* trackno = 0);

    /** Load a "known" sample, or a file */
    virtual ASSample* loadSample(const std::string &name);
    ASSample* loadRawSample(const std::string &name, void* data, unsigned long size);
    bool mixSample(ASSample *samp, bool record_after, double record_size, bool loop = false, float vol = 1.0f, unsigned* trackno = 0);
    bool loopSample(ASSample *samp, float vol = 1.0f, unsigned* trackno = 0);
    bool freeSample(ASSample *samp);
    virtual unsigned stopSample(ASSample *samp, int trackno = -1, bool lock = true);
    virtual unsigned setVolume(ASSample */*samp*/, float /*vol*/ = 1.0f, int /*trackno*/ = -1) {return 0;}
    bool startRec(double max_seconds);
    bool isRecording() { return cur_rec; }
    ASSample* stopRec(const std::string &name, bool save = false, bool save_in_thread = false);
    void stop() {stopping = true;}
    void waitstop();

    static void listDevices();
};

/**
 * An implementation of AudioSystemImpl that mixes any number of tracks
 * with appropriate clipping.
 */
class AudioSystemMixer : public AudioSystemImpl {
protected:
    const unsigned tracks; /* todo: this should be a struct */
    struct Mix {
        ASSample *sam;
        unsigned off;
        float vol;
        bool looping;
    };
    Mix *track;

    virtual void doPlay(void *outputBuffer,
                        unsigned long framesPerBuffer,
                        Timestamp outTime) = 0;

public:
    AudioSystemMixer(unsigned inputChannels = 1,
                     unsigned outputChannels = 2,
                     double sampleRate = 44100,
                     AUDIO_FORMAT format = AF_Int16,
                     unsigned ttracks = 32,
                     int deviceIDin = 0,
                     int deviceIDout = 0)
        :
    AudioSystemImpl(inputChannels, outputChannels, sampleRate, format, deviceIDin, deviceIDout), tracks(ttracks) {
        track = new Mix[tracks];
        for (unsigned i = 0; i < tracks; ++i)
            track[i].sam = 0;
    }

    virtual ~AudioSystemMixer() {
        delete[] track;
    }

    virtual ASSample** getSampleHolder(bool loop = false, float vol = 1.0f, unsigned* trackno = 0);
    virtual unsigned stopSample(ASSample *samp, int trackno = -1, bool lock = true);
    virtual unsigned setVolume(ASSample *samp, float vol = 1.0f, int trackno = -1);
};

/**
 * Templatized version of AudioSystemMixer, that knows how each audio format
 * can be mixed
 */
template <class T>
class AudioSystemMixerT : public AudioSystemMixer {
    virtual void doPlay(void *outputBuffer,
                        unsigned long framesPerBuffer,
                        Timestamp outTime);

    /** Add \a val to \a accum, clipping if it overflows */
    void clipadd(T& accum, const T& val);
public:
    AudioSystemMixerT(unsigned inputChannels = 1,
                      unsigned outputChannels = 2,
                      double sampleRate = 44100,
                      AUDIO_FORMAT format = AF_Int16,
                      unsigned ttracks = 32,
                      int deviceIDin = 0,
                      int deviceIDout = 0)
        :
    AudioSystemMixer(inputChannels, outputChannels, sampleRate, format, ttracks, deviceIDin, deviceIDout) {}
    virtual ASSample* loadSample(const std::string &name);
};

template <class T>
inline void AudioSystemMixerT<T>::clipadd(T& accum, const T& val) {
    //if (std::numeric_limits<T>::is_integer) {
    const T tmp = accum + val;
    accum = (((accum & val & ~tmp) | (~accum & ~val & tmp)) < 0) ?
        (accum < 0 ?                  /* under/overflow/clipping */
         std::numeric_limits<T>::min()  :
         std::numeric_limits<T>::max()) :
        tmp;
}

template <>
inline void AudioSystemMixerT<float>::clipadd(float& accum, const float& val) {
    accum += val;
}

template <>
inline void AudioSystemMixerT<double>::clipadd(double& accum, const double& val) {
    accum += val;
}

template <class T>
void AudioSystemMixerT<T>::doPlay(void *outputBuffer,
                                  unsigned long framesPerBuffer,
                                  Timestamp /*outTime*/) { /*FOLD00*/
    if (!outputBuffer)
        return;

    T *opb = static_cast<T*>(outputBuffer);
    unsigned nmixed = 0;
    memset(outputBuffer, 0, oframe_size * framesPerBuffer);

    for (unsigned i = 0; i < tracks; ++i) {
        if (track[i].sam) {
            Mix &m = track[i];
            /* we assume for now that format is the same (checked in loadSample) */
            const T* ipb = static_cast<const T*>(m.sam->getBytes());
            /* how many frames are there in the entire sample? */
            unsigned long nframes = m.sam->numBytes() / m.sam->getChannels() / sizeof(T);
            /* what frame are we at? */
            unsigned &offset = m.off;
            /* are we looping */
            bool &loop = m.looping;
            bool v = m.vol != 1.0f;

            if (loop || offset < nframes) {
                unsigned opb_offset = 0;
                unsigned long n;
                do {
                    if (loop && offset >= nframes)
                        offset = 0;
                    /* how many frames are left in the sample stream */
                    n = nframes-offset;
                    if (n > framesPerBuffer - opb_offset)
                        n = framesPerBuffer - opb_offset;

                    unsigned ich = m.sam->getChannels();
                    ipb += offset*ich;

                    if  (ich == 1) {
                        /* mix mono -> N channels */
                        for (unsigned f = opb_offset; f < n; ++f) {
                            for (unsigned c = 0; c < outChannels; ++c) {
                                clipadd(opb[outChannels*f + c],
                                        v ? static_cast<T>(roundf(ipb[f] * m.vol))
                                        : ipb[f]);
                            }
                        }
                        m.sam->mixed(n, track + i);
                    } else if (ich == outChannels) {
                        for (unsigned f = opb_offset; f < n*ich; ++f) {
                            clipadd(opb[f],
                                    v ? static_cast<T>(roundf(ipb[f] * m.vol))
                                    : ipb[f]);
                        }
                        m.sam->mixed(n, track + i);
                    } else {
                        /* not supported -- skip */
                    }
                    offset += n;
                } while (loop && (opb_offset += n) < framesPerBuffer);
                ++nmixed;
            }
            if (!loop && offset >= nframes) {
                --m.sam->refs;
                m.sam = 0;
            }
        }
    }
    if (nmixed == 0 && record_after_play) {
        cur_rec = record_after_play;
        record_after_play = 0;
    }
} /*FOLD00*/


template <class T>
ASSample* AudioSystemMixerT<T>::loadSample(const std::string &name) { /*FOLD00*/
    ASSample *ret = 0;
    //note we only need to take out a registry mutex for this
    SDL_mutexP(AudioSystemImpl::registry_mutex);

    REGISTRY::iterator it = registry.find(name);
    if (it == registry.end()) {
        try {
            ret = new FileSampleT<T>(name, outChannels == 2);

            /* sample rates still should match, but no huge dramas if they don't --
             * we will just play it slower/faster.
             */
            if (sampRate != ret->getSamRate()) {
                DODEBUG(WARNING, ("[Aw] Warning: the sample rate of %s (%fHz) differs from the current AudioSystem (%fHz)\n",
                                  name.c_str(), ret->getSamRate(), sampRate));
            }

            registry.insert(REGISTRY::value_type(name, ret));
        } catch (const char *err) {
            DODEBUG(ERROR, ("[Ae] Exception caught at loadSample: %s",
                            err));
        } catch (std::bad_alloc &) {
            DODEBUG(ERROR, ("[Ae] Not enough memory to load %s\n",
                            name.c_str()));
        }
    } else {
        ret = it->second;
    }
    SDL_mutexV(AudioSystemImpl::registry_mutex);
    return ret;
} /*FOLD00*/


#endif

---