blockofighter/src/audio.cpp

#include "main.h"

#include <string.h>
#include <stdio.h>

#include "audio.h"

#define SOUND_FADENONE 0
#define SOUND_FADEIN 1
#define SOUND_FADEOUT 2

struct soundlist {
  Sound *sound;
  soundlist *next;
};

soundlist *allsounds = NULL;

Sound::Sound(Sound *source) {
  memcpy(this, source, sizeof(Sound));
  soundlist *node = new soundlist;
  node->sound = this;
  node->next = allsounds;
  allsounds = node;
}

Sound::Sound(char *filename) {
  load(filename, SOUNDTYPE_AUTODETECT, false);
  // printf("%s: %p, %p, %p, %p\n", filename, this, stream, sample, module);
}

Sound::Sound(char *filename, int type) { load(filename, type, false); }

Sound::Sound(char *filename, bool loops) {
  load(filename, SOUNDTYPE_AUTODETECT, loops);
  // printf("%s: %p, %p, %p, %p\n", filename, this, stream, sample, module);
}

Sound::Sound(char *filename, int type, bool loops) {
  load(filename, type, loops);
}

bool endsWith(char *str1, char *str2) {
  char *str3 = str1 + strlen(str1) - strlen(str2);
#ifdef WIN32
  if (stricmp(str3, str2))
    return false;
#else
  if (strcasecmp(str3, str2))
    return false;
#endif
  else
    return true;
}

void Sound::load(char *filename, int type, bool loops) {
  this->filename = filename;
  if (type == SOUNDTYPE_AUTODETECT) {
    if (endsWith(filename, "mp3") || endsWith(filename, "mp2") ||
        endsWith(filename, "ogg"))
      type = SOUNDTYPE_STREAM;

    if (endsWith(filename, "wav") || endsWith(filename, "raw"))
      type = SOUNDTYPE_SAMPLE;

    if (endsWith(filename, "s3m") || endsWith(filename, "xm") ||
        endsWith(filename, "it") || endsWith(filename, "mid") ||
        endsWith(filename, "rmi") || endsWith(filename, "sgr") ||
        endsWith(filename, "mod"))
      type = SOUNDTYPE_MODULE;
  }
#ifdef AUDIO_FMOD
  sample = NULL;
  module = NULL;
  stream = NULL;
  this->type = type;
  if (type == SOUNDTYPE_MODULE) {
    module = FMUSIC_LoadSong(filename);
    this->loops = false;
  } else if (type == SOUNDTYPE_SAMPLE) {
    if (loops) {
      sample = FSOUND_Sample_Load(FSOUND_FREE, filename, FSOUND_LOOP_NORMAL, 0);
      FSOUND_Sample_SetLoopMode(sample, FSOUND_LOOP_NORMAL);
    } else {
      sample = FSOUND_Sample_Load(FSOUND_FREE, filename, FSOUND_LOOP_OFF, 0);
      FSOUND_Sample_SetLoopMode(sample, FSOUND_LOOP_OFF);
    }
    this->loops = loops;
  } else if (type == SOUNDTYPE_STREAM) {
    if (loops) {
      stream = FSOUND_Stream_OpenFile(filename, FSOUND_LOOP_NORMAL, 0);
    } else {
      stream = FSOUND_Stream_OpenFile(filename, FSOUND_LOOP_OFF, 0);
    }
    this->loops = loops;
  }
#endif
  stopcallback = NULL;
  soundlist *node = new soundlist;
  node->sound = this;
  node->next = allsounds;
  allsounds = node;
  minduration = 0;
  setVolume(1.0);
}

bool Sound::play() {
  // printf("Playing %s: %p, %p, %p, %p\n", filename, this, stream, sample,
  // module);
  if (minduration > 0)
    return false;
  running = true;
  finished = false;
  fademode = SOUND_FADENONE;
  minduration = 0;
#ifdef AUDIO_FMOD
  if (type == SOUNDTYPE_MODULE) {
    FMUSIC_PlaySong(module);
    FMUSIC_SetMasterVolume(module, volume * 256);
  } else if (type == SOUNDTYPE_SAMPLE) {
    channel = FSOUND_PlaySound(FSOUND_FREE, sample);
    FSOUND_SetVolume(channel, volume * 256);
    if (!loops) {
      running = false;
      finished = false;
    }
  } else if (type == SOUNDTYPE_STREAM) {
    channel = FSOUND_Stream_Play(FSOUND_FREE, stream);
    FSOUND_SetVolume(channel, volume * 256);
  }
#endif
  // printf("Done: %f\n", volume);
  return true;
}

