]> git.jsancho.org Git - lugaru.git/blob - Source/Audio/openal_wrapper.cpp
Convert C-header includes to C++ variants in C++ files
[lugaru.git] / Source / Audio / openal_wrapper.cpp
1 /*
2 Copyright (C) 2003, 2010 - Wolfire Games
3 Copyright (C) 2010-2016 - Lugaru contributors (see AUTHORS file)
4
5 This file is part of Lugaru.
6
7 Lugaru is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 Lugaru is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Lugaru.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "Audio/openal_wrapper.hpp"
22
23 #include "Audio/Sounds.hpp"
24 #include "Game.hpp"
25 #include "Math/Quaternions.hpp"
26
27 #include <cstdio>
28 #include <cstdlib>
29 #include <cstring>
30
31 extern float slomofreq;
32
33 // NOTE:
34 // FMOD uses a Left Handed Coordinate system, OpenAL uses a Right Handed
35 //  one...so we just need to flip the sign on the Z axis when appropriate.
36
37 typedef struct {
38     ALuint sid;
39     OPENAL_SAMPLE *sample;
40     bool startpaused;
41     float position[3];
42 } OPENAL_Channels;
43
44 typedef struct OPENAL_SAMPLE {
45     char *name;
46     ALuint bid;  // buffer id.
47     int mode;
48     int is2d;
49 } OPENAL_SAMPLE;
50
51 static size_t num_channels = 0;
52 static OPENAL_Channels *impl_channels = NULL;
53 static bool initialized = false;
54 static float listener_position[3];
55
56 static void set_channel_position(const int channel, const float x,
57                                  const float y, const float z)
58 {
59     OPENAL_Channels *chan = &impl_channels[channel];
60
61     chan->position[0] = x;
62     chan->position[1] = y;
63     chan->position[2] = z;
64
65     OPENAL_SAMPLE *sptr = chan->sample;
66     if (sptr == NULL)
67         return;
68
69     const ALuint sid = chan->sid;
70     const bool no_attenuate = sptr->is2d;
71
72     if (no_attenuate) {
73         alSourcei(sid, AL_SOURCE_RELATIVE, AL_TRUE);
74         alSource3f(sid, AL_POSITION, 0.0f, 0.0f, 0.0f);
75     } else {
76         alSourcei(sid, AL_SOURCE_RELATIVE, AL_FALSE);
77         alSource3f(sid, AL_POSITION, x, y, z);
78     }
79 }
80
81
82 AL_API void OPENAL_3D_Listener_SetAttributes(const float *pos, const float *vel, float fx, float fy, float fz, float tx, float ty, float tz)
83 {
84     if (!initialized)
85         return;
86     if (pos != NULL) {
87         alListener3f(AL_POSITION, pos[0], pos[1], -pos[2]);
88         listener_position[0] = pos[0];
89         listener_position[1] = pos[1];
90         listener_position[2] = -pos[2];
91     }
92
93     ALfloat vec[6] = { fx, fy, -fz, tz, ty, -tz };
94     alListenerfv(AL_ORIENTATION, vec);
95
96     // we ignore velocity, since doppler's broken in the Linux AL at the moment...
97
98     // adjust existing positions...
99     for (int i = 0; i < num_channels; i++) {
100         const float *p = impl_channels[i].position;
101         set_channel_position(i, p[0], p[1], p[2]);
102     }
103 }
104
105 AL_API signed char OPENAL_3D_SetAttributes(int channel, const float *pos, const float *vel)
106 {
107     if (!initialized)
108         return false;
109     if ((channel < 0) || (channel >= num_channels))
110         return false;
111
112     if (pos != NULL)
113         set_channel_position(channel, pos[0], pos[1], -pos[2]);
114
115     // we ignore velocity, since doppler's broken in the Linux AL at the moment...
116
117     return true;
118 }
119
120 AL_API signed char OPENAL_3D_SetAttributes_(int channel, const XYZ &pos, const float *vel)
121 {
122     if (!initialized)
123         return false;
124     if ((channel < 0) || (channel >= num_channels))
125         return false;
126
127     set_channel_position(channel, pos.x, pos.y, -pos.z);
128
129     return true;
130 }
131
132 AL_API signed char OPENAL_Init(int mixrate, int maxsoftwarechannels, unsigned int flags)
133 {
134     if (initialized)
135         return false;
136     if (maxsoftwarechannels == 0)
137         return false;
138
139     if (flags != 0)  // unsupported.
140         return false;
141
142     ALCdevice *dev = alcOpenDevice(NULL);
143     if (!dev)
144         return false;
145
146     ALint caps[] = { ALC_FREQUENCY, mixrate, 0 };
147     ALCcontext *ctx = alcCreateContext(dev, caps);
148     if (!ctx) {
149         alcCloseDevice(dev);
150         return false;
151     }
152
153     alcMakeContextCurrent(ctx);
154     alcProcessContext(ctx);
155
156     if (commandLineOptions[OPENALINFO]) {
157         printf("AL_VENDOR: %s\n", (char *) alGetString(AL_VENDOR));
158         printf("AL_RENDERER: %s\n", (char *) alGetString(AL_RENDERER));
159         printf("AL_VERSION: %s\n", (char *) alGetString(AL_VERSION));
160         printf("AL_EXTENSIONS: %s\n", (char *) alGetString(AL_EXTENSIONS));
161     }
162
163     num_channels = maxsoftwarechannels;
164     impl_channels = new OPENAL_Channels[maxsoftwarechannels];
165     memset(impl_channels, '\0', sizeof (OPENAL_Channels) * num_channels);
166     for (int i = 0; i < num_channels; i++)
167         alGenSources(1, &impl_channels[i].sid);  // !!! FIXME: verify this didn't fail!
168
169     initialized = true;
170     return true;
171 }
172
173 AL_API void OPENAL_Close()
174 {
175     if (!initialized)
176         return;
177
178     ALCcontext *ctx = alcGetCurrentContext();
179     if (ctx) {
180         for (int i = 0; i < num_channels; i++) {
181             alSourceStop(impl_channels[i].sid);
182             alSourcei(impl_channels[i].sid, AL_BUFFER, 0);
183             alDeleteSources(1, &impl_channels[i].sid);
184         }
185         ALCdevice *dev = alcGetContextsDevice(ctx);
186         alcMakeContextCurrent(NULL);
187         alcSuspendContext(ctx);
188         alcDestroyContext(ctx);
189         alcCloseDevice(dev);
190     }
191
192     num_channels = 0;
193     delete[] impl_channels;
194     impl_channels = NULL;
195
196     initialized = false;
197 }
198
199 static OPENAL_SAMPLE *OPENAL_GetCurrentSample(int channel)
200 {
201     if (!initialized)
202         return NULL;
203     if ((channel < 0) || (channel >= num_channels))
204         return NULL;
205     return impl_channels[channel].sample;
206 }
207
208 static signed char OPENAL_GetPaused(int channel)
209 {
210     if (!initialized)
211         return false;
212     if ((channel < 0) || (channel >= num_channels))
213         return false;
214     if (impl_channels[channel].startpaused)
215         return(true);
216
217     ALint state = 0;
218     alGetSourceiv(impl_channels[channel].sid, AL_SOURCE_STATE, &state);
219     return((state == AL_PAUSED) ? true : false);
220 }
221
222 static unsigned int OPENAL_GetLoopMode(int channel)
223 {
224     if (!initialized)
225         return 0;
226     if ((channel < 0) || (channel >= num_channels))
227         return 0;
228     ALint loop = 0;
229     alGetSourceiv(impl_channels[channel].sid, AL_LOOPING, &loop);
230     if (loop)
231         return(OPENAL_LOOP_NORMAL);
232     return OPENAL_LOOP_OFF;
233 }
234
235 static signed char OPENAL_IsPlaying(int channel)
236 {
237     if (!initialized)
238         return false;
239     if ((channel < 0) || (channel >= num_channels))
240         return false;
241     ALint state = 0;
242     alGetSourceiv(impl_channels[channel].sid, AL_SOURCE_STATE, &state);
243     return((state == AL_PLAYING) ? true : false);
244 }
245
246 static int OPENAL_PlaySoundEx(int channel, OPENAL_SAMPLE *sptr, OPENAL_DSPUNIT *dsp, signed char startpaused)
247 {
248     if (!initialized)
249         return -1;
250     if (sptr == NULL)
251         return -1;
252     if (dsp != NULL)
253         return -1;
254     if (channel == OPENAL_FREE) {
255         for (int i = 0; i < num_channels; i++) {
256             ALint state = 0;
257             alGetSourceiv(impl_channels[i].sid, AL_SOURCE_STATE, &state);
258             if ((state != AL_PLAYING) && (state != AL_PAUSED)) {
259                 channel = i;
260                 break;
261             }
262         }
263     }
264
265     if ((channel < 0) || (channel >= num_channels))
266         return -1;
267     alSourceStop(impl_channels[channel].sid);
268     impl_channels[channel].sample = sptr;
269     alSourcei(impl_channels[channel].sid, AL_BUFFER, sptr->bid);
270     alSourcei(impl_channels[channel].sid, AL_LOOPING, (sptr->mode == OPENAL_LOOP_OFF) ? AL_FALSE : AL_TRUE);
271     set_channel_position(channel, 0.0f, 0.0f, 0.0f);
272
273     impl_channels[channel].startpaused = ((startpaused) ? true : false);
274     if (!startpaused)
275         alSourcePlay(impl_channels[channel].sid);
276     return channel;
277 }
278
279
280 static void *decode_to_pcm(const char *_fname, ALenum &format, ALsizei &size, ALuint &freq)
281 {
282 #ifdef __POWERPC__
283     const int bigendian = 1;
284 #else
285     const int bigendian = 0;
286 #endif
287
288     // !!! FIXME: if it's not Ogg, we don't have a decoder. I'm lazy.  :/
289     char *fname = (char *) alloca(strlen(_fname) + 16);
290     strcpy(fname, _fname);
291     char *ptr = strchr(fname, '.');
292     if (ptr)
293         *ptr = '\0';
294     strcat(fname, ".ogg");
295
296     // just in case...
297     FILE *io = fopen(fname, "rb");
298     if (io == NULL)
299         return NULL;
300
301     ALubyte *retval = NULL;
302
303 #if 0  // untested, so disable this!
304     // Can we just feed it to the AL compressed?
305     if (alIsExtensionPresent((const ALubyte *) "AL_EXT_vorbis")) {
306         format = alGetEnumValue((const ALubyte *) "AL_FORMAT_VORBIS_EXT");
307         freq = 44100;
308         fseek(io, 0, SEEK_END);
309         size = ftell(io);
310         fseek(io, 0, SEEK_SET);
311         retval = (ALubyte *) malloc(size);
312         size_t rc = fread(retval, size, 1, io);
313         fclose(io);
314         if (rc != 1) {
315             free(retval);
316             return NULL;
317         }
318         return retval;
319     }
320 #endif
321
322     // Uncompress and feed to the AL.
323     OggVorbis_File vf;
324     memset(&vf, '\0', sizeof (vf));
325     if (ov_open(io, &vf, NULL, 0) == 0) {
326         int bitstream = 0;
327         vorbis_info *info = ov_info(&vf, -1);
328         size = 0;
329         format = (info->channels == 1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16;
330         freq = info->rate;
331
332         if ((info->channels != 1) && (info->channels != 2)) {
333             ov_clear(&vf);
334             return NULL;
335         }
336
337         char buf[1024 * 16];
338         long rc = 0;
339         size_t allocated = 64 * 1024;
340         retval = (ALubyte *) malloc(allocated);
341         while ( (rc = ov_read(&vf, buf, sizeof (buf), bigendian, 2, 1, &bitstream)) != 0 ) {
342             if (rc > 0) {
343                 size += rc;
344                 if (size >= allocated) {
345                     allocated *= 2;
346                     ALubyte *tmp = (ALubyte *) realloc(retval, allocated);
347                     if (tmp == NULL) {
348                         free(retval);
349                         retval = NULL;
350                         break;
351                     }
352                     retval = tmp;
353                 }
354                 memcpy(retval + (size - rc), buf, rc);
355             }
356         }
357         ov_clear(&vf);
358         return retval;
359     }
360
361     fclose(io);
362     return NULL;
363 }
364
365
366 AL_API OPENAL_SAMPLE *OPENAL_Sample_Load(int index, const char *name_or_data, unsigned int mode, int offset, int length)
367 {
368     if (!initialized)
369         return NULL;
370     if (index != OPENAL_FREE)
371         return NULL;  // this is all the game does...
372     if (offset != 0)
373         return NULL;  // this is all the game does...
374     if (length != 0)
375         return NULL;  // this is all the game does...
376     if ((mode != OPENAL_HW3D) && (mode != OPENAL_2D))
377         return NULL;  // this is all the game does...
378
379     OPENAL_SAMPLE *retval = NULL;
380     ALenum format = AL_NONE;
381     ALsizei size = 0;
382     ALuint frequency = 0;
383     void *data = decode_to_pcm(name_or_data, format, size, frequency);
384     if (data == NULL)
385         return NULL;
386
387     ALuint bid = 0;
388     alGetError();
389     alGenBuffers(1, &bid);
390     if (alGetError() == AL_NO_ERROR) {
391         alBufferData(bid, format, data, size, frequency);
392         retval = new OPENAL_SAMPLE;
393         retval->bid = bid;
394         retval->mode = OPENAL_LOOP_OFF;
395         retval->is2d = (mode == OPENAL_2D);
396         retval->name = new char[strlen(name_or_data) + 1];
397         if (retval->name)
398             strcpy(retval->name, name_or_data);
399     }
400
401     free(data);
402     return(retval);
403 }
404
405 AL_API void OPENAL_Sample_Free(OPENAL_SAMPLE *sptr)
406 {
407     if (!initialized)
408         return;
409     if (sptr) {
410         for (int i = 0; i < num_channels; i++) {
411             if (impl_channels[i].sample == sptr) {
412                 alSourceStop(impl_channels[i].sid);
413                 alSourcei(impl_channels[i].sid, AL_BUFFER, 0);
414                 impl_channels[i].sample = NULL;
415             }
416         }
417         alDeleteBuffers(1, &sptr->bid);
418         delete[] sptr->name;
419         delete sptr;
420     }
421 }
422
423 static signed char OPENAL_Sample_SetMode(OPENAL_SAMPLE *sptr, unsigned int mode)
424 {
425     if (!initialized)
426         return false;
427     if ((mode != OPENAL_LOOP_NORMAL) && (mode != OPENAL_LOOP_OFF))
428         return false;
429     if (!sptr)
430         return false;
431     sptr->mode = mode;
432     return true;
433 }
434
435 AL_API signed char OPENAL_SetFrequency(int channel, bool slomo)
436 {
437     if (!initialized)
438         return false;
439     if (channel == OPENAL_ALL) {
440         for (int i = 0; i < num_channels; i++)
441             OPENAL_SetFrequency(i, slomo);
442         return true;
443     }
444
445     if ((channel < 0) || (channel >= num_channels))
446         return false;
447     if (slomo)
448         alSourcef(impl_channels[channel].sid, AL_PITCH, ((ALfloat) slomofreq) / 44100.0f);
449     else
450         alSourcef(impl_channels[channel].sid, AL_PITCH, 1.0f);
451     return true;
452 }
453
454 AL_API signed char OPENAL_SetVolume(int channel, int vol)
455 {
456     if (!initialized)
457         return false;
458
459     if (channel == OPENAL_ALL) {
460         for (int i = 0; i < num_channels; i++)
461             OPENAL_SetVolume(i, vol);
462         return true;
463     }
464
465     if ((channel < 0) || (channel >= num_channels))
466         return false;
467
468     if (vol < 0)
469         vol = 0;
470     else if (vol > 255)
471         vol = 255;
472     ALfloat gain = ((ALfloat) vol) / 255.0f;
473     alSourcef(impl_channels[channel].sid, AL_GAIN, gain);
474     return true;
475 }
476
477 AL_API signed char OPENAL_SetPaused(int channel, signed char paused)
478 {
479     if (!initialized)
480         return false;
481
482     if (channel == OPENAL_ALL) {
483         for (int i = 0; i < num_channels; i++)
484             OPENAL_SetPaused(i, paused);
485         return true;
486     }
487
488     if ((channel < 0) || (channel >= num_channels))
489         return false;
490
491     ALint state = 0;
492     if (impl_channels[channel].startpaused)
493         state = AL_PAUSED;
494     else
495         alGetSourceiv(impl_channels[channel].sid, AL_SOURCE_STATE, &state);
496
497     if ((paused) && (state == AL_PLAYING))
498         alSourcePause(impl_channels[channel].sid);
499     else if ((!paused) && (state == AL_PAUSED)) {
500         alSourcePlay(impl_channels[channel].sid);
501         impl_channels[channel].startpaused = false;
502     }
503     return true;
504 }
505
506 AL_API void OPENAL_SetSFXMasterVolume(int volume)
507 {
508     if (!initialized)
509         return;
510     ALfloat gain = ((ALfloat) volume) / 255.0f;
511     alListenerf(AL_GAIN, gain);
512 }
513
514 AL_API signed char OPENAL_StopSound(int channel)
515 {
516     if (!initialized)
517         return false;
518
519     if (channel == OPENAL_ALL) {
520         for (int i = 0; i < num_channels; i++)
521             OPENAL_StopSound(i);
522         return true;
523     }
524
525     if ((channel < 0) || (channel >= num_channels))
526         return false;
527     alSourceStop(impl_channels[channel].sid);
528     impl_channels[channel].startpaused = false;
529     return true;
530 }
531
532 static OPENAL_SAMPLE *OPENAL_Stream_GetSample(OPENAL_STREAM *stream)
533 {
534     if (!initialized)
535         return NULL;
536     return (OPENAL_SAMPLE *) stream;
537 }
538
539 static int OPENAL_Stream_PlayEx(int channel, OPENAL_STREAM *stream, OPENAL_DSPUNIT *dsp, signed char startpaused)
540 {
541     return OPENAL_PlaySoundEx(channel, (OPENAL_SAMPLE *) stream, dsp, startpaused);
542 }
543
544 static signed char OPENAL_Stream_Stop(OPENAL_STREAM *stream)
545 {
546     if (!initialized)
547         return false;
548     for (int i = 0; i < num_channels; i++) {
549         if (impl_channels[i].sample == (OPENAL_SAMPLE *) stream) {
550             alSourceStop(impl_channels[i].sid);
551             impl_channels[i].startpaused = false;
552         }
553     }
554     return true;
555 }
556
557 AL_API signed char OPENAL_Stream_SetMode(OPENAL_STREAM *stream, unsigned int mode)
558 {
559     return OPENAL_Sample_SetMode((OPENAL_SAMPLE *) stream, mode);
560 }
561
562 AL_API void OPENAL_Update()
563 {
564     if (!initialized)
565         return;
566     alcProcessContext(alcGetCurrentContext());
567 }
568
569 AL_API signed char OPENAL_SetOutput(int outputtype)
570 {
571     return true;
572 }
573
574 extern int channels[];
575
576 extern "C" void PlaySoundEx(int chan, OPENAL_SAMPLE *sptr, OPENAL_DSPUNIT *dsp, signed char startpaused)
577 {
578     const OPENAL_SAMPLE * currSample = OPENAL_GetCurrentSample(channels[chan]);
579     if (currSample && currSample == samp[chan]) {
580         if (OPENAL_GetPaused(channels[chan])) {
581             OPENAL_StopSound(channels[chan]);
582             channels[chan] = OPENAL_FREE;
583         } else if (OPENAL_IsPlaying(channels[chan])) {
584             int loop_mode = OPENAL_GetLoopMode(channels[chan]);
585             if (loop_mode & OPENAL_LOOP_OFF) {
586                 channels[chan] = OPENAL_FREE;
587             }
588         }
589     } else {
590         channels[chan] = OPENAL_FREE;
591     }
592
593     channels[chan] = OPENAL_PlaySoundEx(channels[chan], sptr, dsp, startpaused);
594     if (channels[chan] < 0) {
595         channels[chan] = OPENAL_PlaySoundEx(OPENAL_FREE, sptr, dsp, startpaused);
596     }
597 }
598
599 extern "C" void PlayStreamEx(int chan, OPENAL_STREAM *sptr, OPENAL_DSPUNIT *dsp, signed char startpaused)
600 {
601     const OPENAL_SAMPLE * currSample = OPENAL_GetCurrentSample(channels[chan]);
602     if (currSample && currSample == OPENAL_Stream_GetSample(sptr)) {
603         OPENAL_StopSound(channels[chan]);
604         OPENAL_Stream_Stop(sptr);
605     } else {
606         OPENAL_Stream_Stop(sptr);
607         channels[chan] = OPENAL_FREE;
608     }
609
610     channels[chan] = OPENAL_Stream_PlayEx(channels[chan], sptr, dsp, startpaused);
611     if (channels[chan] < 0) {
612         channels[chan] = OPENAL_Stream_PlayEx(OPENAL_FREE, sptr, dsp, startpaused);
613     }
614 }