taptaudio_paimpl.cpp

Go to the documentation of this file.

/* $Id: taptaudio_paimpl.cpp 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.cpp $ */

/**\file taptaudio_paimpl.cpp
 * Implementation of 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) $
 */

#include "taptaudio_paimpl.h"

SDL_mutex *AudioSystemImpl::as_mutex = SDL_CreateMutex();
SDL_mutex *AudioSystemImpl::registry_mutex = SDL_CreateMutex();

namespace {
    SDL_sem *stop_sem = SDL_CreateSemaphore(0);

#ifndef PAV19
    int my_callback(void *inputBuffer,
                    void *outputBuffer,
                    unsigned long framesPerBuffer,
                    PaTimestamp outTime,
                    void *userData) {
        return static_cast<AudioSystemImpl*>(userData)->
            callback(inputBuffer,
                     outputBuffer,
                     framesPerBuffer,
                     outTime);
    }
#else
    int my_callback(const void *input,
                    void *output,
                    unsigned long frameCount,
                    const PaStreamCallbackTimeInfo* timeInfo,
                    PaStreamCallbackFlags /*statusFlags*/,
                    void *userData ) {
        return static_cast<AudioSystemImpl*>(userData)->
            callback(input,
                     output,
                     frameCount,
                     timeInfo->outputBufferDacTime);
    }
#endif

    struct SaveInfo {
        Recording *r;
        std::string f;
        SaveInfo(Recording *rr, const std::string &file) : r(rr), f(file) {}
    };

    int my_saver(void *data) {
        SaveInfo * si= static_cast<SaveInfo*>(data);
        int ret = si->r->save(si->f);
        delete si;
        return ret;
    }
}

/****************************************************/
/* AudioSystemImpl class implementation starts here */
/****************************************************/

void AudioSystemImpl::waitstop() {
    SDL_SemWait(stop_sem);
}

AudioSystemImpl::~AudioSystemImpl() {
    DODEBUG(INFO, ("[Ai] Not locking to close AudioSystem..."));
    //SDL_mutexP(as_mutex);
    //SDL_mutexP(registry_mutex);

    PaError err;
    DODEBUG(NOTICE, ("[An] Stopping stream..."));
    /* this function may have a bug in it... */
    err = Pa_StopStream(stream);
    DODEBUG(NOTICE, ("[An] Closing stream..."));
    err = Pa_CloseStream(stream);
    DODEBUG(NOTICE, ("[An] Clearing registry..."));
    for (REGISTRY::iterator it = registry.begin(); it != registry.end(); ++it)
        delete it->second;

    //SDL_mutexV(as_mutex);
    //SDL_mutexV(registry_mutex);
    DODEBUG(NOTICE, ("[An] Done."));
}

AudioSystemImpl::AudioSystemImpl(unsigned inputChannels,
                                 unsigned outputChannels,
                                 double sampleRate,
                                 AUDIO_FORMAT format,
                                 int deviceIDin,
                                 int deviceIDout)
