Leviathan::SoundDevice Class Reference

Manages loading the audio library and provides some helpers. More...

#include <SoundDevice.h>

Classes
struct	Implementation

Public Member Functions
DLLEXPORT	SoundDevice ()
DLLEXPORT	~SoundDevice ()
DLLEXPORT bool	Init (bool simulatesound=false)
DLLEXPORT void	Release ()
DLLEXPORT void	Tick (int PassedMs)
DLLEXPORT void	SetSoundListenerPosition (const Float3 &pos, const Float4 &orientation)
	Loads the file and plays the sound. More...
DLLEXPORT void	SetGlobalVolume (float vol)
DLLEXPORT void	Play2DSoundEffect (const std::string &filename)
	Plays a 2d sound without possibility of interrupting. More...
DLLEXPORT AudioSource::pointer	Play2DSound (const std::string &filename, bool looping)
	Plays a 2d sound with options. More...
DLLEXPORT AudioSource::pointer	CreateProceduralSound (const Sound::ProceduralSoundData::pointer &data, size_t chunksize=56000, size_t chunkstoqueue=4)
	Opens an audio source from a procedural data stream. More...
DLLEXPORT Sound::AudioBuffer::pointer	GetBufferFromFile (const std::string &filename, bool cache=true)
	Creates a sound buffer from a file. More...
DLLEXPORT AudioSource::pointer	GetAudioSource ()
	Creates an audio source with no settings applied. More...
DLLEXPORT void	BabysitAudio (AudioSource::pointer audio)
	This class holds the audio source until it has finished playing and then releases the reference. More...
DLLEXPORT void	ReportDestroyedBuffer (Sound::AudioBuffer &buffer)

Detailed Description

Manages loading the audio library and provides some helpers.

Definition at line 15 of file SoundDevice.h.

Constructor & Destructor Documentation

SoundDevice()

SoundDevice::SoundDevice

(

)

Definition at line 57 of file SoundDevice.cpp.

: Pimpl(std::make_unique<Implementation>()) {}

~SoundDevice()

SoundDevice::~SoundDevice

(

)

Definition at line 58 of file SoundDevice.cpp.

{
    Release();
    Pimpl.reset();
}

Member Function Documentation

BabysitAudio()

DLLEXPORT void SoundDevice::BabysitAudio

(

AudioSource::pointer

audio

)

This class holds the audio source until it has finished playing and then releases the reference.

Definition at line 397 of file SoundDevice.cpp.

{
    Engine::Get()->AssertIfNotMainThread();

    Pimpl->HandledAudioSources.push_back(audio);
}

CreateProceduralSound()

DLLEXPORT AudioSource::pointer SoundDevice::CreateProceduralSound	(	const Sound::ProceduralSoundData::pointer &	data,
		size_t	chunksize = 56000,
		size_t	chunkstoqueue = 4
	)

Opens an audio source from a procedural data stream.

Definition at line 332 of file SoundDevice.cpp.

{
    Engine::Get()->AssertIfNotMainThread();

    if(!Pimpl || !data)
        return nullptr;

    const auto source = GetAudioSource();

    if(!source)
        return nullptr;

    source->PlayWithDecoder(data, chunksize, chunkstoqueue);
    return source;
}

GetAudioSource()

DLLEXPORT AudioSource::pointer SoundDevice::GetAudioSource

(

)

Creates an audio source with no settings applied.

Definition at line 385 of file SoundDevice.cpp.

{
    auto alureSource = Pimpl->Context.createSource();

    if(!alureSource) {
        LOG_ERROR("SoundDevice: GetAudioSource: couldn't create alure source");
        return nullptr;
    }

    return AudioSource::MakeShared<AudioSource>(alureSource);
}

GetBufferFromFile()

DLLEXPORT Sound::AudioBuffer::pointer SoundDevice::GetBufferFromFile	(	const std::string &	filename,
		bool	cache = true
	)

Creates a sound buffer from a file.

Definition at line 350 of file SoundDevice.cpp.

{
    const auto now = Time::GetTimeMs64();

    AudioBuffer::pointer buffer;

    // Find buffer from cache
    if(cache) {
        const auto found = Pimpl->BufferCache.find(filename);

        if(found != Pimpl->BufferCache.end()) {
            buffer = std::get<0>(found->second);
            std::get<1>(found->second) = now;
        }
    }

    if(!buffer) {
        // Not cached
        auto alureBuffer = Pimpl->Context.getBuffer(filename);

        if(!alureBuffer) {
            LOG_ERROR("SoundDevice: failed to create buffer from file: " + filename);
            return nullptr;
        }

        buffer = AudioBuffer::MakeShared<AudioBuffer>(std::move(alureBuffer), this);

        if(cache)
            Pimpl->BufferCache[filename] = {buffer, now};
    }

    return buffer;
}

Init()

bool SoundDevice::Init

(

bool

simulatesound = false

)

