Re-add jungles, apple trees
[oweals/minetest.git] / src / sound_openal.cpp
1 /*
2 Minetest
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>
8
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.
13
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.
18
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.
22 */
23
24 #include "sound_openal.h"
25
26 #if defined(_WIN32)
27         #include <al.h>
28         #include <alc.h>
29         //#include <alext.h>
30 #elif defined(__APPLE__)
31         #include <OpenAL/al.h>
32         #include <OpenAL/alc.h>
33         //#include <OpenAL/alext.h>
34 #else
35         #include <AL/al.h>
36         #include <AL/alc.h>
37         #include <AL/alext.h>
38 #endif
39 #include <vorbis/vorbisfile.h>
40 #include "log.h"
41 #include "filesys.h"
42 #include "util/numeric.h" // myrand()
43 #include "debug.h" // assert()
44 #include "porting.h"
45 #include <map>
46 #include <vector>
47 #include <fstream>
48
49 #define BUFFER_SIZE 30000
50
51 static const char *alcErrorString(ALCenum err)
52 {
53         switch (err) {
54         case ALC_NO_ERROR:
55                 return "no error";
56         case ALC_INVALID_DEVICE:
57                 return "invalid device";
58         case ALC_INVALID_CONTEXT:
59                 return "invalid context";
60         case ALC_INVALID_ENUM:
61                 return "invalid enum";
62         case ALC_INVALID_VALUE:
63                 return "invalid value";
64         case ALC_OUT_OF_MEMORY:
65                 return "out of memory";
66         default:
67                 return "<unknown OpenAL error>";
68         }
69 }
70
71 static const char *alErrorString(ALenum err)
72 {
73         switch (err) {
74         case AL_NO_ERROR:
75                 return "no error";
76         case AL_INVALID_NAME:
77                 return "invalid name";
78         case AL_INVALID_ENUM:
79                 return "invalid enum";
80         case AL_INVALID_VALUE:
81                 return "invalid value";
82         case AL_INVALID_OPERATION:
83                 return "invalid operation";
84         case AL_OUT_OF_MEMORY:
85                 return "out of memory";
86         default:
87                 return "<unknown OpenAL error>";
88         }
89 }
90
91 static ALenum warn_if_error(ALenum err, const char *desc)
92 {
93         if(err == AL_NO_ERROR)
94                 return err;
95         errorstream<<"WARNING: "<<desc<<": "<<alErrorString(err)<<std::endl;
96         return err;
97 }
98
99 void f3_set(ALfloat *f3, v3f v)
100 {
101         f3[0] = v.X;
102         f3[1] = v.Y;
103         f3[2] = v.Z;
104 }
105
106 struct SoundBuffer
107 {
108         ALenum format;
109         ALsizei freq;
110         ALuint buffer_id;
111         std::vector<char> buffer;
112 };
113
114 SoundBuffer* loadOggFile(const std::string &filepath)
115 {
116         int endian = 0; // 0 for Little-Endian, 1 for Big-Endian
117         int bitStream;
118         long bytes;
119         char array[BUFFER_SIZE]; // Local fixed size array
120         vorbis_info *pInfo;
121         OggVorbis_File oggFile;
122         
123         // Do a dumb-ass static string copy for old versions of ov_fopen
124         // because they expect a non-const char*
125         char nonconst[10000];
126         snprintf(nonconst, 10000, "%s", filepath.c_str());
127         // Try opening the given file
128         //if(ov_fopen(filepath.c_str(), &oggFile) != 0)
129         if(ov_fopen(nonconst, &oggFile) != 0)
130         {
131                 infostream<<"Audio: Error opening "<<filepath<<" for decoding"<<std::endl;
132                 return NULL;
133         }
134
135         SoundBuffer *snd = new SoundBuffer;
136
137         // Get some information about the OGG file
138         pInfo = ov_info(&oggFile, -1);
139
140         // Check the number of channels... always use 16-bit samples
141         if(pInfo->channels == 1)
142                 snd->format = AL_FORMAT_MONO16;
143         else
144                 snd->format = AL_FORMAT_STEREO16;
145
146         // The frequency of the sampling rate
147         snd->freq = pInfo->rate;
148
149         // Keep reading until all is read
150         do
151         {
152                 // Read up to a buffer's worth of decoded sound data
153                 bytes = ov_read(&oggFile, array, BUFFER_SIZE, endian, 2, 1, &bitStream);
154
155                 if(bytes < 0)
156                 {
157                         ov_clear(&oggFile);
158                         infostream<<"Audio: Error decoding "<<filepath<<std::endl;
159                         return NULL;
160                 }
161
162                 // Append to end of buffer
163                 snd->buffer.insert(snd->buffer.end(), array, array + bytes);
164         } while (bytes > 0);
165
166         alGenBuffers(1, &snd->buffer_id);
167         alBufferData(snd->buffer_id, snd->format,
168                         &(snd->buffer[0]), snd->buffer.size(),
169                         snd->freq);
170
171         ALenum error = alGetError();
172
173         if(error != AL_NO_ERROR){
174                 infostream<<"Audio: OpenAL error: "<<alErrorString(error)
175                                 <<"preparing sound buffer"<<std::endl;
176         }
177
178         infostream<<"Audio file "<<filepath<<" loaded"<<std::endl;
179
180         // Clean up!
181         ov_clear(&oggFile);
182
183         return snd;
184 }
185
186 struct PlayingSound
187 {
188         ALuint source_id;
189         bool loop;
190 };
191
192 class OpenALSoundManager: public ISoundManager
193 {
194 private:
195         OnDemandSoundFetcher *m_fetcher;
196         ALCdevice *m_device;
197         ALCcontext *m_context;
198         bool m_can_vorbis;
199         int m_next_id;
200         std::map<std::string, std::vector<SoundBuffer*> > m_buffers;
201         std::map<int, PlayingSound*> m_sounds_playing;
202         v3f m_listener_pos;
203 public:
204         bool m_is_initialized;
205         OpenALSoundManager(OnDemandSoundFetcher *fetcher):
206                 m_fetcher(fetcher),
207                 m_device(NULL),
208                 m_context(NULL),
209                 m_can_vorbis(false),
210                 m_next_id(1),
211                 m_is_initialized(false)
212         {
213                 ALCenum error = ALC_NO_ERROR;
214                 
215                 infostream<<"Audio: Initializing..."<<std::endl;
216
217                 m_device = alcOpenDevice(NULL);
218                 if(!m_device){
219                         infostream<<"Audio: No audio device available, audio system "
220                                 <<"not initialized"<<std::endl;
221                         return;
222                 }
223
224                 if(alcIsExtensionPresent(m_device, "EXT_vorbis")){
225                         infostream<<"Audio: Vorbis extension present"<<std::endl;
226                         m_can_vorbis = true;
227                 } else{
228                         infostream<<"Audio: Vorbis extension NOT present"<<std::endl;
229                         m_can_vorbis = false;
230                 }
231
232                 m_context = alcCreateContext(m_device, NULL);
233                 if(!m_context){
234                         error = alcGetError(m_device);
235                         infostream<<"Audio: Unable to initialize audio context, "
236                                         <<"aborting audio initialization ("<<alcErrorString(error)
237                                         <<")"<<std::endl;
238                         alcCloseDevice(m_device);
239                         m_device = NULL;
240                         return;
241                 }
242
243                 if(!alcMakeContextCurrent(m_context) ||
244                                 (error = alcGetError(m_device) != ALC_NO_ERROR))
245                 {
246                         infostream<<"Audio: Error setting audio context, aborting audio "
247                                         <<"initialization ("<<alcErrorString(error)<<")"<<std::endl;
248                         alcDestroyContext(m_context);
249                         m_context = NULL;
250                         alcCloseDevice(m_device);
251                         m_device = NULL;
252                         return;
253                 }
254
255                 alDistanceModel(AL_EXPONENT_DISTANCE);
256
257                 infostream<<"Audio: Initialized: OpenAL "<<alGetString(AL_VERSION)
258                                 <<", using "<<alcGetString(m_device, ALC_DEVICE_SPECIFIER)
259                                 <<std::endl;
260
261                 m_is_initialized = true;
262         }
263
264         ~OpenALSoundManager()
265         {
266                 infostream<<"Audio: Deinitializing..."<<std::endl;
267                 // KABOOM!
268                 // TODO: Clear SoundBuffers
269                 alcMakeContextCurrent(NULL);
270                 alcDestroyContext(m_context);
271                 m_context = NULL;
272                 alcCloseDevice(m_device);
273                 m_device = NULL;
274                 infostream<<"Audio: Deinitialized."<<std::endl;
275         }
276         
277         void addBuffer(const std::string &name, SoundBuffer *buf)
278         {
279                 std::map<std::string, std::vector<SoundBuffer*> >::iterator i =
280                                 m_buffers.find(name);
281                 if(i != m_buffers.end()){
282                         i->second.push_back(buf);
283                         return;
284                 }
285                 std::vector<SoundBuffer*> bufs;
286                 bufs.push_back(buf);
287                 m_buffers[name] = bufs;
288                 return;
289         }
290
291         SoundBuffer* getBuffer(const std::string &name)
292         {
293                 std::map<std::string, std::vector<SoundBuffer*> >::iterator i =
294                                 m_buffers.find(name);
295                 if(i == m_buffers.end())
296                         return NULL;
297                 std::vector<SoundBuffer*> &bufs = i->second;
298                 int j = myrand() % bufs.size();
299                 return bufs[j];
300         }
301
302         PlayingSound* createPlayingSound(SoundBuffer *buf, bool loop,
303                         float volume)
304         {
305                 infostream<<"OpenALSoundManager: Creating playing sound"<<std::endl;
306                 assert(buf);
307                 PlayingSound *sound = new PlayingSound;
308                 assert(sound);
309                 warn_if_error(alGetError(), "before createPlayingSound");
310                 alGenSources(1, &sound->source_id);
311                 alSourcei(sound->source_id, AL_BUFFER, buf->buffer_id);
312                 alSourcei(sound->source_id, AL_SOURCE_RELATIVE, true);
313                 alSource3f(sound->source_id, AL_POSITION, 0, 0, 0);
314                 alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
315                 alSourcei(sound->source_id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
316                 volume = MYMAX(0.0, volume);
317                 alSourcef(sound->source_id, AL_GAIN, volume);
318                 alSourcePlay(sound->source_id);
319                 warn_if_error(alGetError(), "createPlayingSound");
320                 return sound;
321         }
322
323         PlayingSound* createPlayingSoundAt(SoundBuffer *buf, bool loop,
324                         float volume, v3f pos)
325         {
326                 infostream<<"OpenALSoundManager: Creating positional playing sound"
327                                 <<std::endl;
328                 assert(buf);
329                 PlayingSound *sound = new PlayingSound;
330                 assert(sound);
331                 warn_if_error(alGetError(), "before createPlayingSoundAt");
332                 alGenSources(1, &sound->source_id);
333                 alSourcei(sound->source_id, AL_BUFFER, buf->buffer_id);
334                 alSourcei(sound->source_id, AL_SOURCE_RELATIVE, false);
335                 alSource3f(sound->source_id, AL_POSITION, pos.X, pos.Y, pos.Z);
336                 alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
337                 //alSourcef(sound->source_id, AL_ROLLOFF_FACTOR, 0.7);
338                 alSourcef(sound->source_id, AL_REFERENCE_DISTANCE, 30.0);
339                 alSourcei(sound->source_id, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
340                 volume = MYMAX(0.0, volume);
341                 alSourcef(sound->source_id, AL_GAIN, volume);
342                 alSourcePlay(sound->source_id);
343                 warn_if_error(alGetError(), "createPlayingSoundAt");
344                 return sound;
345         }
346
347         int playSoundRaw(SoundBuffer *buf, bool loop, float volume)
348         {
349                 assert(buf);
350                 PlayingSound *sound = createPlayingSound(buf, loop, volume);
351                 if(!sound)
352                         return -1;
353                 int id = m_next_id++;
354                 m_sounds_playing[id] = sound;
355                 return id;
356         }
357
358         int playSoundRawAt(SoundBuffer *buf, bool loop, float volume, v3f pos)
359         {
360                 assert(buf);
361                 PlayingSound *sound = createPlayingSoundAt(buf, loop, volume, pos);
362                 if(!sound)
363                         return -1;
364                 int id = m_next_id++;
365                 m_sounds_playing[id] = sound;
366                 return id;
367         }
368         
369         void deleteSound(int id)
370         {
371                 std::map<int, PlayingSound*>::iterator i =
372                                 m_sounds_playing.find(id);
373                 if(i == m_sounds_playing.end())
374                         return;
375                 PlayingSound *sound = i->second;
376                 
377                 alDeleteSources(1, &sound->source_id);
378
379                 delete sound;
380                 m_sounds_playing.erase(id);
381         }
382
383         /* If buffer does not exist, consult the fetcher */
384         SoundBuffer* getFetchBuffer(const std::string name)
385         {
386                 SoundBuffer *buf = getBuffer(name);
387                 if(buf)
388                         return buf;
389                 if(!m_fetcher)
390                         return NULL;
391                 std::set<std::string> paths;
392                 std::set<std::string> datas;
393                 m_fetcher->fetchSounds(name, paths, datas);
394                 for(std::set<std::string>::iterator i = paths.begin();
395                                 i != paths.end(); i++){
396                         loadSoundFile(name, *i);
397                 }
398                 for(std::set<std::string>::iterator i = datas.begin();
399                                 i != datas.end(); i++){
400                         loadSoundData(name, *i);
401                 }
402                 return getBuffer(name);
403         }
404         
405         // Remove stopped sounds
406         void maintain()
407         {
408                 verbosestream<<"OpenALSoundManager::maintain(): "
409                                 <<m_sounds_playing.size()<<" playing sounds, "
410                                 <<m_buffers.size()<<" sound names loaded"<<std::endl;
411                 std::set<int> del_list;
412                 for(std::map<int, PlayingSound*>::iterator
413                                 i = m_sounds_playing.begin();
414                                 i != m_sounds_playing.end(); i++)
415                 {
416                         int id = i->first;
417                         PlayingSound *sound = i->second;
418                         // If not playing, remove it
419                         {
420                                 ALint state;
421                                 alGetSourcei(sound->source_id, AL_SOURCE_STATE, &state);
422                                 if(state != AL_PLAYING){
423                                         del_list.insert(id);
424                                 }
425                         }
426                 }
427                 if(del_list.size() != 0)
428                         verbosestream<<"OpenALSoundManager::maintain(): deleting "
429                                         <<del_list.size()<<" playing sounds"<<std::endl;
430                 for(std::set<int>::iterator i = del_list.begin();
431                                 i != del_list.end(); i++)
432                 {
433                         deleteSound(*i);
434                 }
435         }
436
437         /* Interface */
438
439         bool loadSoundFile(const std::string &name,
440                         const std::string &filepath)
441         {
442                 SoundBuffer *buf = loadOggFile(filepath);
443                 if(buf)
444                         addBuffer(name, buf);
445                 return false;
446         }
447         bool loadSoundData(const std::string &name,
448                         const std::string &filedata)
449         {
450                 // The vorbis API sucks; just write it to a file and use vorbisfile
451                 // TODO: Actually load it directly from memory
452                 std::string basepath = porting::path_user + DIR_DELIM + "cache" +
453                                 DIR_DELIM + "tmp";
454                 std::string path = basepath + DIR_DELIM + "tmp.ogg";
455                 verbosestream<<"OpenALSoundManager::loadSoundData(): Writing "
456                                 <<"temporary file to ["<<path<<"]"<<std::endl;
457                 fs::CreateAllDirs(basepath);
458                 std::ofstream of(path.c_str(), std::ios::binary);
459                 of.write(filedata.c_str(), filedata.size());
460                 of.close();
461                 return loadSoundFile(name, path);
462         }
463
464         void updateListener(v3f pos, v3f vel, v3f at, v3f up)
465         {
466                 m_listener_pos = pos;
467                 alListener3f(AL_POSITION, pos.X, pos.Y, pos.Z);
468                 alListener3f(AL_VELOCITY, vel.X, vel.Y, vel.Z);
469                 ALfloat f[6];
470                 f3_set(f, at);
471                 f3_set(f+3, -up);
472                 alListenerfv(AL_ORIENTATION, f);
473                 warn_if_error(alGetError(), "updateListener");
474         }
475         
476         void setListenerGain(float gain)
477         {
478                 alListenerf(AL_GAIN, gain);
479         }
480
481         int playSound(const std::string &name, bool loop, float volume)
482         {
483                 maintain();
484                 if(name == "")
485                         return 0;
486                 SoundBuffer *buf = getFetchBuffer(name);
487                 if(!buf){
488                         infostream<<"OpenALSoundManager: \""<<name<<"\" not found."
489                                         <<std::endl;
490                         return -1;
491                 }
492                 return playSoundRaw(buf, loop, volume);
493         }
494         int playSoundAt(const std::string &name, bool loop, float volume, v3f pos)
495         {
496                 maintain();
497                 if(name == "")
498                         return 0;
499                 SoundBuffer *buf = getFetchBuffer(name);
500                 if(!buf){
501                         infostream<<"OpenALSoundManager: \""<<name<<"\" not found."
502                                         <<std::endl;
503                         return -1;
504                 }
505                 return playSoundRawAt(buf, loop, volume, pos);
506         }
507         void stopSound(int sound)
508         {
509                 maintain();
510                 deleteSound(sound);
511         }
512         bool soundExists(int sound)
513         {
514                 maintain();
515                 return (m_sounds_playing.count(sound) != 0);
516         }
517         void updateSoundPosition(int id, v3f pos)
518         {
519                 std::map<int, PlayingSound*>::iterator i =
520                                 m_sounds_playing.find(id);
521                 if(i == m_sounds_playing.end())
522                         return;
523                 PlayingSound *sound = i->second;
524
525                 alSourcei(sound->source_id, AL_SOURCE_RELATIVE, false);
526                 alSource3f(sound->source_id, AL_POSITION, pos.X, pos.Y, pos.Z);
527                 alSource3f(sound->source_id, AL_VELOCITY, 0, 0, 0);
528                 alSourcef(sound->source_id, AL_REFERENCE_DISTANCE, 30.0);
529         }
530 };
531
532 ISoundManager *createOpenALSoundManager(OnDemandSoundFetcher *fetcher)
533 {
534         OpenALSoundManager *m = new OpenALSoundManager(fetcher);
535         if(m->m_is_initialized)
536                 return m;
537         delete m;
538         return NULL;
539 };
540