src/SoundEngine.cc

   1 /*
   2  * Copyright (C) 2002,2003,2004 Daniel Heck
   3  * Copyright (C) 2007,2008 Andreas Lochmann
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  */
  20 #include "errors.hh"
  21 #include "options.hh"
  22 #include "SoundEngine.hh"
  23 #include "main.hh"
  24
  25 #include "SDL_mixer.h"
  26 #include "SDL_mutex.h"
  27
  28 #include <string>
  29 #include <cassert>
  30
  31 using namespace enigma;
  32 using namespace sound;
  33
  34 /* -------------------- Local variables -------------------- */
  35 namespace
  36 {
  37     std::auto_ptr<SoundEngine> sound_engine;
  38
  39     bool sound_enabled      = true;
  40     bool music_enabled      = true;
  41     bool sound_enabled_temp = false;
  42     bool sound_mute         = false;
  43     bool music_mute         = false;
  44 }
  45
  46 /* -------------------- Interface Functions -------------------- */
  47
  48 void sound::Init(bool withMusic, bool withSound)
  49 {
  50     sound_enabled = withSound;
  51     music_enabled = withMusic;
  52     if (!sound_engine.get()) {
  53         sound_engine.reset(new SoundEngine_SDL);
  54     }
  55
  56     if (sound_engine->init()) {
  57         sound::UpdateVolume();
  58     } else {
  59         sound_enabled = false;
  60         music_enabled = false;
  61         sound_engine.reset(new SoundEngine_Null);
  62     }
  63 }
  64
  65 void sound::Shutdown()
  66 {
  67     if (sound_engine.get())
  68         sound_engine->shutdown();
  69 }
  70
  71 void sound::Tick (double dtime)
  72 {
  73     sound_engine->tick (dtime);
  74     sound::MusicTick(dtime);
  75 }
  76
  77 void sound::TempDisableSound() {
  78     sound_enabled_temp = sound_enabled;
  79     sound_enabled      = false;
  80 }
  81
  82 void sound::TempReEnableSound() {
  83     sound_enabled = sound_enabled_temp;
  84 }
  85
  86 bool sound::IsSoundMute() {
  87     return !sound_enabled || sound_mute;
  88 }
  89
  90 bool sound::IsMusicMute() {
  91     return !sound_enabled || !music_enabled || music_mute;
  92 }
  93
  94 void sound::DefineSound (const SoundName &name, const SoundData &data)
  95 {
  96     sound_engine->define_sound (name, data);
  97 }
  98
  99 void sound::SetListenerPosition (const ecl::V2 &pos)
 100 {
 101     sound_engine->set_listenerpos (pos);
 102 }
 103
 104 bool sound::PlaySound (const SoundName &name, const ecl::V2 &pos, double volume, int priority)
 105 {
 106     if (sound::IsSoundMute())
 107         return false;
 108
 109     SoundEvent se;
 110     se.name         = name;
 111     se.has_position = true;
 112     se.position     = pos;
 113     se.priority     = priority;
 114     se.volume       = volume * options::GetDouble("SoundVolume");
 115     se.left = se.right = 0;
 116
 117     return sound_engine->play_sound (se);
 118 }
 119
 120 bool sound::PlaySoundGlobal (const SoundName &name, double volume, int priority)
 121 {
 122     if (sound::IsSoundMute())
 123         return false;
 124
 125     SoundEvent se;
 126     se.name         = name;
 127     se.has_position = false;
 128     se.position     = ecl::V2();
 129     se.priority     = priority;
 130     se.volume       = volume * options::GetDouble("SoundVolume");
 131     se.left         = 255;
 132     se.right        = 255;
 133
 134     return sound_engine->play_sound (se);
 135 }
 136
 137 void sound::ClearCache()
 138 {
 139     sound_engine->clear_cache();
 140 }
 141
 142 void sound::CacheSound(const SoundEffect &s)
 143 {
 144     sound_engine->cache_sound(s);
 145 }
 146
 147 void sound::FadeoutMusic(bool blocking)
 148 {
 149     sound_engine->fadeout_music(blocking);
 150 }
 151
 152 bool sound::PlayMusic (const std::string &name, double position)
 153 {
 154     if(sound::IsMusicMute() || name=="")
 155         return false;
 156
 157     std::string fname;
 158     return app.resourceFS->findFile (name, fname) && sound_engine->play_music(fname, position);
 159 }
 160
 161 void sound::StopMusic() {
 162     sound_engine->stop_music();
 163 }
 164
 165 bool sound::IsMusicPlaying() {
 166     return sound_engine->is_music_playing();
 167 }
 168
 169 void sound::SetSoundVolume (double vol)
 170 {
 171     sound_engine->set_sound_volume (vol);
 172     sound_mute = (vol == 0.0);
 173 }
 174
 175 void sound::SetMusicVolume (double vol)
 176 {
 177     sound_engine->set_music_volume (vol);
 178     music_mute = (vol == 0.0);
 179 }
 180
 181 void sound::UpdateVolume()
 182 {
 183     sound::SetSoundVolume(options::GetDouble("SoundVolume"));
 184     sound::SetMusicVolume(options::GetDouble("MusicVolume"));
 185 }
 186
 187 /* -------------------- SoundEngine_SDL implementation -------------------- */
 188
 189 SoundEngine::SoundEngine()
 190 {}
 191
 192 class MutexLock {
 193 public:
 194     MutexLock (SDL_mutex *m) {
 195         mutex = m;
 196         SDL_mutexP (mutex);
 197     }
 198     ~MutexLock () {
 199         SDL_mutexV (mutex);
 200     };
 201 private:
 202     SDL_mutex *mutex;
 203 };
 204
 205 SoundEngine_SDL *SoundEngine_SDL::m_instance = 0;
 206
 207 SoundEngine_SDL::SoundEngine_SDL()
 208 : m_initialized(false),
 209   m_soundvolume (MIX_MAX_VOLUME),
 210   m_musicvolume (MIX_MAX_VOLUME),
 211   m_current_music (0),
 212   m_freq (MIX_DEFAULT_FREQUENCY),
 213   m_format (MIX_DEFAULT_FORMAT),
 214   m_channels (MIX_DEFAULT_CHANNELS)
 215 {
 216     assert (m_instance == 0);
 217     m_instance = this;
 218 }
 219
 220 SoundEngine_SDL::~SoundEngine_SDL()
 221 {
 222     shutdown();
 223     m_instance = 0;
 224 }
 225
 226 bool SoundEngine_SDL::init()
 227 {
 228     if (!m_initialized) {
 229         // Initialize SDL audio subsystem
 230         if (SDL_InitSubSystem (SDL_INIT_AUDIO) == -1) {
 231             fprintf(stderr, "Couldn't open SDL audio subsystem: %s\n", SDL_GetError());
 232             return false;
 233         }
 234
 235         const SDL_version* vi = Mix_Linked_Version();
 236         Log <<  ecl::strf("SDL_mixer Version: %u.%u.%u\n", vi->major, vi->minor, vi->patch);
 237 #ifdef SDL_MIX_INIT
 238         int mix_flags = MIX_INIT_OGG | MIX_INIT_MOD;
 239         if (Mix_Init(mix_flags) & mix_flags != mix_flags) {
 240             Log << ecl::strf( "Couldn't initialize SDL_mixer: %s\n", Mix_GetError());
 241             return false;
 242         }
 243 #endif
 244
 245         // Initialize SDL_mixer lib
 246         if (Mix_OpenAudio(m_freq, m_format, m_channels, 1024) < 0) {
 247             fprintf(stderr, "Couldn't open mixer: %s\n", Mix_GetError());
 248             return false;
 249         }
 250
 251         // Update number of available channels
 252         m_channels = Mix_GroupCount (-1);
 253         m_channelinfo.resize (m_channels);
 254
 255         Mix_ChannelFinished (&channel_finished);
 256         m_mutex = SDL_CreateMutex();
 257         if (!m_mutex)
 258             return false;
 259
 260         m_initialized = true;
 261     }
 262     return true;
 263 }
 264
 265 void SoundEngine_SDL::shutdown()
 266 {
 267     if (m_initialized) {
 268         Mix_FreeMusic(m_current_music);
 269         Mix_CloseAudio();
 270         clear_cache();
 271         SDL_DestroyMutex (m_mutex);
 272 #ifdef SDL_MIX_INIT
 273         Mix_Quit();
 274 #endif
 275         m_initialized = false;
 276     }
 277 }
 278
 279 void SoundEngine_SDL::clear_cache()
 280 {
 281     for (ecl::Dict<Mix_Chunk*>::iterator it = wav_cache.begin(); it != wav_cache.end(); ++it)
 282         Mix_FreeChunk(it->second);
 283     wav_cache.clear();
 284 }
 285
 286 void SoundEngine_SDL::set_sound_volume (double soundvol)
 287 {
 288     if (!m_initialized)
 289         return;                 // SDL_mixer crashes without this check
 290
 291     m_soundvolume = ecl::round_down<int>(ecl::Clamp(soundvol, 0.0, 1.0) * MIX_MAX_VOLUME);
 292     Mix_Volume (-1, m_soundvolume);
 293 }
 294
 295 void SoundEngine_SDL::set_music_volume (double musicvol)
 296 {
 297     if (!m_initialized)
 298         return;                 // SDL_mixer crashes without this check
 299
 300     m_musicvolume = ecl::round_down<int>(ecl::Clamp(musicvol, 0.0, 1.0) * MIX_MAX_VOLUME);
 301     Mix_VolumeMusic (m_musicvolume);
 302     //Mix_SetPanning(MIX_CHANNEL_POST, m_musicvolume, m_musicvolume);
 303 }
 304
 305
 306 void SoundEngine_SDL::stop_music()
 307 {
 308     Mix_HaltMusic();
 309     Mix_FreeMusic(m_current_music);
 310     m_current_music = 0;
 311 }
 312
 313 bool SoundEngine_SDL::play_music (const std::string &filename, double position)
 314 {
 315     if (Mix_Music *music = Mix_LoadMUS(filename.c_str())) {
 316         if (m_current_music)
 317             Mix_FreeMusic (m_current_music);
 318         m_current_music = music;
 319         if(Mix_PlayMusic (m_current_music, 1) == -1)
 320             Log << "Mix_PlayMusic: " << Mix_GetError() << "\n";
 321         if(position > 0) {
 322             Log << "Start music at position " << position << "\n";
 323             if(Mix_SetMusicPosition(position) == -1)
 324                 Log << "Mix_SetMusicPosition: " << Mix_GetError() << "\n";
 325         }
 326         Mix_VolumeMusic (m_musicvolume);
 327         //Mix_SetPanning(MIX_CHANNEL_POST, m_musicvolume, m_musicvolume);
 328         return true;
 329     }
 330     return false;
 331 }
 332
 333 void SoundEngine_SDL::fadeout_music(bool blocking)
 334 {
 335     while (Mix_FadingMusic() != MIX_NO_FADING) {
 336         if (!blocking)
 337             return;
 338         SDL_Delay(10);
 339     }
 340
 341     if (Mix_PlayingMusic()) {
 342         Mix_FadeOutMusic(500);
 343         if (!blocking)
 344             return;
 345         SDL_Delay(400);
 346     }
 347     while (Mix_PlayingMusic())
 348         SDL_Delay(10);
 349 }
 350
 351 void SoundEngine_SDL::update_channel (int channel)
 352 {
 353     SoundEvent &se = m_channelinfo[channel];
 354
 355     double volume;
 356     int    left;
 357     int    right;
 358     if (se.has_position) {
 359         ecl::V2 distv = se.position - m_listenerpos;
 360         int xdist = int(distv[0] * options::GetDouble("StereoSeparation"));
 361         left  = ecl::Clamp (255 - xdist, 0, 255);
 362         right = ecl::Clamp (255 + xdist, 0, 255);
 363         volume = se.effectiveVolume(length(distv));
 364     }
 365     else
 366     {
 367         volume = se.volume;
 368         left = se.left;
 369         right = se.right;
 370     }
 371
 372     Mix_SetPanning (channel, left, right);
 373
 374     int mixvol = ecl::round_down<int>(volume * MIX_MAX_VOLUME);
 375     Mix_Volume(channel, ecl::Clamp(mixvol, 0, MIX_MAX_VOLUME));
 376 }
 377
 378 int SoundEngine_SDL::already_playing (const SoundEvent &s)
 379 {
 380     for (size_t i=0; i<m_channelinfo.size(); ++i) {
 381         const SoundEvent &se = m_channelinfo[i];
 382
 383         if (se.active && se.name == s.name && se.playing_time < 0.05
 384             && (!se.has_position || !s.has_position ||
 385                 ecl::length(se.position - s.position) < se.range + se.fullvol_range))
 386             return static_cast<int> (i);
 387     }
 388     return -1;
 389 }
 390
 391 Mix_Chunk *SoundEngine_SDL::cache_sound(const std::string &name)
 392 {
 393     ecl::Dict<Mix_Chunk*>::iterator i=wav_cache.find(name);
 394     if (i == wav_cache.end()) {
 395         Mix_Chunk *ch = 0;
 396         std::string filename;
 397         if (app.resourceFS->findFile("soundsets/" + name + ".wav", filename))
 398              ch = Mix_LoadWAV(filename.c_str());
 399         else
 400             // Sounds from other resources shoudl return correct error:
 401             Mix_SetError("Sound not found in resources.");
 402         if (ch != 0)
 403             wav_cache.insert(name, ch);
 404         else
 405             enigma::Log << "Couldn't load sample '" << name << "': "
 406                         << Mix_GetError() << std::endl;
 407         return ch;
 408     } else
 409         return i->second;
 410 }
 411
 412 void SoundEngine_SDL::cache_sound(const SoundEffect &s)
 413 {
 414     std::string filename = s.getFilename();
 415     if (filename != "")
 416         cache_sound(filename);
 417 }
 418
 419 bool SoundEngine_SDL::play_sound (const SoundEvent &s)
 420 {
 421     int channel = already_playing (s);
 422     if (channel != -1) {
 423         MutexLock (m_instance->m_mutex);
 424         SoundEvent &se = m_channelinfo [channel];
 425         if(se.merge(s)) {
 426             update_channel(channel);
 427             return true;
 428         }
 429     }
 430
 431     if (Mix_Chunk *chunk = cache_sound(s.name)) {
 432         channel = -1; //Mix_GroupOldest(-1);
 433
 434         channel = Mix_PlayChannel(channel, chunk, 0);
 435
 436         if (channel != -1) {
 437             {
 438                 MutexLock (m_instance->m_mutex);
 439                 SoundEvent &se = m_channelinfo[channel];
 440                 se = s;
 441                 se.active       = true;
 442                 se.playing_time = 0.0;
 443             }
 444             update_channel (channel);
 445         }
 446         return true; // even if no free channel was found
 447     } else
 448         return false;
 449 }
 450
 451 bool SoundEngine_SDL::is_music_playing() {
 452     return Mix_PlayingMusic() || Mix_PausedMusic();
 453 }
 454
 455 void SoundEngine_SDL::tick (double dtime)
 456 {
 457     MutexLock (m_instance->m_mutex);
 458     for (size_t i=0; i<m_channelinfo.size(); ++i) {
 459         SoundEvent &se = m_channelinfo[i];
 460         if (se.active)
 461             se.playing_time += dtime;
 462     }
 463 }
 464
 465 void SoundEngine_SDL::define_sound (
 466     const SoundName &name,
 467     const SoundData &data)
 468 {
 469     Uint32 bufsize = static_cast<Uint32> (data.buf.size());
 470     Mix_Chunk *ch= ChunkFromRaw (&data.buf[0], bufsize,
 471                                  data.freq, AUDIO_S8, data.nchannels);
 472     if (ch != 0)
 473         wav_cache.insert(name, ch);
 474 }
 475
 476 void SoundEngine_SDL::channel_finished (int channel)
 477 {
 478     MutexLock (m_instance->m_mutex);
 479     SoundEvent &se = m_instance->m_channelinfo[channel];
 480     se.active = false;
 481 }
 482
 483 /*! SDL_ConvertAudio is only capable of changing the sound frequency by
 484   integer powers of 2 (i.e., by a factor of ... 1/4 1/2 1 2 ...).
 485   The sound files used by Oxyd are sampled at 6kHz which we must
 486   convert to roughly 22kHz.  This function resamples between any two
 487   frequencies using simple linear interpolation.  It is not capable
 488   of changing the sample format or dealing with more than one
 489   channel.
 490
 491   FIXME: We should apply a lowpass filter after reampling to get rid
 492   of the artifacts introduced by linear interpolation or use a better
 493   interpolator. */
 494 Sint8* SoundEngine_SDL::resample (const Sint8 *data, Uint32 len, int oldfreq,
 495                                   int newfreq, Uint32 *newlen_)
 496     {
 497         assert (data);
 498         assert (len>0);
 499         assert (oldfreq > 0);
 500         assert (newfreq > 0);
 501         const int sample_size = 1;    //  8bit sample data
 502
 503         float ratio = float(oldfreq) / float(newfreq);
 504         Uint32 newlen = ecl::round_down<int> (len / ratio);
 505         *newlen_ = newlen;
 506         Sint8 *newdata = (Sint8*) malloc (sample_size * newlen);
 507         if (!newdata)
 508             return 0;
 509
 510         const Sint8 *src = data;
 511         Sint8       *dst = newdata;
 512
 513         float srcinc = float (len-1) / float (newlen);
 514         for (unsigned i=0; i<newlen; ++i) {
 515             int srcidx = ecl::round_down <int> (i * srcinc);
 516             float a2 = i*srcinc - srcidx;
 517             float a1 = 1.0f - a2;
 518             dst[i] = static_cast<Sint8> ((a1*src[srcidx] + a2*src[srcidx+1])/2);
 519         }
 520         return newdata;
 521     }
 522
 523 Mix_Chunk* SoundEngine_SDL::ChunkFromRaw (const Uint8 *buf, Uint32 len,
 524                                            int sfreq, int sformat, int schannels)
 525 {
 526     if (sound::IsSoundMute() || !buf)
 527         return 0;
 528
 529     // Get destination format
 530     int dfreq, dchannels;
 531     Uint16 dformat;
 532     Mix_QuerySpec (&dfreq, &dformat, &dchannels);
 533
 534     // Resample
 535     Uint32 newlen=0;
 536     Uint8 *newbuf = (Uint8*)resample((const Sint8*)buf, len, sfreq, dfreq, &newlen);
 537
 538     // Convert audio data
 539     SDL_AudioCVT cvt;
 540     if (!SDL_BuildAudioCVT (&cvt, sformat, schannels, dfreq,
 541                             dformat, dchannels, dfreq))
 542         return 0; // memory leak!
 543
 544     cvt.buf = (Uint8*) malloc(newlen * cvt.len_mult);
 545     cvt.len = newlen;
 546     memcpy(cvt.buf, newbuf, newlen);
 547     free(newbuf);
 548
 549     SDL_ConvertAudio(&cvt);
 550
 551     Mix_Chunk *chunk = Mix_QuickLoad_RAW(cvt.buf, cvt.len_cvt);
 552     chunk->allocated = 1;
 553     return chunk;
 554 }
 555