jarikomppa/soloud

Free, easy, portable audio engine for games

SoLoud

SoLoud is an easy to use, free, portable c/c++ audio engine for games.

Zlib/LibPng licensed. Portable. Easy.

Official site with documentation can be found at: http://soloud-audio.com

soloud's Issues

modplug: faster instances

It should be possible to change the libmodplug so that we can have several "playheads" for one set of data that's loaded. This would also make creation of instances faster, as parsing would only happen on load() time.

Higher quality resampler(s)

While lerp resampler is better than nothing, SoLoud needs a higher quality resampler (or few).

float probably not a good variable type for time

After about a day, float starts to run out of precision, so it's probably not a good choise in the long run - consider alternatives / workarounds.

Android support via OpenSL ES

Precision sound triggering

Need to be able to trigger sounds at a better accuracy than at the start of a sound buffer. Use case: shmup where lots of things are shooting and triggering sounds. Currently most of the sounds will just overlap.

integrate sfxr

The author of sfxr gave us permission to re-license sfxr under zlib/libpng license, so do so and integrate sfxr as an audio source.

Expose more of libmodplug api

Find a soloud api-friendly way of exposing more of libmodplug api (like querying current pattern or whatnot)

Investigate different glue interfaces that can be added to the codegen

Such as darkbasic, glbasic, blitzmax, etc. I'll need people who use those languages to help with this.

FFT filter framework

Create a sub-classable fft filter class that handles fft / ifft and lets the 'payload' do things like pitch shifting.

3d audio testing

3d audio isn't completely tested, the look-at matrix might work as is, or it might need work, attenuation modes might have some issues, etc.

64 bit builds

Someone's bound to need a 64bit build eventually. At least back ends (dyndll stuff) needs a lot of work.

emscripten build support

Make an emscripten-friendly build mode.

Stream from memory

Currently, SoLoud has two ways of handling wave data: completely uncompressed to memory, or completely streamed off disk. An intermediary approach could also be useful, where compressed data is in memory and is decompressed on the fly. In this context, raw 16 and 8 bit audio is also considered to be "compressed".

Chain sounds with gapless playback

Often you want to seamlessly segue from a sound effect to a new music track, or do consecutive sound effects or seamless playback of multiple pieces of music one after another.

Would be nice to have basic functionality in soloud to achieve these without having to code your own callback magic crap.

Implement architecture for mixing busses

One of the "basic" features SoLoud still lacks are mixing busses.

Sample loop points

Implement loop points to audio. Currently looping always jumps to the beginning of the stream.

Test Thread::wait and Thread::release on linux

Refactor OpenAL back-end to use the new thread functions and test on Linux.

Resamplers

Create API for resamplers (fast and high quality options)

Support for surround speakers (4, 5.1 ,7.1, ...)

Architectural work: figure out what to actually do with the speakers

• Panning
  • "Stereo arc"
  • "Speaker fill"
• 3d audio
  • Also with stereo speakers..

Wave length

Add methods to get the length of a wave source.

FFT library replacement?

The ffft library is great, but takes ages to compile; we don't need the flexibility, and instead only really need some specific fixed-width fft/ifft solution.

Codegen should generate wrapper code via templates

The codegen should also parse a template file and generate custom output to make generation of various non-c wrappers easier.

Visualization data from different points of graph

Currently, visualization data is gathered from the exit point of the sound graph. It would be better if the data could be gathered from any point, or at least from the output of any mix bus.

This way the visualization wouldn't be hampered by global volume changes, filters down the line etc, and thus it would be possible to create visualizations "in the world", instead of just the global output.

Research sfml / allegro

Research whether making back-ends for sfml and allegro makes sense, and implement them if there's a chance of getting low latency

portaudio support improvements

We're doing plenty of stuff in the portaudio callback that portaudio documentation directly forbids, including file i/o and memory allocations.

