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/XYZ.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 {
  39     ALuint sid;
  40     OPENAL_SAMPLE* sample;
  41     bool startpaused;
  42     float position[3];
  43 } OPENAL_Channels;
  44
  45 typedef struct OPENAL_SAMPLE
  46 {
  47     char* name;
  48     ALuint bid; // buffer id.
  49     int mode;
  50     int is2d;
  51 } OPENAL_SAMPLE;
  52
  53 static size_t num_channels = 0;
  54 static OPENAL_Channels* impl_channels = NULL;
  55 static bool initialized = false;
  56 static float listener_position[3];
  57
  58 static void set_channel_position(const int channel, const float x,
  59                                  const float y, const float z)
  60 {
  61     OPENAL_Channels* chan = &impl_channels[channel];
  62
  63     chan->position[0] = x;
  64     chan->position[1] = y;
  65     chan->position[2] = z;
  66
  67     OPENAL_SAMPLE* sptr = chan->sample;
  68     if (sptr == NULL)
  69         return;
  70
  71     const ALuint sid = chan->sid;
  72     const bool no_attenuate = sptr->is2d;
  73
  74     if (no_attenuate) {
  75         alSourcei(sid, AL_SOURCE_RELATIVE, AL_TRUE);
  76         alSource3f(sid, AL_POSITION, 0.0f, 0.0f, 0.0f);
  77     } else {
  78         alSourcei(sid, AL_SOURCE_RELATIVE, AL_FALSE);
  79         alSource3f(sid, AL_POSITION, x, y, z);
  80     }
  81 }
  82
  83 AL_API void OPENAL_3D_Listener_SetAttributes(const float* pos, const float*, float fx, float fy, float fz, float tx, float ty, float tz)
  84 {
  85     if (!initialized)
  86         return;
  87     if (pos != NULL) {
  88         alListener3f(AL_POSITION, pos[0], pos[1], -pos[2]);
  89         listener_position[0] = pos[0];
  90         listener_position[1] = pos[1];
  91         listener_position[2] = -pos[2];
  92     }
  93
  94     ALfloat vec[6] = { fx, fy, -fz, tx, ty, -tz };
  95     alListenerfv(AL_ORIENTATION, vec);
  96
  97     // we ignore velocity, since doppler's broken in the Linux AL at the moment...
  98
  99     // adjust existing positions...
 100     for (unsigned i = 0; i < num_channels; i++) {
 101         const float* p = impl_channels[i].position;
 102         set_channel_position(i, p[0], p[1], p[2]);
 103     }
 104 }
 105
 106 AL_API signed char OPENAL_3D_SetAttributes(int channel, const float* pos)
 107 {
 108     if (!initialized)
 109         return false;
 110     if ((channel < 0) || (channel >= (int)num_channels))
 111         return false;
 112
 113     if (pos != NULL)
 114         set_channel_position(channel, pos[0], pos[1], -pos[2]);
 115
 116     // we ignore velocity, since doppler's broken in the Linux AL at the moment...
 117
 118     return true;
 119 }
 120
 121 AL_API signed char OPENAL_3D_SetAttributes_(int channel, const XYZ& pos)
 122 {
 123     if (!initialized)
 124         return false;
 125     if ((channel < 0) || (channel >= (int)num_channels))
 126         return false;
 127
 128     set_channel_position(channel, pos.x, pos.y, -pos.z);
 129
 130     return true;
 131 }
 132
 133 AL_API signed char OPENAL_Init(int mixrate, int maxsoftwarechannels, unsigned int flags)
 134 {
 135     if (initialized)
 136         return false;
 137     if (maxsoftwarechannels == 0)
 138         return false;
 139
 140     if (flags != 0) // unsupported.
 141         return false;
 142
 143     ALCdevice* dev = alcOpenDevice(NULL);
 144     if (!dev)
 145         return false;
 146
 147     ALint caps[] = { ALC_FREQUENCY, mixrate, 0 };
 148     ALCcontext* ctx = alcCreateContext(dev, caps);
 149     if (!ctx) {
 150         alcCloseDevice(dev);
 151         return false;
 152     }
 153
 154     alcMakeContextCurrent(ctx);
 155     alcProcessContext(ctx);
 156
 157     if (commandLineOptions[OPENALINFO]) {
 158         printf("AL_VENDOR: %s\n", (char*)alGetString(AL_VENDOR));
 159         printf("AL_RENDERER: %s\n", (char*)alGetString(AL_RENDERER));
 160         printf("AL_VERSION: %s\n", (char*)alGetString(AL_VERSION));
 161         printf("AL_EXTENSIONS: %s\n", (char*)alGetString(AL_EXTENSIONS));
 162     }
 163
 164     num_channels = maxsoftwarechannels;
 165     impl_channels = new OPENAL_Channels[maxsoftwarechannels];
 166     memset(impl_channels, '\0', sizeof(OPENAL_Channels) * num_channels);
 167     for (unsigned i = 0; i < num_channels; i++)
 168         alGenSources(1, &impl_channels[i].sid); // !!! FIXME: verify this didn't fail!
 169
 170     initialized = true;
 171     return true;
 172 }
 173
 174 AL_API void OPENAL_Close()
 175 {
 176     if (!initialized)
 177         return;
 178
 179     ALCcontext* ctx = alcGetCurrentContext();
 180     if (ctx) {
 181         for (unsigned i = 0; i < num_channels; i++) {
 182             alSourceStop(impl_channels[i].sid);
 183             alSourcei(impl_channels[i].sid, AL_BUFFER, 0);
 184             alDeleteSources(1, &impl_channels[i].sid);
 185         }
 186         ALCdevice* dev = alcGetContextsDevice(ctx);
 187         alcMakeContextCurrent(NULL);
 188         alcSuspendContext(ctx);
 189         alcDestroyContext(ctx);
 190         alcCloseDevice(dev);
 191     }
 192
 193     num_channels = 0;
 194     delete[] impl_channels;
 195     impl_channels = NULL;
 196
 197     initialized = false;
 198 }
 199
 200 static OPENAL_SAMPLE* OPENAL_GetCurrentSample(int channel)
 201 {
 202     if (!initialized)
 203         return NULL;
 204     if ((channel < 0) || (channel >= (int)num_channels))
 205         return NULL;
 206     return impl_channels[channel].sample;
 207 }
 208
 209 static signed char OPENAL_GetPaused(int channel)
 210 {
 211     if (!initialized)
 212         return false;
 213     if ((channel < 0) || (channel >= (int)num_channels))
 214         return false;
 215     if (impl_channels[channel].startpaused)
 216         return (true);
 217
 218     ALint state = 0;
 219     alGetSourceiv(impl_channels[channel].sid, AL_SOURCE_STATE, &state);
 220     return ((state == AL_PAUSED) ? true : false);
 221 }
 222
 223 static unsigned int OPENAL_GetLoopMode(int channel)
 224 {
 225     if (!initialized)
 226         return 0;
 227     if ((channel < 0) || (channel >= (int)num_channels))
 228         return 0;
 229     ALint loop = 0;
 230     alGetSourceiv(impl_channels[channel].sid, AL_LOOPING, &loop);
 231     if (loop)
 232         return (OPENAL_LOOP_NORMAL);
 233     return OPENAL_LOOP_OFF;
 234 }
 235
 236 static signed char OPENAL_IsPlaying(int channel)
 237 {
 238     if (!initialized)
 239         return false;
 240     if ((channel < 0) || (channel >= (int)num_channels))
 241         return false;
 242     ALint state = 0;
 243     alGetSourceiv(impl_channels[channel].sid, AL_SOURCE_STATE, &state);
 244     return ((state == AL_PLAYING) ? true : false);
 245 }
 246
 247 static int OPENAL_PlaySoundEx(int channel, OPENAL_SAMPLE* sptr, OPENAL_DSPUNIT* dsp, signed char startpaused)
 248 {
 249     if (!initialized)
 250         return -1;
 251     if (sptr == NULL)
 252         return -1;
 253     if (dsp != NULL)
 254         return -1;
 255     if (channel == OPENAL_FREE) {
 256         for (unsigned i = 0; i < num_channels; i++) {
 257             ALint state = 0;
 258             alGetSourceiv(impl_channels[i].sid, AL_SOURCE_STATE, &state);
 259             if ((state != AL_PLAYING) && (state != AL_PAUSED)) {
 260                 channel = i;
 261                 break;
 262             }
 263         }
 264     }
 265
 266     if ((channel < 0) || (channel >= (int)num_channels))
 267         return -1;
 268     alSourceStop(impl_channels[channel].sid);
 269     impl_channels[channel].sample = sptr;
 270     alSourcei(impl_channels[channel].sid, AL_BUFFER, sptr->bid);
 271     alSourcei(impl_channels[channel].sid, AL_LOOPING, (sptr->mode == OPENAL_LOOP_OFF) ? AL_FALSE : AL_TRUE);
 272     set_channel_position(channel, 0.0f, 0.0f, 0.0f);
 273
 274     impl_channels[channel].startpaused = ((startpaused) ? true : false);
 275     if (!startpaused)
 276         alSourcePlay(impl_channels[channel].sid);
 277     return channel;
 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 >= (int)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 AL_API OPENAL_SAMPLE* OPENAL_Sample_Load(int index, const char* name_or_data, unsigned int mode, int offset, int length)
 366 {
 367     if (!initialized)
 368         return NULL;
 369     if (index != OPENAL_FREE)
 370         return NULL; // this is all the game does...
 371     if (offset != 0)
 372         return NULL; // this is all the game does...
 373     if (length != 0)
 374         return NULL; // this is all the game does...
 375     if ((mode != OPENAL_HW3D) && (mode != OPENAL_2D))
 376         return NULL; // this is all the game does...
 377
 378     OPENAL_SAMPLE* retval = NULL;
 379     ALenum format = AL_NONE;
 380     ALsizei size = 0;
 381     ALuint frequency = 0;
 382     void* data = decode_to_pcm(name_or_data, format, size, frequency);
 383     if (data == NULL)
 384         return NULL;
 385
 386     ALuint bid = 0;
 387     alGetError();
 388     alGenBuffers(1, &bid);
 389     if (alGetError() == AL_NO_ERROR) {
 390         alBufferData(bid, format, data, size, frequency);
 391         retval = new OPENAL_SAMPLE;
 392         retval->bid = bid;
 393         retval->mode = OPENAL_LOOP_OFF;
 394         retval->is2d = (mode == OPENAL_2D);
 395         retval->name = new char[strlen(name_or_data) + 1];
 396         if (retval->name)
 397             strcpy(retval->name, name_or_data);
 398     }
 399
 400     free(data);
 401     return (retval);
 402 }
 403
 404 AL_API void OPENAL_Sample_Free(OPENAL_SAMPLE* sptr)
 405 {
 406     if (!initialized)
 407         return;
 408     if (sptr) {
 409         for (unsigned i = 0; i < num_channels; i++) {
 410             if (impl_channels[i].sample == sptr) {
 411                 alSourceStop(impl_channels[i].sid);
 412                 alSourcei(impl_channels[i].sid, AL_BUFFER, 0);
 413                 impl_channels[i].sample = NULL;
 414             }
 415         }
 416         alDeleteBuffers(1, &sptr->bid);
 417         delete[] sptr->name;
 418         delete sptr;
 419     }
 420 }
 421
 422 static signed char OPENAL_Sample_SetMode(OPENAL_SAMPLE* sptr, unsigned int mode)
 423 {
 424     if (!initialized)
 425         return false;
 426     if ((mode != OPENAL_LOOP_NORMAL) && (mode != OPENAL_LOOP_OFF))
 427         return false;
 428     if (!sptr)
 429         return false;
 430     sptr->mode = mode;
 431     return true;
 432 }
 433
 434 AL_API signed char OPENAL_SetFrequency(int channel, bool slomo)
 435 {
 436     if (!initialized)
 437         return false;
 438     if (channel == OPENAL_ALL) {
 439         for (unsigned i = 0; i < num_channels; i++)
 440             OPENAL_SetFrequency(i, slomo);
 441         return true;
 442     }
 443
 444     if ((channel < 0) || (channel >= (int)num_channels))
 445         return false;
 446     if (slomo)
 447         alSourcef(impl_channels[channel].sid, AL_PITCH, ((ALfloat)slomofreq) / 44100.0f);
 448     else
 449         alSourcef(impl_channels[channel].sid, AL_PITCH, 1.0f);
 450     return true;
 451 }
 452
 453 AL_API signed char OPENAL_SetVolume(int channel, int vol)
 454 {
 455     if (!initialized)
 456         return false;
 457
 458     if (channel == OPENAL_ALL) {
 459         for (unsigned i = 0; i < num_channels; i++)
 460             OPENAL_SetVolume(i, vol);
 461         return true;
 462     }
 463
 464     if ((channel < 0) || (channel >= (int)num_channels))
 465         return false;
 466
 467     if (vol < 0)
 468         vol = 0;
 469     else if (vol > 255)
 470         vol = 255;
 471     ALfloat gain = ((ALfloat)vol) / 255.0f;
 472     alSourcef(impl_channels[channel].sid, AL_GAIN, gain);
 473     return true;
 474 }
 475
 476 AL_API signed char OPENAL_SetPaused(int channel, signed char paused)
 477 {
 478     if (!initialized)
 479         return false;
 480
 481     if (channel == OPENAL_ALL) {
 482         for (unsigned i = 0; i < num_channels; i++)
 483             OPENAL_SetPaused(i, paused);
 484         return true;
 485     }
 486
 487     if ((channel < 0) || (channel >= (int)num_channels))
 488         return false;
 489
 490     ALint state = 0;
 491     if (impl_channels[channel].startpaused)
 492         state = AL_PAUSED;
 493     else
 494         alGetSourceiv(impl_channels[channel].sid, AL_SOURCE_STATE, &state);
 495
 496     if ((paused) && (state == AL_PLAYING))
 497         alSourcePause(impl_channels[channel].sid);
 498     else if ((!paused) && (state == AL_PAUSED)) {
 499         alSourcePlay(impl_channels[channel].sid);
 500         impl_channels[channel].startpaused = false;
 501     }
 502     return true;
 503 }
 504
 505 AL_API void OPENAL_SetSFXMasterVolume(int volume)
 506 {
 507     if (!initialized)
 508         return;
 509     ALfloat gain = ((ALfloat)volume) / 255.0f;
 510     alListenerf(AL_GAIN, gain);
 511 }
 512
 513 AL_API signed char OPENAL_StopSound(int channel)
 514 {
 515     if (!initialized)
 516         return false;
 517
 518     if (channel == OPENAL_ALL) {
 519         for (unsigned i = 0; i < num_channels; i++)
 520             OPENAL_StopSound(i);
 521         return true;
 522     }
 523
 524     if ((channel < 0) || (channel >= (int)num_channels))
 525         return false;
 526     alSourceStop(impl_channels[channel].sid);
 527     impl_channels[channel].startpaused = false;
 528     return true;
 529 }
 530
 531 static OPENAL_SAMPLE* OPENAL_Stream_GetSample(OPENAL_STREAM* stream)
 532 {
 533     if (!initialized)
 534         return NULL;
 535     return (OPENAL_SAMPLE*)stream;
 536 }
 537
 538 static int OPENAL_Stream_PlayEx(int channel, OPENAL_STREAM* stream, OPENAL_DSPUNIT* dsp, signed char startpaused)
 539 {
 540     return OPENAL_PlaySoundEx(channel, (OPENAL_SAMPLE*)stream, dsp, startpaused);
 541 }
 542
 543 static signed char OPENAL_Stream_Stop(OPENAL_STREAM* stream)
 544 {
 545     if (!initialized)
 546         return false;
 547     for (unsigned i = 0; i < num_channels; i++) {
 548         if (impl_channels[i].sample == (OPENAL_SAMPLE*)stream) {
 549             alSourceStop(impl_channels[i].sid);
 550             impl_channels[i].startpaused = false;
 551         }
 552     }
 553     return true;
 554 }
 555
 556 AL_API signed char OPENAL_Stream_SetMode(OPENAL_STREAM* stream, unsigned int mode)
 557 {
 558     return OPENAL_Sample_SetMode((OPENAL_SAMPLE*)stream, mode);
 559 }
 560
 561 AL_API void OPENAL_Update()
 562 {
 563     if (!initialized)
 564         return;
 565     alcProcessContext(alcGetCurrentContext());
 566 }
 567
 568 extern int channels[];
 569
 570 extern "C" void PlaySoundEx(int chan, OPENAL_SAMPLE* sptr, OPENAL_DSPUNIT* dsp, signed char startpaused)
 571 {
 572     const OPENAL_SAMPLE* currSample = OPENAL_GetCurrentSample(channels[chan]);
 573     if (currSample && currSample == samp[chan]) {
 574         if (OPENAL_GetPaused(channels[chan])) {
 575             OPENAL_StopSound(channels[chan]);
 576             channels[chan] = OPENAL_FREE;
 577         } else if (OPENAL_IsPlaying(channels[chan])) {
 578             int loop_mode = OPENAL_GetLoopMode(channels[chan]);
 579             if (loop_mode & OPENAL_LOOP_OFF) {
 580                 channels[chan] = OPENAL_FREE;
 581             }
 582         }
 583     } else {
 584         channels[chan] = OPENAL_FREE;
 585     }
 586
 587     channels[chan] = OPENAL_PlaySoundEx(channels[chan], sptr, dsp, startpaused);
 588     if (channels[chan] < 0) {
 589         channels[chan] = OPENAL_PlaySoundEx(OPENAL_FREE, sptr, dsp, startpaused);
 590     }
 591 }
 592
 593 extern "C" void PlayStreamEx(int chan, OPENAL_STREAM* sptr, OPENAL_DSPUNIT* dsp, signed char startpaused)
 594 {
 595     const OPENAL_SAMPLE* currSample = OPENAL_GetCurrentSample(channels[chan]);
 596     if (currSample && currSample == OPENAL_Stream_GetSample(sptr)) {
 597         OPENAL_StopSound(channels[chan]);
 598         OPENAL_Stream_Stop(sptr);
 599     } else {
 600         OPENAL_Stream_Stop(sptr);
 601         channels[chan] = OPENAL_FREE;
 602     }
 603
 604     channels[chan] = OPENAL_Stream_PlayEx(channels[chan], sptr, dsp, startpaused);
 605     if (channels[chan] < 0) {
 606         channels[chan] = OPENAL_Stream_PlayEx(OPENAL_FREE, sptr, dsp, startpaused);
 607     }
 608 }