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 "util/cpp11_container.h"
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 UNORDERED_MAP<std::string, std::vector<SoundBuffer*> > m_buffers;
275 UNORDERED_MAP<int, PlayingSound*> m_sounds_playing;
278 bool m_is_initialized;
279 OpenALSoundManager(OnDemandSoundFetcher *fetcher):
284 m_is_initialized(false)
286 ALCenum error = ALC_NO_ERROR;
288 infostream<<"Audio: Initializing..."<<std::endl;
290 m_device = alcOpenDevice(NULL);
292 infostream<<"Audio: No audio device available, audio system "
293 <<"not initialized"<<std::endl;
297 m_context = alcCreateContext(m_device, NULL);
299 error = alcGetError(m_device);
300 infostream<<"Audio: Unable to initialize audio context, "
301 <<"aborting audio initialization ("<<alcErrorString(error)
303 alcCloseDevice(m_device);
308 if(!alcMakeContextCurrent(m_context) ||
309 (error = alcGetError(m_device) != ALC_NO_ERROR))
311 infostream<<"Audio: Error setting audio context, aborting audio "
312 <<"initialization ("<<alcErrorString(error)<<")"<<std::endl;
313 alcDestroyContext(m_context);
315 alcCloseDevice(m_device);
320 alDistanceModel(AL_EXPONENT_DISTANCE);
322 infostream<<"Audio: Initialized: OpenAL "<<alGetString(AL_VERSION)
323 <<", using "<<alcGetString(m_device, ALC_DEVICE_SPECIFIER)
326 m_is_initialized = true;
329 ~OpenALSoundManager()
331 infostream<<"Audio: Deinitializing..."<<std::endl;
333 // TODO: Clear SoundBuffers
334 alcMakeContextCurrent(NULL);
335 alcDestroyContext(m_context);
337 alcCloseDevice(m_device);
340 for (UNORDERED_MAP<std::string, std::vector<SoundBuffer*> >::iterator i = m_buffers.begin();
341 i != m_buffers.end(); ++i) {
342 for (std::vector<SoundBuffer*>::iterator iter = (*i).second.begin();
343 iter != (*i).second.end(); ++iter) {
349 infostream<<"Audio: Deinitialized."<<std::endl;
352 void addBuffer(const std::string &name, SoundBuffer *buf)
354 UNORDERED_MAP<std::string, std::vector<SoundBuffer*> >::iterator i =
355 m_buffers.find(name);
356 if(i != m_buffers.end()){
357 i->second.push_back(buf);
360 std::vector<SoundBuffer*> bufs;
362 m_buffers[name] = bufs;
366 SoundBuffer* getBuffer(const std::string &name)
368 UNORDERED_MAP<std::string, std::vector<SoundBuffer*> >::iterator i =
369 m_buffers.find(name);
370 if(i == m_buffers.end())
372 std::vector<SoundBuffer*> &bufs = i->second;
373 int j = myrand() % bufs.size();
377 PlayingSound* createPlayingSound(SoundBuffer *buf, bool loop,
380 infostream<<"OpenALSoundManager: Creating playing sound"<<std::endl;
382 PlayingSound *sound = new PlayingSound;
384 warn_if_error(alGetError(), "before createPlayingSound");
385 alGenSources(1, &sound->source_id);
386 alSourcei(sound->source_id, AL_BUFFER, buf->buffer_id);
387 alSourcei(sound->source_id, AL_SOURCE_RELATIVE, true);
388 alSource3f(sound->source_id, AL_POSITION, 0, 0, 0);
389 alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
390 alSourcei(sound->source_id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
391 volume = MYMAX(0.0, volume);
392 alSourcef(sound->source_id, AL_GAIN, volume);
393 alSourcePlay(sound->source_id);
394 warn_if_error(alGetError(), "createPlayingSound");
398 PlayingSound* createPlayingSoundAt(SoundBuffer *buf, bool loop,
399 float volume, v3f pos)
401 infostream<<"OpenALSoundManager: Creating positional playing sound"
404 PlayingSound *sound = new PlayingSound;
406 warn_if_error(alGetError(), "before createPlayingSoundAt");
407 alGenSources(1, &sound->source_id);
408 alSourcei(sound->source_id, AL_BUFFER, buf->buffer_id);
409 alSourcei(sound->source_id, AL_SOURCE_RELATIVE, false);
410 alSource3f(sound->source_id, AL_POSITION, pos.X, pos.Y, pos.Z);
411 alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
412 //alSourcef(sound->source_id, AL_ROLLOFF_FACTOR, 0.7);
413 alSourcef(sound->source_id, AL_REFERENCE_DISTANCE, 30.0);
414 alSourcei(sound->source_id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
415 volume = MYMAX(0.0, volume);
416 alSourcef(sound->source_id, AL_GAIN, volume);
417 alSourcePlay(sound->source_id);
418 warn_if_error(alGetError(), "createPlayingSoundAt");
422 int playSoundRaw(SoundBuffer *buf, bool loop, float volume)
425 PlayingSound *sound = createPlayingSound(buf, loop, volume);
428 int id = m_next_id++;
429 m_sounds_playing[id] = sound;
433 int playSoundRawAt(SoundBuffer *buf, bool loop, float volume, v3f pos)
436 PlayingSound *sound = createPlayingSoundAt(buf, loop, volume, pos);
439 int id = m_next_id++;
440 m_sounds_playing[id] = sound;
444 void deleteSound(int id)
446 UNORDERED_MAP<int, PlayingSound*>::iterator i = m_sounds_playing.find(id);
447 if(i == m_sounds_playing.end())
449 PlayingSound *sound = i->second;
451 alDeleteSources(1, &sound->source_id);
454 m_sounds_playing.erase(id);
457 /* If buffer does not exist, consult the fetcher */
458 SoundBuffer* getFetchBuffer(const std::string &name)
460 SoundBuffer *buf = getBuffer(name);
465 std::set<std::string> paths;
466 std::set<std::string> datas;
467 m_fetcher->fetchSounds(name, paths, datas);
468 for(std::set<std::string>::iterator i = paths.begin();
469 i != paths.end(); ++i){
470 loadSoundFile(name, *i);
472 for(std::set<std::string>::iterator i = datas.begin();
473 i != datas.end(); ++i){
474 loadSoundData(name, *i);
476 return getBuffer(name);
479 // Remove stopped sounds
482 verbosestream<<"OpenALSoundManager::maintain(): "
483 <<m_sounds_playing.size()<<" playing sounds, "
484 <<m_buffers.size()<<" sound names loaded"<<std::endl;
485 std::set<int> del_list;
486 for(UNORDERED_MAP<int, PlayingSound*>::iterator i = m_sounds_playing.begin();
487 i != m_sounds_playing.end(); ++i) {
489 PlayingSound *sound = i->second;
490 // If not playing, remove it
493 alGetSourcei(sound->source_id, AL_SOURCE_STATE, &state);
494 if(state != AL_PLAYING){
499 if(!del_list.empty())
500 verbosestream<<"OpenALSoundManager::maintain(): deleting "
501 <<del_list.size()<<" playing sounds"<<std::endl;
502 for(std::set<int>::iterator i = del_list.begin();
503 i != del_list.end(); ++i)
511 bool loadSoundFile(const std::string &name,
512 const std::string &filepath)
514 SoundBuffer *buf = load_ogg_from_file(filepath);
516 addBuffer(name, buf);
519 bool loadSoundData(const std::string &name,
520 const std::string &filedata)
522 SoundBuffer *buf = load_ogg_from_buffer(filedata, name);
524 addBuffer(name, buf);
528 void updateListener(v3f pos, v3f vel, v3f at, v3f up)
530 m_listener_pos = pos;
531 alListener3f(AL_POSITION, pos.X, pos.Y, pos.Z);
532 alListener3f(AL_VELOCITY, vel.X, vel.Y, vel.Z);
536 alListenerfv(AL_ORIENTATION, f);
537 warn_if_error(alGetError(), "updateListener");
540 void setListenerGain(float gain)
542 alListenerf(AL_GAIN, gain);
545 int playSound(const std::string &name, bool loop, float volume)
550 SoundBuffer *buf = getFetchBuffer(name);
552 infostream<<"OpenALSoundManager: \""<<name<<"\" not found."
556 return playSoundRaw(buf, loop, volume);
558 int playSoundAt(const std::string &name, bool loop, float volume, v3f pos)
563 SoundBuffer *buf = getFetchBuffer(name);
565 infostream<<"OpenALSoundManager: \""<<name<<"\" not found."
569 return playSoundRawAt(buf, loop, volume, pos);
571 void stopSound(int sound)
576 bool soundExists(int sound)
579 return (m_sounds_playing.count(sound) != 0);
581 void updateSoundPosition(int id, v3f pos)
583 UNORDERED_MAP<int, PlayingSound*>::iterator i = m_sounds_playing.find(id);
584 if (i == m_sounds_playing.end())
586 PlayingSound *sound = i->second;
588 alSourcei(sound->source_id, AL_SOURCE_RELATIVE, false);
589 alSource3f(sound->source_id, AL_POSITION, pos.X, pos.Y, pos.Z);
590 alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
591 alSourcef(sound->source_id, AL_REFERENCE_DISTANCE, 30.0);
595 ISoundManager *createOpenALSoundManager(OnDemandSoundFetcher *fetcher)
597 OpenALSoundManager *m = new OpenALSoundManager(fetcher);
598 if(m->m_is_initialized)