void Sound::play(int minduration) {
  if (play())
    this->minduration = minduration;
}

void Sound::stop() {
#ifdef AUDIO_FMOD
  if (type == SOUNDTYPE_MODULE) {
    FMUSIC_StopSong(module);
  } else if (type == SOUNDTYPE_SAMPLE) {
    FSOUND_StopSound(channel);
  } else if (type == SOUNDTYPE_STREAM) {
    FSOUND_Stream_Stop(stream);
  }
#endif
}

void Sound::setVolume(float volume) {
// printf("Volume %s: %f\n", filename, volume);
#ifdef AUDIO_FMOD
  if (type == SOUNDTYPE_MODULE) {
    FMUSIC_SetMasterVolume(module, volume * 256);
  } else if (type == SOUNDTYPE_SAMPLE) {
    FSOUND_SetVolume(channel, volume * 256);
  } else if (type == SOUNDTYPE_STREAM) {
    FSOUND_SetVolume(channel, volume * 256);
  }
#endif
  this->volume = volume;
}

#ifdef AUDIO_FMOD
signed char streamendcallback(FSOUND_STREAM *stream, void *buff, int len,
                              int param) {
  Sound *sound = (Sound *)param;
  sound->setFinished();
  return true;
}
#endif

void Sound::setStopCallback(STOPCALLBACK callback) {
  stopcallback = callback;
#ifdef AUDIO_FMOD
  if (type == SOUNDTYPE_MODULE) {
  } else if (type == SOUNDTYPE_SAMPLE) {
    // NOT SUPPORTED
  } else if (type == SOUNDTYPE_STREAM) {
    FSOUND_Stream_SetEndCallback(stream, streamendcallback, (int)this);
  }
#endif
}

void Sound::setFinished(void) { finished = true; }

bool Sound::isFinished(void) {
#ifdef AUDIO_FMOD
  if (type == SOUNDTYPE_MODULE) {
    if (FMUSIC_IsFinished(module))
      return true;
  } else if (type == SOUNDTYPE_SAMPLE) {
    // NOT SUPPORTED
  } else if (type == SOUNDTYPE_STREAM) {
    if (finished)
      return true;
  }
#endif
  return false;
}

void Sound::update(void) {
  if (running) {
    if (isFinished()) {
      running = false;
      if (stopcallback != NULL)
        stopcallback(this);
    } else {
      if (fademode == SOUND_FADEIN) {
        if (fadepos < fadetarget) {
          fadepos++;
          setVolume((float)fadepos / fadetarget);
        } else
          fademode = SOUND_FADENONE;
      }
      if (fademode == SOUND_FADEOUT) {
        if (fadepos < fadetarget) {
          fadepos++;
          setVolume(1.0 - (float)fadepos / fadetarget);
        } else {
          fademode = SOUND_FADENONE;
          stop();
        }
      }
    }
  }
  if (minduration > 0)
    minduration--;
}

void Sound::fadeIn(int length) {
  fademode = SOUND_FADEIN;
  fadepos = 0;
  fadetarget = length;
}

void Sound::fadeOut(int length) {
  if (fademode == SOUND_FADEIN) {
    float percent = 1.0 - (float)fadepos / fadetarget;
    fadepos = fadetarget * percent;
  }
  fadepos = 0;
  fadetarget = length;
  fademode = SOUND_FADEOUT;
}

void initAudio(void) {
#ifdef AUDIO_FMOD
  FSOUND_Init(44100, 32, 0);
#endif
}

void uninitAudio(void) {
#ifdef AUDIO_FMOD
  FSOUND_Close();
#endif
}

void updateAudio(void) {
  soundlist *node = allsounds;
  while (node != NULL) {
    Sound *sound = node->sound;
    sound->update();
    node = node->next;
  }
}