Parameters

simulatenosound

If true the sound device isn't initialized to simulate not having a valid audio device (or if the user just doesn't want sound)

Definition at line 64 of file SoundDevice.cpp.

{
    if(simulatesound) {
        LOG_WARNING("SoundDevice: simulating not having a playing device");
        return true;
    }

    Pimpl->DeviceManager = alure::DeviceManager::getInstance();

    const auto defaultChoice =
        Pimpl->DeviceManager.defaultDeviceName(alure::DefaultDeviceType::Full);

    auto devices = Pimpl->DeviceManager.enumerate(alure::DeviceEnumeration::Full);

    if(defaultChoice.empty()) {

        LOG_ERROR("SoundDevice: no default sound device detected");
        return false;
    }

    if(devices.empty()) {

        LOG_ERROR("SoundDevice: no audio devices detected");
        return false;
    }

    std::string selectedDevice;
    // There's no print error here if missing to make tests run
    ObjectFileProcessor::LoadValueFromNamedVars<std::string>(
        Engine::Get()->GetDefinition()->GetValues(), "AudioDevice", selectedDevice, "default");

    if(selectedDevice == "default") {

        selectedDevice = defaultChoice;

    } else if(std::find(devices.begin(), devices.end(), selectedDevice) == devices.end()) {
        LOG_ERROR("SoundDevice: selected audio device \"" + selectedDevice +
                  "\" doesn't exists. Using default");
        selectedDevice = defaultChoice;
    }

    LOG_INFO("SoundDevice: Initializing sound with device: " + selectedDevice);

    std::stringstream sstream;

    sstream << "Start of audio system information:\n"
            << "// ------------------------------------ //\n";

    auto defaultDeviceName =
        Pimpl->DeviceManager.defaultDeviceName(alure::DefaultDeviceType::Basic);
    devices = Pimpl->DeviceManager.enumerate(alure::DeviceEnumeration::Basic);

    sstream << "Available basic devices:\n";
    for(const auto& name : devices) {
        sstream << "\t> " << name;
        if(name == defaultDeviceName)
            sstream << " [DEFAULT]";
        sstream << "\n";
    }

    sstream << "\n";

    devices = Pimpl->DeviceManager.enumerate(alure::DeviceEnumeration::Full);
    defaultDeviceName = Pimpl->DeviceManager.defaultDeviceName(alure::DefaultDeviceType::Full);

    sstream << "Available devices:\n";
    for(const auto& name : devices) {
        sstream << "\t> " << name;
        if(name == defaultDeviceName)
            sstream << " [DEFAULT]";
        sstream << "\n";
    }
    sstream << "\n";

    devices = Pimpl->DeviceManager.enumerate(alure::DeviceEnumeration::Capture);
    defaultDeviceName =
        Pimpl->DeviceManager.defaultDeviceName(alure::DefaultDeviceType::Capture);
    sstream << "Available capture devices:\n";
    for(const auto& name : devices) {
        sstream << "\t> " << name;
        if(name == defaultDeviceName)
            sstream << " [DEFAULT]";
        sstream << "\n";
    }
    sstream << "\n";

    try {
        Pimpl->Device = Pimpl->DeviceManager.openPlayback(selectedDevice);
    } catch(const std::exception& e) {
        LOG_INFO(sstream.str());
        LOG_ERROR("SoundDevice: opening playback failed: " + std::string(e.what()));
        return false;
    }

    sstream << "Info for device \"" << Pimpl->Device.getName(alure::PlaybackName::Full)
            << "\":" << std::endl;
    auto version = Pimpl->Device.getALCVersion();
    sstream << "ALC version: " << version.getMajor() << "." << version.getMinor() << "\n";
    version = Pimpl->Device.getEFXVersion();
    if(!version.isZero()) {
        sstream << "EFX version: " << version.getMajor() << "." << version.getMinor() << "\n";
        sstream << "Max auxiliary sends: " << Pimpl->Device.getMaxAuxiliarySends() << "\n";
    } else
        sstream << "EFX not supported"
                << "\n";

    // TODO: extensions
    // Pimpl->Device.queryExtension(const String &name)

    sstream << "// ------------------------------------ //";

    LOG_INFO(sstream.str());

    try {
        Pimpl->Context = Pimpl->Device.createContext();

        if(!Pimpl->Context)
            throw Exception("returned context is null");

    } catch(const std::exception& e) {
        LOG_ERROR("SoundDevice: opening context failed: " + std::string(e.what()));
        return false;
    }

    alure::Context::MakeCurrent(Pimpl->Context);
    Pimpl->Listener = Pimpl->Context.getListener();

    Pimpl->Context.setMessageHandler(alure::MakeShared<SoundMessageHandler>());

    // Setup global volume //
    SetGlobalVolume(1.f);

    Pimpl->Listener.setPosition({0, 0, 0});
    Pimpl->Listener.set3DParameters(
        // Pos
        {0, 0, 0},
        // Velocity
        {0, 0, 0},
        // Orientation, at and up
        {{0, 0, 0}, {0, 1, 0}});

    return true;
}

