taptaudio.cpp

Go to the documentation of this file.

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

/**\file taptaudio.cpp
 * Implementation of the Audio subsystem using portaudio
 * \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 <assert.h>

#include "taptaudio_paimpl.h"

AudioSystem::AudioSystem(AUDIO_FORMAT format,
                         double sampleRate,
                         int inputChannels,
                         int outputChannels,
                         int deviceIDin,
                         int deviceIDout
                        )
:
impl(0)
{
    if (AUDIO_TRACKS == 0) {
        DODEBUG(NOTICE, ("[An] Audio is disabled in the config file"));
        return;
    }
    assert(!instance || "There can only be one audio system!");

    SDL_mutexP(AudioSystemImpl::as_mutex);
    if (format == AF_Default)
        format = AF_Int16;

    try {
        if (AUDIO_TRACKS > 1) {
            switch(format) {
            case AF_Float32:
                impl = new AudioSystemMixerT<float>(inputChannels, outputChannels,
                                                    sampleRate, format, AUDIO_TRACKS,
                                                    deviceIDin, deviceIDout);
                break;
            case AF_Int32:
                impl = new AudioSystemMixerT<Sint32>(inputChannels, outputChannels,
                                                     sampleRate, format, AUDIO_TRACKS,
                                                     deviceIDin, deviceIDout);

                break;
            case AF_Int16:
                impl = new AudioSystemMixerT<Sint16>(inputChannels, outputChannels,
                                                     sampleRate, format, AUDIO_TRACKS,
                                                     deviceIDin, deviceIDout);

                break;
            case AF_Int8:
                impl = new AudioSystemMixerT<Sint8>(inputChannels, outputChannels,
                                                    sampleRate, format, AUDIO_TRACKS,
                                                    deviceIDin, deviceIDout);

                break;
            default: break;

            }
        }
        if (!impl) {
            impl = new AudioSystemImpl(inputChannels, outputChannels, sampleRate, format,
                                       deviceIDin, deviceIDout);

        }
    } catch (PaError &err) {
        DODEBUG(ERROR, ("[Ae] Error initialising audio system: %s",
                        Pa_GetErrorText(err)));
        impl = 0;
    }

    AudioSystem::instance = this;

    SDL_mutexV(AudioSystemImpl::as_mutex);
}

AudioSystem::~AudioSystem() {
    if (impl) {
        impl->stop();
        impl->waitstop();
        delete impl;
    }
    AudioSystem::instance = 0;
}

ASSample* AudioSystem::loadSample(const std::string &name) {
    return (this && impl) ? impl->loadSample(name) : 0;
}

ASSample* AudioSystem::loadRawSample(const std::string &name, void* data, unsigned long size) {
    return (this && impl && data) ? impl->loadRawSample(name, data, size) : 0;
}

bool AudioSystem::mixSample(ASSample *samp, bool record_after, double record_size, float vol, unsigned* trackno) {
    return (this && impl && samp) ? impl->mixSample(samp, record_after, record_size, false, vol, trackno) : false;
}

bool AudioSystem::mixSample(ASSample *samp, float vol, unsigned* trackno) {
    return (this && impl && samp) ? impl->mixSample(samp, false, 0, false, vol, trackno) : false;
}

bool AudioSystem::loopSample(ASSample *samp, float vol, unsigned* trackno) {
    return (this && impl && samp) ? impl->loopSample(samp, vol, trackno) : false;
}

bool AudioSystem::freeSample(ASSample *samp) {
    return (this && impl && samp) ? impl->freeSample(samp) : false;
}

unsigned AudioSystem::stopSample(ASSample *samp, int trackno) {
    return (this && impl && samp) ? impl->stopSample(samp, trackno) : false;
}

bool AudioSystem::startRec(double secondsMax) {
    return (this && impl) ? impl->startRec(secondsMax) : false;
}

ASSample* AudioSystem::stopRec(const std::string &name, bool save, bool save_in_thread) {
    return (this && impl) ? impl->stopRec(name, save, save_in_thread) : 0;
}

bool AudioSystem::isRecording() {
    return (this && impl) ? impl->isRecording() : false;
}

unsigned AudioSystem::setVolume(ASSample *samp, float vol, int trackno) {
    return (this && impl && samp) ? impl->setVolume(samp, vol, trackno) : 0;
}

void AudioSystem::stop() {
    if (this && impl)
        impl->stop();
}

unsigned AudioSystem::AUDIO_TRACKS = 32;
AudioSystem* AudioSystem::instance = 0;


ASSample* AudioSystem::loadSample(const char* name) {
    return loadSample(std::string(name));
}

ASSample* AudioSystem::loadRawSample(const char* name, void* data, unsigned long size) {
    return loadRawSample(std::string(name), data, size);
}

ASSample* AudioSystem::stopRec(const char* name, bool save, bool save_in_thread) {
    return stopRec(std::string(name), save, save_in_thread);
}

void AudioSystem::setDebugLevel(unsigned level) {
    SETDEBUG(level);
}

void AudioSystem::setDebugFile(void* FILESTAR) {
    taptaudio_debug_file = static_cast<FILE*>(FILESTAR);
}

void AudioSystem::listDevices() {
    AudioSystemImpl::listDevices();
}

---