3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
4 OpenAL support based on work by:
5 Copyright (C) 2011 Sebastian 'Bahamada' Rühl
6 Copyright (C) 2011 Cyriaque 'Cisoun' Skrapits <cysoun@gmail.com>
7 Copyright (C) 2011 Giuseppe Bilotta <giuseppe.bilotta@gmail.com>
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU Lesser General Public License as published by
11 the Free Software Foundation; either version 2.1 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU Lesser General Public License for more details.
19 You should have received a copy of the GNU Lesser General Public License along
20 with this program; ifnot, write to the Free Software Foundation, Inc.,
21 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 #include "sound_openal.h"
30 #elif defined(__APPLE__)
31 #include <OpenAL/al.h>
32 #include <OpenAL/alc.h>
33 //#include <OpenAL/alext.h>
39 #include <vorbis/vorbisfile.h>
42 #include "util/numeric.h" // myrand()
46 #include <unordered_map>
48 #define BUFFER_SIZE 30000
50 static const char *alcErrorString(ALCenum err)
55 case ALC_INVALID_DEVICE:
56 return "invalid device";
57 case ALC_INVALID_CONTEXT:
58 return "invalid context";
59 case ALC_INVALID_ENUM:
60 return "invalid enum";
61 case ALC_INVALID_VALUE:
62 return "invalid value";
63 case ALC_OUT_OF_MEMORY:
64 return "out of memory";
66 return "<unknown OpenAL error>";
70 static const char *alErrorString(ALenum err)
76 return "invalid name";
78 return "invalid enum";
79 case AL_INVALID_VALUE:
80 return "invalid value";
81 case AL_INVALID_OPERATION:
82 return "invalid operation";
83 case AL_OUT_OF_MEMORY:
84 return "out of memory";
86 return "<unknown OpenAL error>";
90 static ALenum warn_if_error(ALenum err, const char *desc)
92 if(err == AL_NO_ERROR)
94 warningstream<<desc<<": "<<alErrorString(err)<<std::endl;
98 void f3_set(ALfloat *f3, v3f v)
110 std::vector<char> buffer;
113 SoundBuffer *load_opened_ogg_file(OggVorbis_File *oggFile,
114 const std::string &filename_for_logging)
116 int endian = 0; // 0 for Little-Endian, 1 for Big-Endian
119 char array[BUFFER_SIZE]; // Local fixed size array
122 SoundBuffer *snd = new SoundBuffer;
124 // Get some information about the OGG file
125 pInfo = ov_info(oggFile, -1);
127 // Check the number of channels... always use 16-bit samples
128 if(pInfo->channels == 1)
129 snd->format = AL_FORMAT_MONO16;
131 snd->format = AL_FORMAT_STEREO16;
133 // The frequency of the sampling rate
134 snd->freq = pInfo->rate;
136 // Keep reading until all is read
139 // Read up to a buffer's worth of decoded sound data
140 bytes = ov_read(oggFile, array, BUFFER_SIZE, endian, 2, 1, &bitStream);
145 infostream << "Audio: Error decoding "
146 << filename_for_logging << std::endl;
151 // Append to end of buffer
152 snd->buffer.insert(snd->buffer.end(), array, array + bytes);
155 alGenBuffers(1, &snd->buffer_id);
156 alBufferData(snd->buffer_id, snd->format,
157 &(snd->buffer[0]), snd->buffer.size(),
160 ALenum error = alGetError();
162 if(error != AL_NO_ERROR){
163 infostream<<"Audio: OpenAL error: "<<alErrorString(error)
164 <<"preparing sound buffer"<<std::endl;
167 infostream << "Audio file "
168 << filename_for_logging << " loaded" << std::endl;
176 SoundBuffer *load_ogg_from_file(const std::string &path)
178 OggVorbis_File oggFile;
180 // Try opening the given file.
181 // This requires libvorbis >= 1.3.2, as
182 // previous versions expect a non-const char *
183 if (ov_fopen(path.c_str(), &oggFile) != 0) {
184 infostream << "Audio: Error opening " << path
185 << " for decoding" << std::endl;
189 return load_opened_ogg_file(&oggFile, path);
192 struct BufferSource {
198 size_t buffer_sound_read_func(void *ptr, size_t size, size_t nmemb, void *datasource)
200 BufferSource *s = (BufferSource *)datasource;
201 size_t copied_size = MYMIN(s->len - s->cur_offset, size);
202 memcpy(ptr, s->buf + s->cur_offset, copied_size);
203 s->cur_offset += copied_size;
207 int buffer_sound_seek_func(void *datasource, ogg_int64_t offset, int whence)
209 BufferSource *s = (BufferSource *)datasource;
210 if (whence == SEEK_SET) {
211 if (offset < 0 || (size_t)MYMAX(offset, 0) >= s->len) {
212 // offset out of bounds
215 s->cur_offset = offset;
217 } else if (whence == SEEK_CUR) {
218 if ((size_t)MYMIN(-offset, 0) > s->cur_offset
219 || s->cur_offset + offset > s->len) {
220 // offset out of bounds
223 s->cur_offset += offset;
226 // invalid whence param (SEEK_END doesn't have to be supported)
230 long BufferSourceell_func(void *datasource)
232 BufferSource *s = (BufferSource *)datasource;
233 return s->cur_offset;
236 static ov_callbacks g_buffer_ov_callbacks = {
237 &buffer_sound_read_func,
238 &buffer_sound_seek_func,
240 &BufferSourceell_func
243 SoundBuffer *load_ogg_from_buffer(const std::string &buf, const std::string &id_for_log)
245 OggVorbis_File oggFile;
252 if (ov_open_callbacks(&s, &oggFile, NULL, 0, g_buffer_ov_callbacks) != 0) {
253 infostream << "Audio: Error opening " << id_for_log
254 << " for decoding" << std::endl;
258 return load_opened_ogg_file(&oggFile, id_for_log);
267 class OpenALSoundManager: public ISoundManager
270 OnDemandSoundFetcher *m_fetcher;
272 ALCcontext *m_context;
274 std::unordered_map<std::string, std::vector<SoundBuffer*>> m_buffers;
275 std::unordered_map<int, PlayingSound*> m_sounds_playing;
279 FadeState(float step, float current_gain, float target_gain):
281 current_gain(current_gain),
282 target_gain(target_gain) {}
288 std::unordered_map<int, FadeState> m_sounds_fading;
291 bool m_is_initialized;
292 OpenALSoundManager(OnDemandSoundFetcher *fetcher):
298 m_is_initialized(false)
300 ALCenum error = ALC_NO_ERROR;
302 infostream<<"Audio: Initializing..."<<std::endl;
304 m_device = alcOpenDevice(NULL);
306 infostream<<"Audio: No audio device available, audio system "
307 <<"not initialized"<<std::endl;
311 m_context = alcCreateContext(m_device, NULL);
313 error = alcGetError(m_device);
314 infostream<<"Audio: Unable to initialize audio context, "
315 <<"aborting audio initialization ("<<alcErrorString(error)
317 alcCloseDevice(m_device);
322 if(!alcMakeContextCurrent(m_context) ||
323 (error = alcGetError(m_device) != ALC_NO_ERROR))
325 infostream<<"Audio: Error setting audio context, aborting audio "
326 <<"initialization ("<<alcErrorString(error)<<")"<<std::endl;
327 alcDestroyContext(m_context);
329 alcCloseDevice(m_device);
334 alDistanceModel(AL_INVERSE_DISTANCE);
336 infostream<<"Audio: Initialized: OpenAL "<<alGetString(AL_VERSION)
337 <<", using "<<alcGetString(m_device, ALC_DEVICE_SPECIFIER)
340 m_is_initialized = true;
343 ~OpenALSoundManager()
345 infostream<<"Audio: Deinitializing..."<<std::endl;
347 // TODO: Clear SoundBuffers
348 alcMakeContextCurrent(NULL);
349 alcDestroyContext(m_context);
351 alcCloseDevice(m_device);
354 for (std::unordered_map<std::string, std::vector<SoundBuffer*>>::iterator i =
355 m_buffers.begin(); i != m_buffers.end(); ++i) {
356 for (std::vector<SoundBuffer*>::iterator iter = (*i).second.begin();
357 iter != (*i).second.end(); ++iter) {
363 infostream<<"Audio: Deinitialized."<<std::endl;
366 void step(float dtime)
371 void addBuffer(const std::string &name, SoundBuffer *buf)
373 std::unordered_map<std::string, std::vector<SoundBuffer*>>::iterator i =
374 m_buffers.find(name);
375 if(i != m_buffers.end()){
376 i->second.push_back(buf);
379 std::vector<SoundBuffer*> bufs;
381 m_buffers[name] = bufs;
385 SoundBuffer* getBuffer(const std::string &name)
387 std::unordered_map<std::string, std::vector<SoundBuffer*>>::iterator i =
388 m_buffers.find(name);
389 if(i == m_buffers.end())
391 std::vector<SoundBuffer*> &bufs = i->second;
392 int j = myrand() % bufs.size();
396 PlayingSound* createPlayingSound(SoundBuffer *buf, bool loop,
397 float volume, float pitch)
399 infostream<<"OpenALSoundManager: Creating playing sound"<<std::endl;
401 PlayingSound *sound = new PlayingSound;
403 warn_if_error(alGetError(), "before createPlayingSound");
404 alGenSources(1, &sound->source_id);
405 alSourcei(sound->source_id, AL_BUFFER, buf->buffer_id);
406 alSourcei(sound->source_id, AL_SOURCE_RELATIVE, true);
407 alSource3f(sound->source_id, AL_POSITION, 0, 0, 0);
408 alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
409 alSourcei(sound->source_id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
410 volume = MYMAX(0.0, volume);
411 alSourcef(sound->source_id, AL_GAIN, volume);
412 alSourcef(sound->source_id, AL_PITCH, pitch);
413 alSourcePlay(sound->source_id);
414 warn_if_error(alGetError(), "createPlayingSound");
418 PlayingSound* createPlayingSoundAt(SoundBuffer *buf, bool loop,
419 float volume, v3f pos, float pitch)
421 infostream<<"OpenALSoundManager: Creating positional playing sound"
424 PlayingSound *sound = new PlayingSound;
426 warn_if_error(alGetError(), "before createPlayingSoundAt");
427 alGenSources(1, &sound->source_id);
428 alSourcei(sound->source_id, AL_BUFFER, buf->buffer_id);
429 alSourcei(sound->source_id, AL_SOURCE_RELATIVE, false);
430 alSource3f(sound->source_id, AL_POSITION, pos.X, pos.Y, pos.Z);
431 alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
432 alSourcef(sound->source_id, AL_REFERENCE_DISTANCE, 30.0);
433 alSourcei(sound->source_id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
434 volume = MYMAX(0.0, volume);
435 alSourcef(sound->source_id, AL_GAIN, volume);
436 alSourcef(sound->source_id, AL_PITCH, pitch);
437 alSourcePlay(sound->source_id);
438 warn_if_error(alGetError(), "createPlayingSoundAt");
442 int playSoundRaw(SoundBuffer *buf, bool loop, float volume, float pitch)
445 PlayingSound *sound = createPlayingSound(buf, loop, volume, pitch);
448 int id = m_next_id++;
449 m_sounds_playing[id] = sound;
453 int playSoundRawAt(SoundBuffer *buf, bool loop, float volume, v3f pos, float pitch)
456 PlayingSound *sound = createPlayingSoundAt(buf, loop, volume, pos, pitch);
459 int id = m_next_id++;
460 m_sounds_playing[id] = sound;
464 void deleteSound(int id)
466 std::unordered_map<int, PlayingSound*>::iterator i = m_sounds_playing.find(id);
467 if(i == m_sounds_playing.end())
469 PlayingSound *sound = i->second;
471 alDeleteSources(1, &sound->source_id);
474 m_sounds_playing.erase(id);
477 /* If buffer does not exist, consult the fetcher */
478 SoundBuffer* getFetchBuffer(const std::string &name)
480 SoundBuffer *buf = getBuffer(name);
485 std::set<std::string> paths;
486 std::set<std::string> datas;
487 m_fetcher->fetchSounds(name, paths, datas);
488 for(std::set<std::string>::iterator i = paths.begin();
489 i != paths.end(); ++i){
490 loadSoundFile(name, *i);
492 for(std::set<std::string>::iterator i = datas.begin();
493 i != datas.end(); ++i){
494 loadSoundData(name, *i);
496 return getBuffer(name);
499 // Remove stopped sounds
502 verbosestream<<"OpenALSoundManager::maintain(): "
503 <<m_sounds_playing.size()<<" playing sounds, "
504 <<m_buffers.size()<<" sound names loaded"<<std::endl;
505 std::set<int> del_list;
506 for(std::unordered_map<int, PlayingSound*>::iterator i = m_sounds_playing.begin();
507 i != m_sounds_playing.end(); ++i) {
509 PlayingSound *sound = i->second;
510 // If not playing, remove it
513 alGetSourcei(sound->source_id, AL_SOURCE_STATE, &state);
514 if(state != AL_PLAYING){
519 if(!del_list.empty())
520 verbosestream<<"OpenALSoundManager::maintain(): deleting "
521 <<del_list.size()<<" playing sounds"<<std::endl;
522 for(std::set<int>::iterator i = del_list.begin();
523 i != del_list.end(); ++i)
531 bool loadSoundFile(const std::string &name,
532 const std::string &filepath)
534 SoundBuffer *buf = load_ogg_from_file(filepath);
536 addBuffer(name, buf);
540 bool loadSoundData(const std::string &name,
541 const std::string &filedata)
543 SoundBuffer *buf = load_ogg_from_buffer(filedata, name);
545 addBuffer(name, buf);
549 void updateListener(v3f pos, v3f vel, v3f at, v3f up)
551 m_listener_pos = pos;
552 alListener3f(AL_POSITION, pos.X, pos.Y, pos.Z);
553 alListener3f(AL_VELOCITY, vel.X, vel.Y, vel.Z);
557 alListenerfv(AL_ORIENTATION, f);
558 warn_if_error(alGetError(), "updateListener");
561 void setListenerGain(float gain)
563 alListenerf(AL_GAIN, gain);
566 int playSound(const std::string &name, bool loop, float volume, float fade, float pitch)
571 SoundBuffer *buf = getFetchBuffer(name);
573 infostream<<"OpenALSoundManager: \""<<name<<"\" not found."
579 handle = playSoundRaw(buf, loop, 0.0f, pitch);
580 fadeSound(handle, fade, volume);
582 handle = playSoundRaw(buf, loop, volume, pitch);
587 int playSoundAt(const std::string &name, bool loop, float volume, v3f pos, float pitch)
592 SoundBuffer *buf = getFetchBuffer(name);
594 infostream<<"OpenALSoundManager: \""<<name<<"\" not found."
598 return playSoundRawAt(buf, loop, volume, pos, pitch);
601 void stopSound(int sound)
607 void fadeSound(int soundid, float step, float gain)
609 m_sounds_fading[soundid] = FadeState(step, getSoundGain(soundid), gain);
612 void doFades(float dtime)
614 m_fade_delay += dtime;
616 if (m_fade_delay < 0.1f)
620 for (std::unordered_map<int, FadeState>::iterator i = m_sounds_fading.begin();
621 i != m_sounds_fading.end();) {
622 if (i->second.step < 0.f)
623 chkGain = -(i->second.current_gain);
625 chkGain = i->second.current_gain;
627 if (chkGain < i->second.target_gain) {
628 i->second.current_gain += (i->second.step * m_fade_delay);
629 i->second.current_gain = rangelim(i->second.current_gain, 0, 1);
631 updateSoundGain(i->first, i->second.current_gain);
634 if (i->second.target_gain <= 0.f)
637 m_sounds_fading.erase(i++);
643 bool soundExists(int sound)
646 return (m_sounds_playing.count(sound) != 0);
649 void updateSoundPosition(int id, v3f pos)
651 std::unordered_map<int, PlayingSound*>::iterator i = m_sounds_playing.find(id);
652 if (i == m_sounds_playing.end())
654 PlayingSound *sound = i->second;
656 alSourcei(sound->source_id, AL_SOURCE_RELATIVE, false);
657 alSource3f(sound->source_id, AL_POSITION, pos.X, pos.Y, pos.Z);
658 alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
659 alSourcef(sound->source_id, AL_REFERENCE_DISTANCE, 30.0);
662 bool updateSoundGain(int id, float gain)
664 std::unordered_map<int, PlayingSound*>::iterator i = m_sounds_playing.find(id);
665 if (i == m_sounds_playing.end())
668 PlayingSound *sound = i->second;
669 alSourcef(sound->source_id, AL_GAIN, gain);
673 float getSoundGain(int id)
675 std::unordered_map<int, PlayingSound*>::iterator i = m_sounds_playing.find(id);
676 if (i == m_sounds_playing.end())
679 PlayingSound *sound = i->second;
681 alGetSourcef(sound->source_id, AL_GAIN, &gain);
686 ISoundManager *createOpenALSoundManager(OnDemandSoundFetcher *fetcher)
688 OpenALSoundManager *m = new OpenALSoundManager(fetcher);
689 if(m->m_is_initialized)