Play2DSound()

DLLEXPORT AudioSource::pointer SoundDevice::Play2DSound	(	const std::string &	filename,
		bool	looping
	)

Plays a 2d sound with options.

Returns

The audio source that is playing the sound (this must be held onto until it is done playing, can be passed to BabysitAudio if not manually wanted to be managed or use the SoundEffect variant of this method) may be null on error

Definition at line 311 of file SoundDevice.cpp.

{
    Engine::Get()->AssertIfNotMainThread();

    const auto buffer = GetBufferFromFile(filename);
    if(!buffer)
        return nullptr;

    const auto source = GetAudioSource();

    if(!source)
        return nullptr;

    source->Play2D(buffer);

    if(looping)
        source->SetLooping(true);
    return source;
}

Play2DSoundEffect()

DLLEXPORT void SoundDevice::Play2DSoundEffect

(

const std::string &

filename

)

Plays a 2d sound without possibility of interrupting.

Definition at line 293 of file SoundDevice.cpp.

{
    Engine::Get()->AssertIfNotMainThread();

    const auto buffer = GetBufferFromFile(filename);
    if(!buffer)
        return;

    const auto source = GetAudioSource();

    if(!source)
        return;

    source->Play2D(buffer);

    Engine::Get()->RunOnMainThread([=]() { this->BabysitAudio(source); });
}

Release()

void SoundDevice::Release

(

)

Definition at line 208 of file SoundDevice.cpp.

{
    if(!Pimpl->Device)
        return;

    Pimpl->HandledAudioSources.clear();
    Pimpl->BufferCache.clear();

    alure::Context::MakeCurrent(nullptr);
    Pimpl->Listener = nullptr;
    Pimpl->Context.destroy();
    Pimpl->Device.close();

    Pimpl->Device = nullptr;
}

ReportDestroyedBuffer()

DLLEXPORT void SoundDevice::ReportDestroyedBuffer

(

Sound::AudioBuffer &

buffer

)

Definition at line 404 of file SoundDevice.cpp.

{
    Pimpl->Context.removeBuffer(buffer.GetBuffer());
}

SetGlobalVolume()

DLLEXPORT void SoundDevice::SetGlobalVolume

(

float

vol

)

Parameters

vol	The volume [0.f, 1.f]

Definition at line 286 of file SoundDevice.cpp.

{
    vol = std::clamp(vol, 0.f, 1.f);

    Pimpl->Listener.setGain(vol);
}

SetSoundListenerPosition()

DLLEXPORT void SoundDevice::SetSoundListenerPosition	(	const Float3 &	pos,
		const Float4 &	orientation
	)

Loads the file and plays the sound.

This creates a temporary SoundEffect on a background thread that is loaded from the file and destroyed once it finishes

Returns

False if the file doesn't exist or the sound couldn't be played for some other reason

Definition at line 260 of file SoundDevice.cpp.

{
    if(!Pimpl->Listener)
        return;

    bs::Quaternion quaternion(orientation);

    bs::Radian angle;
    bs::Vector3 direction;

    // TODO: does this do the right thing?
    quaternion.toAxisAngle(direction, angle); // toAngleAxis(angle, direction);

    alure::Vector3 at(0, 0, 0);

    // TODO: better velocity calculation
    const auto temp = pos - Pimpl->PreviousPosition;
    alure::Vector3 velocity(temp.X, temp.Y, temp.Z);

    Pimpl->Listener.set3DParameters(
        {pos.X, pos.Y, pos.Z}, velocity, {at, {direction.x, direction.y, direction.z}});

    Pimpl->PreviousPosition = pos;
}

Tick()

void SoundDevice::Tick

(

int

PassedMs

)

Definition at line 224 of file SoundDevice.cpp.

{
    ElapsedSinceLastClean += PassedMs;

    Pimpl->Context.update();

    if(ElapsedSinceLastClean > 200) {
        ElapsedSinceLastClean = 0;

        for(auto iter = Pimpl->HandledAudioSources.begin();
            iter != Pimpl->HandledAudioSources.end();) {

            if(!(*iter)->IsPlaying()) {

                iter = Pimpl->HandledAudioSources.erase(iter);
            } else {
                ++iter;
            }
        }

        const auto now = Time::GetTimeMs64();

        // Clear cache entries
        for(auto iter = Pimpl->BufferCache.begin(); iter != Pimpl->BufferCache.end();) {

            if(std::get<1>(iter->second) - now > CacheSoundEffectMilliseconds) {
                // Remove from cache

                iter = Pimpl->BufferCache.erase(iter);
            } else {
                ++iter;
            }
        }
    }
}

---

The documentation for this class was generated from the following files:

• SoundDevice.h
• SoundDevice.cpp