AudioPlayback.cc File Reference

#include <Nsound/Nsound.h>
#include <Nsound/AudioBackend.h>
#include <Nsound/AudioBackendLibao.h>
#include <Nsound/AudioBackendLibportaudio.h>
#include <Nsound/AudioBackendType.h>
#include <Nsound/AudioPlayback.h>
#include <Nsound/AudioStream.h>
#include <Nsound/Buffer.h>
#include <Nsound/GuitarBass.h>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>

Include dependency graph for AudioPlayback.cc:

Go to the source code of this file.

Functions
AudioBackend *	allocate_backend (const AudioBackendType &type, const uint32 sample_rate, const uint32 channels, const uint32 bits_per_sample)
template<typename T >
void	play_int (AudioBackend *backend, const AudioStream &a, const float64 &scale)
template<typename T >
void	play_int (AudioBackend *backend, const Buffer &b, const float64 &scale)
template<typename T >
void	_play (AudioPlayback *pb, AudioBackend **be, const T &audio)
std::string	mylower (const std::string &x)

Function Documentation

AudioBackend* allocate_backend	(	const AudioBackendType &	type,
		const uint32	sample_rate,
		const uint32	channels,
		const uint32	bits_per_sample
	)

Definition at line 65 of file AudioPlayback.cc.

References Nsound::BACKEND_TYPE_LIBAO, Nsound::BACKEND_TYPE_LIBPORTAUDIO, and Nsound::BACKEND_TYPE_NONE.

Referenced by Nsound::AudioPlayback::AudioPlayback(), Nsound::AudioPlayback::initialize(), and Nsound::AudioPlayback::scanDevices().

{
    AudioBackend * backend = NULL;

    switch(type)
    {
        case BACKEND_TYPE_LIBAO:
            #ifdef NSOUND_LIBAO
                backend = new AudioBackendLibao(
                    sample_rate,
                    channels,
                    bits_per_sample);
            #endif
            break;

        case BACKEND_TYPE_LIBPORTAUDIO:
            #ifdef NSOUND_LIBPORTAUDIO
                backend = new AudioBackendLibportaudio(
                    sample_rate,
                    channels,
                    bits_per_sample);
            #endif
            break;

        case BACKEND_TYPE_NONE:
            break;
    }

    return backend;
}

template<typename T >

void play_int	(	AudioBackend *	backend,
		const AudioStream &	a,
		const float64 &	scale
	)

Definition at line 317 of file AudioPlayback.cc.

References Nsound::AudioBackend::getChannels(), Nsound::AudioStream::getLength(), Nsound::AudioStream::getNChannels(), M_THROW, and Nsound::AudioBackend::play().

{
    uint32 n_channels = a.getNChannels();

    // If the AudioStream is mono, just call play() for the buffer method and
    // return.
    if(n_channels == 1)
    {
        play_int<T>(backend, a[0], scale);
        return;
    }

    // If the number of channels in the AudioStream doesn't agree with the
    // number of channels of the backend, print error.
    if(n_channels != backend->getChannels())
    {
        M_THROW("Nsound::AudioPlayback::play():"
            << ": AudioStream channels do not match backend channels ("
            << n_channels
            << " != "
            << backend->getChannels()
            << ")");
        return;
    }

    T * array = NULL;

    uint32 n_samples = a.getLength();

    array = new T [n_samples * n_channels];

    if(array == NULL)
    {
        M_THROW("Nsound::AudioPlayback::play():"
            << ": failed allocate memory");
        return;
    }

    uint32 k = 0;
    for(uint32 i = 0; i < n_samples; ++i)
    {
        for(uint32 j = 0; j < n_channels; ++j)
        {
            array[k] = static_cast<T>(a[j][i] * scale);
            ++k;
        }
    }

    backend->play(
        reinterpret_cast<void *>(array),
        n_samples * n_channels * sizeof(T));

    delete array;
}

template<typename T >

void play_int	(	AudioBackend *	backend,
		const Buffer &	b,
		const float64 &	scale
	)

Definition at line 377 of file AudioPlayback.cc.

References Nsound::AudioBackend::getChannels(), Nsound::Buffer::getLength(), and Nsound::AudioBackend::play().

{
    uint32 n_samples = b.getLength();
    uint32 n_channels = backend->getChannels();

    std::vector<T> array;

    array.reserve(n_samples * n_channels);

    uint32 k = 0;
    for(uint32 i = 0; i < n_samples; ++i)
    {
        for(uint32 j = 0; j < n_channels; ++j)
        {
            array.push_back(static_cast<T>(b[i] * scale));
            ++k;
        }
    }

    backend->play(
        reinterpret_cast<void *>(array.data()),
        n_samples * n_channels * sizeof(T));
}

template<typename T >

void _play	(	AudioPlayback *	pb,
		AudioBackend **	be,
		const T &	audio
	)

Definition at line 407 of file AudioPlayback.cc.

References Nsound::AudioPlayback::initialize(), and M_THROW.

{
    pb->initialize();

    if(*be == NULL) return;

    uint32 bits = (*be)->getBitsPerSample();

    switch(bits)
    {
        case 16:
            play_int<int16>(*be, audio, 32768.0);
            break;
        case 32:
            play_int<int32>(*be, audio, 2147483648.0);
            break;

        default:
            M_THROW("Nsound::AudioPlayback::play():"
                << ": Support for "
                << bits
                << "-bit playback not yet implemented");
            break;
    }
}

std::string mylower

(

const std::string &

x

)

Definition at line 555 of file AudioPlayback.cc.

Referenced by Nsound::use().

{
    std::string y = x;
    std::transform(y.begin(), y.end(), y.begin(), ::tolower);
    return y;
}