:
stream(0),
stopping(false),
inChannels(inputChannels),
outChannels(outputChannels),
sampRate(sampleRate == 0.0 ? 44100 : sampleRate),
fmt(format == AF_Default ? AF_Int16 : format),
cur_rec(0),
cur_play(0),
record_after_play(0)
{
    int sz = 0;
    switch (fmt) {
    case AF_Float32:
    case AF_Int32: sz++;
    case AF_PackedInt24 :
    case AF_Int24: sz++;
    case AF_Int16: sz++;
    case AF_Int8:
    case AF_UInt8: sz++;
    default: break;
    }
    iframe_size = inChannels * sz;
    oframe_size = outChannels * sz;

    PaError err;
    if ((err = Pa_Initialize()) != paNoError)
        throw err;

    fakeMonoMic = inChannels == 1 && outChannels == 2;

#ifndef PAV19
    if (deviceIDin == 0 && deviceIDout == 0) {
        if ((err = Pa_OpenDefaultStream(&stream,    /* stream */
                                        fakeMonoMic ? 2 : inChannels,
                                        outChannels,
                                        fmt,         /* outputSampleFormat */
                                        sampRate,    /* sampleRate */
                                        1024,        /* frames per buffer -- about 23ms at 44,100 */
                                        0,           /* number of buffers -- use the default minimum */
                                        my_callback,
                                        this)) != paNoError)
            throw err;
    } else {
        if ((err = Pa_OpenStream(&stream,    /* stream */
                                 deviceIDin, /* inputDeviceID */
                                 fakeMonoMic ? 2 : inChannels,
                                 fmt,        /* inputSampleFormat */
                                 0,          /* inputDriverInfo */
                                 deviceIDout, /* outputDeviceID */
                                 outChannels,
                                 fmt,         /* outputSampleFormat */
                                 0,           /* outputDriverInfo */
                                 sampRate,    /* sampleRate */
                                 1024,        /* frames per buffer -- about 23ms at 44,100 */
                                 0,           /* number of buffers -- use the default minimum */
                                 0,           /* PortAudio Stream Flags */
                                 my_callback,
                                 this)) != paNoError)
            throw err;
    }
#else
    if (deviceIDin == 0 && deviceIDout == 0) {
        if ((err = Pa_OpenDefaultStream(&stream,
                                        fakeMonoMic ? 2 : inChannels,
                                        outChannels,
                                        fmt,
                                        sampRate,
                                        1024,
                                        my_callback,
                                        this)) != paNoError)
            throw err;
    } else {
        PaStreamParameters in, out;
        in.device = out.device = 0;
        in.channelCount = fakeMonoMic ? 2 : inChannels;
        out.channelCount = outChannels;
        in.sampleFormat = out.sampleFormat = fmt;
        in.suggestedLatency = out.suggestedLatency = 0.010; //10ms
        in.hostApiSpecificStreamInfo = out.hostApiSpecificStreamInfo = 0;

        if ((err = Pa_OpenStream(&stream,
                                 &in, &out,
                                 sampRate,
                                 1024,  /* frames per buffer */
                                 0,     /* stream flags */
                                 my_callback,
                                 this)) != paNoError)
            throw err;
    }
#endif

    if ((err = Pa_StartStream(stream)) != paNoError)
        throw err;

    /* we are now running... */
    DODEBUG(NOTICE, ("[An] AudioSystem mixing at %fHz for %d input and %d output channels on device %d/%d...",
                     sampRate, inChannels, outChannels, deviceIDin, deviceIDout));
    DODEBUG(INFO, ("[Ai] fakeMonoMic = %s, iframe_size = %u, oframe_size = %u, sz = %d.",
                   fakeMonoMic ? "true" : "false", iframe_size, oframe_size, sz));
}

int AudioSystemImpl::callback(const void *inputBuffer,
                              void *outputBuffer,
                              unsigned long framesPerBuffer,
                              Timestamp outTime)
{
    if (stopping) {
        SDL_SemPost(stop_sem);
        return 1;
    }
    SDL_mutexP(as_mutex);
    if (cur_rec)
        doRecord(inputBuffer, framesPerBuffer);
    doPlay(outputBuffer, framesPerBuffer, outTime);
    SDL_mutexV(as_mutex);
    return 0;
}

void AudioSystemImpl::doRecord(const void *inputBuffer,
                               unsigned long framesPerBuffer)
{
    if (inputBuffer) {
        //cur_rec->append(inputBuffer, iframe_size * framesPerBuffer);
        if (fakeMonoMic)
            cur_rec->skipfill(inputBuffer, iframe_size * framesPerBuffer, iframe_size/2);
        else
            cur_rec->fill(inputBuffer, iframe_size * framesPerBuffer);
    } else { //fill with silence
        cur_rec->fillSilence(iframe_size * framesPerBuffer);
    }
}

void AudioSystemImpl::doPlay(void *outputBuffer,
                             unsigned long framesPerBuffer,
                             Timestamp /*outTime*/) {
    if (outputBuffer) {
        memset(outputBuffer, 0, oframe_size * framesPerBuffer);
        if (cur_play) {
//            putc('b', stderr);
            unsigned long nb = cur_play->numBytes();
            if (play_offset < nb) {
                unsigned long sz = framesPerBuffer * oframe_size;
                if (sz > nb - play_offset)
                    sz = nb - play_offset;

                if  (cur_play->getChannels() == 1 && outChannels == 2) {
                    sz /= 2;
                    PCMSample::mono2stereo(static_cast<Uint8*>(outputBuffer),
                                           static_cast<const Uint8*>(cur_play->getBytes()) + play_offset,
                                           sz,
                                           oframe_size/2);
                } else {
                    memcpy(outputBuffer,
                           static_cast<const Uint8*>(cur_play->getBytes()) + play_offset,
                           sz);
                }
                play_offset += sz;
            }
            if (play_offset >= nb - 1) {
                //play_offset = 0;
                --cur_play->refs;
                cur_play = 0;
                if (record_after_play) {
                    cur_rec = record_after_play;
                    record_after_play = 0;
                }
            }
        }
    }
}


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

    REGISTRY::iterator it = registry.find(name);
    if (it == registry.end()) {
        try {
            ret = new FileSample(name/*, outChannels == 2*/);

            if   (fmt == ret->getFormat() &&
                  outChannels >= ret->getChannels() &&
                  sampRate == ret->getSamRate()) {

                registry.insert(REGISTRY::value_type(name, ret));

            } else {

                DODEBUG(WARNING, ("[Aw] The format of %s is not compatible with the current AudioSystem",
                                  name.c_str()));
                DODEBUG(WARNING, ("[Aw] (file = [%d]fmt %d ch @ %fHz != [%d]fmt %d ch @ %fHz = AudioSystem)",
                                  static_cast<int>(ret->getFormat()), ret->getChannels(), ret->getSamRate(),
                                  static_cast<int>(fmt), outChannels, sampRate));

                delete ret;

            }
        } catch (const char *err) {
            DODEBUG(ERROR, ("[Ae] Exception caught trying to load %s: %s",
                            name.c_str(), err));
        } catch (std::bad_alloc &) {
            DODEBUG(ERROR, ("[Ae] Not enough memory to load %s",
                            name.c_str()));
        }
    } else {
        ret = it->second;
    }
    SDL_mutexV(registry_mutex);
    return ret;
}

