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;
278 FadeState() = default;
280 FadeState(float step, float current_gain, float target_gain):
282 current_gain(current_gain),
283 target_gain(target_gain) {}
289 std::unordered_map<int, FadeState> m_sounds_fading;
292 bool m_is_initialized;
293 OpenALSoundManager(OnDemandSoundFetcher *fetcher):
299 m_is_initialized(false)
301 ALCenum error = ALC_NO_ERROR;
303 infostream<<"Audio: Initializing..."<<std::endl;
305 m_device = alcOpenDevice(NULL);
307 infostream<<"Audio: No audio device available, audio system "
308 <<"not initialized"<<std::endl;
312 m_context = alcCreateContext(m_device, NULL);
314 error = alcGetError(m_device);
315 infostream<<"Audio: Unable to initialize audio context, "
316 <<"aborting audio initialization ("<<alcErrorString(error)
318 alcCloseDevice(m_device);
323 if(!alcMakeContextCurrent(m_context) ||
324 (error = alcGetError(m_device) != ALC_NO_ERROR))
326 infostream<<"Audio: Error setting audio context, aborting audio "
327 <<"initialization ("<<alcErrorString(error)<<")"<<std::endl;
328 alcDestroyContext(m_context);
330 alcCloseDevice(m_device);
335 alDistanceModel(AL_INVERSE_DISTANCE);
337 infostream<<"Audio: Initialized: OpenAL "<<alGetString(AL_VERSION)
338 <<", using "<<alcGetString(m_device, ALC_DEVICE_SPECIFIER)
341 m_is_initialized = true;
344 ~OpenALSoundManager()
346 infostream<<"Audio: Deinitializing..."<<std::endl;
348 // TODO: Clear SoundBuffers
349 alcMakeContextCurrent(NULL);
350 alcDestroyContext(m_context);
352 alcCloseDevice(m_device);
355 for (auto &buffer : m_buffers) {
356 for (SoundBuffer *sb : buffer.second) {
359 buffer.second.clear();
362 infostream<<"Audio: Deinitialized."<<std::endl;
365 void step(float dtime)
370 void addBuffer(const std::string &name, SoundBuffer *buf)
372 std::unordered_map<std::string, std::vector<SoundBuffer*>>::iterator i =
373 m_buffers.find(name);
374 if(i != m_buffers.end()){
375 i->second.push_back(buf);
378 std::vector<SoundBuffer*> bufs;
380 m_buffers[name] = bufs;
383 SoundBuffer* getBuffer(const std::string &name)
385 std::unordered_map<std::string, std::vector<SoundBuffer*>>::iterator i =
386 m_buffers.find(name);
387 if(i == m_buffers.end())
389 std::vector<SoundBuffer*> &bufs = i->second;
390 int j = myrand() % bufs.size();
394 PlayingSound* createPlayingSound(SoundBuffer *buf, bool loop,
395 float volume, float pitch)
397 infostream<<"OpenALSoundManager: Creating playing sound"<<std::endl;
399 PlayingSound *sound = new PlayingSound;
401 warn_if_error(alGetError(), "before createPlayingSound");
402 alGenSources(1, &sound->source_id);
403 alSourcei(sound->source_id, AL_BUFFER, buf->buffer_id);
404 alSourcei(sound->source_id, AL_SOURCE_RELATIVE, true);
405 alSource3f(sound->source_id, AL_POSITION, 0, 0, 0);
406 alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
407 alSourcei(sound->source_id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
408 volume = MYMAX(0.0, volume);
409 alSourcef(sound->source_id, AL_GAIN, volume);
410 alSourcef(sound->source_id, AL_PITCH, pitch);
411 alSourcePlay(sound->source_id);
412 warn_if_error(alGetError(), "createPlayingSound");
416 PlayingSound* createPlayingSoundAt(SoundBuffer *buf, bool loop,
417 float volume, v3f pos, float pitch)
419 infostream<<"OpenALSoundManager: Creating positional playing sound"
422 PlayingSound *sound = new PlayingSound;
424 warn_if_error(alGetError(), "before createPlayingSoundAt");
425 alGenSources(1, &sound->source_id);
426 alSourcei(sound->source_id, AL_BUFFER, buf->buffer_id);
427 alSourcei(sound->source_id, AL_SOURCE_RELATIVE, false);
428 alSource3f(sound->source_id, AL_POSITION, pos.X, pos.Y, pos.Z);
429 alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
430 alSourcef(sound->source_id, AL_REFERENCE_DISTANCE, 30.0);
431 alSourcei(sound->source_id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
432 volume = MYMAX(0.0, volume);
433 alSourcef(sound->source_id, AL_GAIN, volume);
434 alSourcef(sound->source_id, AL_PITCH, pitch);
435 alSourcePlay(sound->source_id);
436 warn_if_error(alGetError(), "createPlayingSoundAt");
440 int playSoundRaw(SoundBuffer *buf, bool loop, float volume, float pitch)
443 PlayingSound *sound = createPlayingSound(buf, loop, volume, pitch);
446 int id = m_next_id++;
447 m_sounds_playing[id] = sound;
451 int playSoundRawAt(SoundBuffer *buf, bool loop, float volume, const v3f &pos,
455 PlayingSound *sound = createPlayingSoundAt(buf, loop, volume, pos, pitch);
458 int id = m_next_id++;
459 m_sounds_playing[id] = sound;
463 void deleteSound(int id)
465 std::unordered_map<int, PlayingSound*>::iterator i = m_sounds_playing.find(id);
466 if(i == m_sounds_playing.end())
468 PlayingSound *sound = i->second;
470 alDeleteSources(1, &sound->source_id);
473 m_sounds_playing.erase(id);
476 /* If buffer does not exist, consult the fetcher */
477 SoundBuffer* getFetchBuffer(const std::string &name)
479 SoundBuffer *buf = getBuffer(name);
484 std::set<std::string> paths;
485 std::set<std::string> datas;
486 m_fetcher->fetchSounds(name, paths, datas);
487 for (const std::string &path : paths) {
488 loadSoundFile(name, path);
490 for (const std::string &data : datas) {
491 loadSoundData(name, data);
493 return getBuffer(name);
496 // Remove stopped sounds
499 verbosestream<<"OpenALSoundManager::maintain(): "
500 <<m_sounds_playing.size()<<" playing sounds, "
501 <<m_buffers.size()<<" sound names loaded"<<std::endl;
502 std::set<int> del_list;
503 for (auto &sp : m_sounds_playing) {
505 PlayingSound *sound = sp.second;
506 // If not playing, remove it
509 alGetSourcei(sound->source_id, AL_SOURCE_STATE, &state);
510 if(state != AL_PLAYING){
515 if(!del_list.empty())
516 verbosestream<<"OpenALSoundManager::maintain(): deleting "
517 <<del_list.size()<<" playing sounds"<<std::endl;
518 for (int i : del_list) {
525 bool loadSoundFile(const std::string &name,
526 const std::string &filepath)
528 SoundBuffer *buf = load_ogg_from_file(filepath);
530 addBuffer(name, buf);
534 bool loadSoundData(const std::string &name,
535 const std::string &filedata)
537 SoundBuffer *buf = load_ogg_from_buffer(filedata, name);
539 addBuffer(name, buf);
543 void updateListener(v3f pos, v3f vel, v3f at, v3f up)
545 m_listener_pos = pos;
546 alListener3f(AL_POSITION, pos.X, pos.Y, pos.Z);
547 alListener3f(AL_VELOCITY, vel.X, vel.Y, vel.Z);
551 alListenerfv(AL_ORIENTATION, f);
552 warn_if_error(alGetError(), "updateListener");
555 void setListenerGain(float gain)
557 alListenerf(AL_GAIN, gain);
560 int playSound(const std::string &name, bool loop, float volume, float fade, float pitch)
565 SoundBuffer *buf = getFetchBuffer(name);
567 infostream<<"OpenALSoundManager: \""<<name<<"\" not found."
573 handle = playSoundRaw(buf, loop, 0.0f, pitch);
574 fadeSound(handle, fade, volume);
576 handle = playSoundRaw(buf, loop, volume, pitch);
581 int playSoundAt(const std::string &name, bool loop, float volume, v3f pos, float pitch)
586 SoundBuffer *buf = getFetchBuffer(name);
588 infostream<<"OpenALSoundManager: \""<<name<<"\" not found."
592 return playSoundRawAt(buf, loop, volume, pos, pitch);
595 void stopSound(int sound)
601 void fadeSound(int soundid, float step, float gain)
603 m_sounds_fading[soundid] = FadeState(step, getSoundGain(soundid), gain);
606 void doFades(float dtime)
608 m_fade_delay += dtime;
610 if (m_fade_delay < 0.1f)
614 for (std::unordered_map<int, FadeState>::iterator i = m_sounds_fading.begin();
615 i != m_sounds_fading.end();) {
616 if (i->second.step < 0.f)
617 chkGain = -(i->second.current_gain);
619 chkGain = i->second.current_gain;
621 if (chkGain < i->second.target_gain) {
622 i->second.current_gain += (i->second.step * m_fade_delay);
623 i->second.current_gain = rangelim(i->second.current_gain, 0, 1);
625 updateSoundGain(i->first, i->second.current_gain);
628 if (i->second.target_gain <= 0.f)
631 m_sounds_fading.erase(i++);
637 bool soundExists(int sound)
640 return (m_sounds_playing.count(sound) != 0);
643 void updateSoundPosition(int id, v3f pos)
645 std::unordered_map<int, PlayingSound*>::iterator i = m_sounds_playing.find(id);
646 if (i == m_sounds_playing.end())
648 PlayingSound *sound = i->second;
650 alSourcei(sound->source_id, AL_SOURCE_RELATIVE, false);
651 alSource3f(sound->source_id, AL_POSITION, pos.X, pos.Y, pos.Z);
652 alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
653 alSourcef(sound->source_id, AL_REFERENCE_DISTANCE, 30.0);
656 bool updateSoundGain(int id, float gain)
658 std::unordered_map<int, PlayingSound*>::iterator i = m_sounds_playing.find(id);
659 if (i == m_sounds_playing.end())
662 PlayingSound *sound = i->second;
663 alSourcef(sound->source_id, AL_GAIN, gain);
667 float getSoundGain(int id)
669 std::unordered_map<int, PlayingSound*>::iterator i = m_sounds_playing.find(id);
670 if (i == m_sounds_playing.end())
673 PlayingSound *sound = i->second;
675 alGetSourcef(sound->source_id, AL_GAIN, &gain);
680 ISoundManager *createOpenALSoundManager(OnDemandSoundFetcher *fetcher)
682 OpenALSoundManager *m = new OpenALSoundManager(fetcher);
683 if(m->m_is_initialized)