#include "sound_openal.h"
-#if defined(_MSC_VER)
+#if defined(_WIN32)
#include <al.h>
#include <alc.h>
- #include <alext.h>
#elif defined(__APPLE__)
#include <OpenAL/al.h>
#include <OpenAL/alc.h>
#include <map>
#include <vector>
#include "utility.h" // myrand()
+#include "filesys.h"
#define BUFFER_SIZE 30000
}
}
+static ALenum warn_if_error(ALenum err, const char *desc)
+{
+ if(err == AL_NO_ERROR)
+ return err;
+ errorstream<<"WARNING: "<<desc<<": "<<alErrorString(err)<<std::endl;
+ return err;
+}
+
void f3_set(ALfloat *f3, v3f v)
{
f3[0] = v.X;
struct SoundBuffer
{
- ALenum format;
- ALsizei freq;
- ALuint bufferID;
+ ALenum format;
+ ALsizei freq;
+ ALuint buffer_id;
std::vector<char> buffer;
};
char array[BUFFER_SIZE]; // Local fixed size array
vorbis_info *pInfo;
OggVorbis_File oggFile;
-
+
+ // Do a dumb-ass static string copy for old versions of ov_fopen
+ // because they expect a non-const char*
+ char nonconst[10000];
+ snprintf(nonconst, 10000, "%s", filepath.c_str());
// Try opening the given file
- if(ov_fopen(filepath.c_str(), &oggFile) != 0)
+ //if(ov_fopen(filepath.c_str(), &oggFile) != 0)
+ if(ov_fopen(nonconst, &oggFile) != 0)
{
infostream<<"Audio: Error opening "<<filepath<<" for decoding"<<std::endl;
return NULL;
snd->buffer.insert(snd->buffer.end(), array, array + bytes);
} while (bytes > 0);
- alGenBuffers(1, &snd->bufferID);
- alBufferData(snd->bufferID, snd->format,
+ alGenBuffers(1, &snd->buffer_id);
+ alBufferData(snd->buffer_id, snd->format,
&(snd->buffer[0]), snd->buffer.size(),
snd->freq);
struct PlayingSound
{
+ ALuint source_id;
+ bool loop;
};
class OpenALSoundManager: public ISoundManager
{
private:
+ OnDemandSoundFetcher *m_fetcher;
ALCdevice *m_device;
ALCcontext *m_context;
bool m_can_vorbis;
int m_next_id;
std::map<std::string, std::vector<SoundBuffer*> > m_buffers;
std::map<int, PlayingSound*> m_sounds_playing;
+ v3f m_listener_pos;
public:
- OpenALSoundManager():
+ OpenALSoundManager(OnDemandSoundFetcher *fetcher):
+ m_fetcher(fetcher),
m_device(NULL),
m_context(NULL),
m_can_vorbis(false),
}
std::vector<SoundBuffer*> bufs;
bufs.push_back(buf);
+ m_buffers[name] = bufs;
return;
}
return bufs[j];
}
- void updateListener(v3f pos, v3f vel, v3f at, v3f up)
+ PlayingSound* createPlayingSound(SoundBuffer *buf, bool loop,
+ float volume)
{
- ALfloat f[6];
- f3_set(f, pos);
- alListenerfv(AL_POSITION, f);
- f3_set(f, vel);
- alListenerfv(AL_VELOCITY, f);
- f3_set(f, at);
- f3_set(f+3, up);
- alListenerfv(AL_ORIENTATION, f);
+ infostream<<"OpenALSoundManager: Creating playing sound"<<std::endl;
+ assert(buf);
+ PlayingSound *sound = new PlayingSound;
+ assert(sound);
+ warn_if_error(alGetError(), "before createPlayingSound");
+ alGenSources(1, &sound->source_id);
+ alSourcei(sound->source_id, AL_BUFFER, buf->buffer_id);
+ alSourcei(sound->source_id, AL_SOURCE_RELATIVE, true);
+ alSource3f(sound->source_id, AL_POSITION, 0, 0, 0);
+ alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
+ alSourcei(sound->source_id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
+ volume = MYMAX(0.0, volume);
+ alSourcef(sound->source_id, AL_GAIN, volume);
+ alSourcePlay(sound->source_id);
+ warn_if_error(alGetError(), "createPlayingSound");
+ return sound;
+ }
+
+ PlayingSound* createPlayingSoundAt(SoundBuffer *buf, bool loop,
+ float volume, v3f pos)
+ {
+ infostream<<"OpenALSoundManager: Creating positional playing sound"
+ <<std::endl;
+ assert(buf);
+ PlayingSound *sound = new PlayingSound;
+ assert(sound);
+ warn_if_error(alGetError(), "before createPlayingSoundAt");
+ alGenSources(1, &sound->source_id);
+ alSourcei(sound->source_id, AL_BUFFER, buf->buffer_id);
+ alSourcei(sound->source_id, AL_SOURCE_RELATIVE, false);
+ alSource3f(sound->source_id, AL_POSITION, pos.X, pos.Y, pos.Z);
+ alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
+ //alSourcef(sound->source_id, AL_ROLLOFF_FACTOR, 0.7);
+ alSourcef(sound->source_id, AL_REFERENCE_DISTANCE, 30.0);
+ alSourcei(sound->source_id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
+ volume = MYMAX(0.0, volume);
+ alSourcef(sound->source_id, AL_GAIN, volume);
+ alSourcePlay(sound->source_id);
+ warn_if_error(alGetError(), "createPlayingSoundAt");
+ return sound;
+ }
+
+ int playSoundRaw(SoundBuffer *buf, bool loop, float volume)
+ {
+ assert(buf);
+ PlayingSound *sound = createPlayingSound(buf, loop, volume);
+ if(!sound)
+ return -1;
+ int id = m_next_id++;
+ m_sounds_playing[id] = sound;
+ return id;
+ }
+
+ int playSoundRawAt(SoundBuffer *buf, bool loop, float volume, v3f pos)
+ {
+ assert(buf);
+ PlayingSound *sound = createPlayingSoundAt(buf, loop, volume, pos);
+ if(!sound)
+ return -1;
+ int id = m_next_id++;
+ m_sounds_playing[id] = sound;
+ return id;
+ }
+
+ void deleteSound(int id)
+ {
+ std::map<int, PlayingSound*>::iterator i =
+ m_sounds_playing.find(id);
+ if(i == m_sounds_playing.end())
+ return;
+ PlayingSound *sound = i->second;
+
+ alDeleteSources(1, &sound->source_id);
+
+ delete sound;
+ m_sounds_playing.erase(id);
+ }
+
+ /* If buffer does not exist, consult the fetcher */
+ SoundBuffer* getFetchBuffer(const std::string name)
+ {
+ SoundBuffer *buf = getBuffer(name);
+ if(buf)
+ return buf;
+ if(!m_fetcher)
+ return NULL;
+ std::set<std::string> paths;
+ std::set<std::string> datas;
+ m_fetcher->fetchSounds(name, paths, datas);
+ for(std::set<std::string>::iterator i = paths.begin();
+ i != paths.end(); i++){
+ loadSoundFile(name, *i);
+ }
+ for(std::set<std::string>::iterator i = datas.begin();
+ i != datas.end(); i++){
+ loadSoundData(name, *i);
+ }
+ return getBuffer(name);
}
- bool loadSound(const std::string &name,
+ // Remove stopped sounds
+ void maintain()
+ {
+ verbosestream<<"OpenALSoundManager::maintain(): "
+ <<m_sounds_playing.size()<<" playing sounds, "
+ <<m_buffers.size()<<" sound names loaded"<<std::endl;
+ std::set<int> del_list;
+ for(std::map<int, PlayingSound*>::iterator
+ i = m_sounds_playing.begin();
+ i != m_sounds_playing.end(); i++)
+ {
+ int id = i->first;
+ PlayingSound *sound = i->second;
+ // If not playing, remove it
+ {
+ ALint state;
+ alGetSourcei(sound->source_id, AL_SOURCE_STATE, &state);
+ if(state != AL_PLAYING){
+ del_list.insert(id);
+ }
+ }
+ }
+ if(del_list.size() != 0)
+ verbosestream<<"OpenALSoundManager::maintain(): deleting "
+ <<del_list.size()<<" playing sounds"<<std::endl;
+ for(std::set<int>::iterator i = del_list.begin();
+ i != del_list.end(); i++)
+ {
+ deleteSound(*i);
+ }
+ }
+
+ /* Interface */
+
+ bool loadSoundFile(const std::string &name,
const std::string &filepath)
{
SoundBuffer *buf = loadOggFile(filepath);
addBuffer(name, buf);
return false;
}
- bool loadSound(const std::string &name,
- const std::vector<char> &filedata)
+ bool loadSoundData(const std::string &name,
+ const std::string &filedata)
{
- errorstream<<"OpenALSoundManager: Loading from filedata not"
- " implemented"<<std::endl;
- return false;
+ // The vorbis API sucks; just write it to a file and use vorbisfile
+ // TODO: Actually load it directly from memory
+ std::string basepath = porting::path_user + DIR_DELIM + "cache" +
+ DIR_DELIM + "tmp";
+ std::string path = basepath + DIR_DELIM + "tmp.ogg";
+ verbosestream<<"OpenALSoundManager::loadSoundData(): Writing "
+ <<"temporary file to ["<<path<<"]"<<std::endl;
+ fs::CreateAllDirs(basepath);
+ std::ofstream of(path.c_str(), std::ios::binary);
+ of.write(filedata.c_str(), filedata.size());
+ of.close();
+ return loadSoundFile(name, path);
}
- int playSound(const std::string &name, int loopcount,
- float volume)
+ void updateListener(v3f pos, v3f vel, v3f at, v3f up)
{
- return -1;
+ m_listener_pos = pos;
+ alListener3f(AL_POSITION, pos.X, pos.Y, pos.Z);
+ alListener3f(AL_VELOCITY, vel.X, vel.Y, vel.Z);
+ ALfloat f[6];
+ f3_set(f, at);
+ f3_set(f+3, up);
+ alListenerfv(AL_ORIENTATION, f);
+ warn_if_error(alGetError(), "updateListener");
}
- int playSoundAt(const std::string &name, int loopcount,
- v3f pos, float volume)
+
+ int playSound(const std::string &name, bool loop, float volume)
{
- return -1;
+ maintain();
+ if(name == "")
+ return 0;
+ SoundBuffer *buf = getFetchBuffer(name);
+ if(!buf){
+ infostream<<"OpenALSoundManager: \""<<name<<"\" not found."
+ <<std::endl;
+ return -1;
+ }
+ return playSoundRaw(buf, loop, volume);
+ }
+ int playSoundAt(const std::string &name, bool loop, float volume, v3f pos)
+ {
+ maintain();
+ if(name == "")
+ return 0;
+ SoundBuffer *buf = getFetchBuffer(name);
+ if(!buf){
+ infostream<<"OpenALSoundManager: \""<<name<<"\" not found."
+ <<std::endl;
+ return -1;
+ }
+ return playSoundRawAt(buf, loop, volume, pos);
}
void stopSound(int sound)
{
+ maintain();
+ deleteSound(sound);
+ }
+ bool soundExists(int sound)
+ {
+ maintain();
+ return (m_sounds_playing.count(sound) != 0);
+ }
+ void updateSoundPosition(int id, v3f pos)
+ {
+ std::map<int, PlayingSound*>::iterator i =
+ m_sounds_playing.find(id);
+ if(i == m_sounds_playing.end())
+ return;
+ PlayingSound *sound = i->second;
+
+ alSourcei(sound->source_id, AL_SOURCE_RELATIVE, false);
+ alSource3f(sound->source_id, AL_POSITION, pos.X, pos.Y, pos.Z);
+ alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
+ alSourcef(sound->source_id, AL_REFERENCE_DISTANCE, 30.0);
}
};
-ISoundManager *createSoundManager()
+ISoundManager *createOpenALSoundManager(OnDemandSoundFetcher *fetcher)
{
- return new OpenALSoundManager();
+ return new OpenALSoundManager(fetcher);
};
projects / oweals / minetest.git / blobdiff