bool AudioSystemImpl::freeSample(ASSample* samp) {
    /* \todo -- use some RAII, this looks crap */
    bool ret = false;
    SDL_mutexP(as_mutex);
    if (samp->refs) {
        SDL_mutexV(as_mutex);
        DODEBUG(WARNING, ("[Aw] Couldn't free sample -- maybe it is still playing"));
        return false;
    }
    SDL_mutexP(registry_mutex);

    REGISTRY::iterator it = registry.begin();
    for (; it != registry.end() && it->second != samp; ++it)
        ;

    if (it == registry.end()) {
        DODEBUG(ERROR, ("[Ae] Couldn't find sample in registry -- not freeing"));
    } else {
        registry.erase(it);
        delete samp;
        DODEBUG(INFO, ("[Ai] Sample removed from registry and deleted"));
        ret = true;
    }
    SDL_mutexV(registry_mutex);
    SDL_mutexV(as_mutex);
    return ret;
}

ASSample* AudioSystemImpl::loadRawSample(const std::string &name, void* data, unsigned long size) {
    ASSample *ret = 0;
    //note we only need to take out a registry mutex for this
    SDL_mutexP(registry_mutex);

    REGISTRY::iterator it = registry.find(name);
    if (it != registry.end()) {
        registry.erase(it);
    }
    ret = new PCMSample(data, outChannels, size, sampRate, fmt);
    registry.insert(REGISTRY::value_type(name, ret));
    SDL_mutexV(registry_mutex);
    return ret;
}


ASSample** AudioSystemImpl::getSampleHolder(bool loop, float /*vol*/, unsigned* trackno) {
    if (trackno)
        *trackno = 0;
    if (!loop && !cur_play) {
        play_offset = 0;
        return &cur_play;
    }
    return 0;
}

unsigned AudioSystemImpl::stopSample(ASSample *samp, int /*trackno*/, bool lock) {
    if (cur_play == samp) {
        if (lock) SDL_mutexP(as_mutex);
        --cur_play->refs;
        cur_play = 0;
        if (lock) SDL_mutexV(as_mutex);
        return 1;
    }
    return 0;
}

ASSample** AudioSystemMixer::getSampleHolder(bool loop, float vol, unsigned* trackno) {
    for (unsigned i = 0; i < tracks; ++i) {
        if (!track[i].sam) {
            track[i].off = 0;
            track[i].vol = vol;
            track[i].looping = loop;
            if (trackno)
                *trackno = i;
            return &(track[i].sam);
        }
    }
    return 0;
}

unsigned AudioSystemMixer::stopSample(ASSample *samp, int trackno, bool lock) {
    unsigned ctr = 0;
    unsigned i = (trackno < 0) ? 0 : trackno;
    const unsigned max = (trackno < 0) ? tracks : trackno+1;
    if (lock) SDL_mutexP(as_mutex);
    for (; i < max; ++i) {
        if (track[i].sam == samp) {
            --track[i].sam->refs;
            track[i].sam = 0;
            ctr++;
        }
    }
    if (lock) SDL_mutexV(as_mutex);
    return ctr;
}

unsigned AudioSystemMixer::setVolume(ASSample *samp, float vol, int trackno) {
    unsigned ctr = 0;
    unsigned i = (trackno < 0) ? 0 : trackno;
    const unsigned max = (trackno < 0) ? tracks : trackno+1;
    SDL_mutexP(as_mutex);
    for (; i < max; ++i) {
        if (track[i].sam == samp) {
            track[i].vol = vol;
            ctr++;
        }
    }
    SDL_mutexV(as_mutex);
    return ctr;
}