A better way would probably be to run a separate thread that performs those calculations in advance, and gets triggered by the portaudio callback whenever we've run out of ready material.

Negative side effect from this is increased latency, and things seem to work fine..

Emscripten support

Try to figure out whether it's possible to get SoLoud to work through emscripten. May require new features in Emscripten to work.

WASAPI windows back-end

Implement WASAPI windows back-end.

Generalize "memory file i/o"

The wav/wavstream classes have some "read file from memory pointer" functionality, this should probably be generalized to reduce copypasta.

My fear with this is that this move will turn soloud more into one of those feature creep monsters and will be tweeting its status in a couple years..

Add ruby wrapper generator

rpg maker seems to use ruby, so having a ruby wrapper might benefit at least those guys..

Broken build

Looks like soloud_bus.h is missing (probably .cpp too)

SDL2 dll mutex functions

Fix the SDL back-end to load sdl2 dll correctly (different mutex function names)

[suggestion] make demos cross-platform

most (SDL) demos might be cross-platform by switching from SDL graphics (which is legacy 1.2 anyways) into text ascii art
maybe a single header-only portable console library with gotoxy()/clear() and (color) printfs should be enough

XM / MOD player

Find or implement a free XM / MOD player, and implement it as an audio source.

Simple recording plugin?

Hi,

would it be possible to get a simple microphone recording plugin?
I suggest some API like:
bool record_start( );
AudioSourceInstance* record_stop(); // no idea about the return value - but it would return a buffer that you can immediately play or analyze.

typedef for different kinds of int data

Should define typedefs for sound handles and errorcode return codes to make it more obvious what different ints are.

Integrate modplug

Integrate the public domain modplug as an audio source (mod/midi format support)

Redesign handling of number of voices

Instead of fixed max number of voices, soloud probably should sort the sounds by audibility and only play the N most audible.

It makes more sense to "play" hundreds of audio loops in positional audio, but most of those are not audible at the same time (actually, most will have a volume of 0).

osx port

Figure out audio interface(s) in osx for new backends
Solve dyndll loading in osx for existing backends

Speech enhancement filters

SoLoud needs filters to adjust the way the speech synth sounds. Result doesn't (necessarily) need to be legible. Stuff like robotize, radio static, "blackmailer masked voice", etc.

Create FFT-based filter base

ADPCM compressed wav support

Add ADPCM compressed audio support to wave loader

Implement OSS back-end on Linux

Implement direct /dev/dsp back-end on Linux.

3d audio and clicks

Since the panning volumes only change once per audio buffer, it produces audible clicks. Add small ramps to fix this. (Might simplify the mixer because after this we might not need to evaluate volume faders once per sample).

better FFT implementation

I'm not quite satisfied with the current FFT implementation; I'm not certain, but I think doing fft + ifft should result in more or less the same signal, instead of blowing up the amplitude. Also, I know it could be faster, especially since we use a fixed window size.

The code has already been refactored so that replacing the implementation should be simpler.

Add visualization waveform output

Short mono-mix of current output audio. Only generated if enabled via flag at init time.

Integrate SoLoud to real-world game(s)

Replacing the audio system in some full-scale game would be a great way to test and stress SoLoud.

Error handling

Currently, the SoLoud api has no mechanism for error reporting. Design and implement a non-invasive mechanism. Exceptions can't be used.

Synchronized stream startup / other atomic ops

Currently there's no guarantee that when starting (or unpausing) two streams, they'll start at the same time. Second one may end up in the next output buffer.

Settle on makefile system and implement it

Should make static libraries and binaries of the tests, at least.

C-interface and DLL

One of the requested features is a DLL interface, mainly so that SoLoud could be used from other languages than c++. Creating the DLL requires a plain "C" interface. The "C" interface could be largely autogenerated by parsing the header files and generating the glue code. Some bits, like custom audio sources, are either harder or impossible, but most of SoLoud's functionality should wrap into a "C" interface rather nicely.