bool AudioSystemImpl::mixSample(ASSample *samp, bool record_after, double record_size, bool loop, float vol, unsigned* trackno) {
    bool success = false;
    SDL_mutexP(as_mutex);
    ASSample **holder = getSampleHolder(loop, vol, trackno);
    if (holder) {
        *holder = samp;
        ++samp->refs;
        success = true;
        if (record_after && !cur_rec && !record_after_play)
            record_after_play = new Recording(static_cast<unsigned long>(record_size * sampRate * iframe_size),
                                              inChannels,
                                              fmt,
                                              sampRate);
        DODEBUG(FUNCTION, ("[Af] %sixing %lu bytes, %d channels @ %fHz",
                           (*holder)->getChannels() == outChannels ? "M" : "Upm",
                           (*holder)->numBytes(), (*holder)->getChannels(), (*holder)->getSamRate()));
    }
    SDL_mutexV(as_mutex);
    return success;
}

bool AudioSystemImpl::loopSample(ASSample *samp, float vol, unsigned* trackno) {
    return mixSample(samp, false, 0.0, true, vol, trackno);
}

bool AudioSystemImpl::startRec(double max_seconds) {
    DODEBUG(FUNCTION, ("[Af] Recording..."));
    SDL_mutexP(as_mutex);
    bool success = false;
    if (!cur_rec && !record_after_play) {
        try {
            //play_offset = 0;
            cur_rec = new Recording(static_cast<unsigned long>(max_seconds * sampRate * iframe_size),
                                    inChannels,
                                    fmt,
                                    sampRate);
            success = true;
        } catch (std::bad_alloc&) {
        }
    }
    SDL_mutexV(as_mutex);
    return success;
}

ASSample* AudioSystemImpl::stopRec(const std::string &name, bool save, bool save_in_thread) {
    DODEBUG(FUNCTION, ("[Af] Stopping... "));
    Recording *ret = 0;
    SDL_mutexP(as_mutex);
    if (cur_rec) {
        cur_rec->trim();
        DODEBUG(INFO, ("[Ai] Size is %lu bytes\n",
                       cur_rec->numBytes()));
        ret = cur_rec;
        cur_rec = 0;

        { //register
            SDL_mutexP(registry_mutex);
            REGISTRY::iterator it = registry.find(name);
            if (it != registry.end()) {
                delete it->second;
                it->second = ret;
            } else {
                registry.insert(REGISTRY::value_type(name, ret));
            }
            SDL_mutexV(registry_mutex);
        }

        if (save) {
            if (save_in_thread) {
                (void)SDL_CreateThread(my_saver, new SaveInfo(ret, name));
            } else {
                ret->save(name);
            }
        }
    }
    SDL_mutexV(as_mutex);
    return ret;
}

void AudioSystemImpl::listDevices() {
    (void)Pa_Initialize();
#ifndef PAV19
    int numdevices = Pa_CountDevices();
    int defaultin = Pa_GetDefaultInputDeviceID();
    int defaultout = Pa_GetDefaultOutputDeviceID();

    fprintf(stderr, "Counted %d device%s. Device #0 for default (?).\n", numdevices, numdevices == 1 ? "" : "s");
    for (int i = 0; i < numdevices; ++i) {
        const PaDeviceInfo* d = Pa_GetDeviceInfo(i);
        fprintf(stderr,
                "Device #%d%s%s\n"
                "\tstructVersion   : %d\n"
                "\tname            : %s\n"
                "\tmaxInputChannels: %d\n"
                "\tmaxOutputChans  : %d\n"
                "\tsampleFormats   : %lx\n"
                "\tsampleRates     : ",
                i,
                (i == defaultin  ? " (Default Input)"  : ""),
                (i == defaultout ? " (Default Output)" : ""),
                d->structVersion, d->name,
                d->maxInputChannels, d->maxOutputChannels,
                d->nativeSampleFormats);
        if (d->numSampleRates < 0) {
            fprintf(stderr,
                    "%.0f -- %.0f\n",
                    d->sampleRates[0], d->sampleRates[1]);
        } else {
            if (d->numSampleRates > 0)
                fprintf(stderr, "%.0f", d->sampleRates[0]);
            for (int j = 1; j < d->numSampleRates; ++j) {
                fprintf(stderr, ", %.0f", d->sampleRates[j]);
            }
            fprintf(stderr, "\n");
        }
    }
#else

#endif
}

---