Sound::Sound() {
if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
SDL_Log("Unable to initialize SDL: %s", SDL_GetError());
return;
}
if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, MIX_DEFAULT_CHANNELS, 1024) == -1) {
printf("%s", Mix_GetError());
}
for(int i = 0; i < nbChannelSound; i++){
activeChannel[i] = false;
}
menu = Mix_LoadMUSType_RW(SDL_RWFromMem(music_menu_mp3, music_menu_mp3_len), MUS_MP3, 0);
battle = Mix_LoadMUSType_RW(SDL_RWFromMem(music_battle_mp3, music_battle_mp3_len), MUS_MP3, 0);
bipSound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_bip_wav, sound_bip_wav_len), 0);
bombeBounceSound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_bounce_wav, sound_bounce_wav_len), 0);
playerBurnSound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_burn_wav, sound_burn_wav_len), 0);
cancelSound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_cancel_wav, sound_cancel_wav_len), 0);
endSound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_end_wav, sound_end_wav_len), 0);
fireSound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_fire_wav, sound_fire_wav_len), 0);
hole1Sound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_hole1_wav, sound_hole1_wav_len), 0);
hole2Sound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_hole2_wav, sound_hole2_wav_len), 0);
hole3Sound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_hole3_wav, sound_hole3_wav_len), 0);
playerKickSound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_kick_wav, sound_kick_wav_len), 0);
louisSound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_louis_wav, sound_louis_wav_len), 0);
mineSound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_mine_wav, sound_mine_wav_len), 0);
teleporterCloseSound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_teleporter_close_wav, sound_teleporter_close_wav_len), 0);
teleporterOpenSound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_teleporter_open_wav, sound_teleporter_open_wav_len), 0);
validSound = Mix_LoadWAV_RW(SDL_RWFromMem(sound_valide_wav, sound_valide_wav_len), 0);
Mix_PlayMusic(menu, -1);
Mix_VolumeMusic (MIX_MAX_VOLUME);
Mix_AllocateChannels(nbChannelSound);
Mix_Volume(0, MIX_MAX_VOLUME / 2);
Mix_Volume(3, MIX_MAX_VOLUME / 2);
mineOffsetChannel = 14;
}
static mrb_value
mrb_sdl2_mixer_music_initialize(mrb_state *mrb, mrb_value self)
{
Mix_Music *music = NULL;
mrb_sdl2_mixer_music_data_t *data =
(mrb_sdl2_mixer_music_data_t*)DATA_PTR(self);
if (NULL == data) {
data = (mrb_sdl2_mixer_music_data_t*)mrb_malloc(mrb, sizeof(mrb_sdl2_mixer_music_data_t));
if (NULL == data) {
mrb_raise(mrb, E_RUNTIME_ERROR, "insufficient memory.");
}
data->music = NULL;
}
if (1 == mrb->c->ci->argc) {
mrb_value obj;
SDL_RWops *rwops;
mrb_get_args(mrb, "o", &obj);
if (mrb_obj_is_kind_of(mrb, obj, mrb_class_get_under(mrb, mrb->object_class, "String"))) {
music = Mix_LoadMUS(RSTRING_PTR(obj));
} else if (mrb_obj_is_kind_of(mrb, obj, mrb_class_get_under(mrb, mod_SDL2, "RWops"))) {
rwops = mrb_sdl2_rwops_get_ptr(mrb, obj);
music = Mix_LoadMUS_RW(rwops, 0);
} else {
mrb_free(mrb, data);
mrb_raise(mrb, E_RUNTIME_ERROR, "unexpected type.");
}
} else if (2 == mrb->c->ci->argc) {
mrb_value rw;
mrb_int type;
SDL_RWops *rwops;
mrb_get_args(mrb, "oi", &rw, &type);
rwops = mrb_sdl2_rwops_get_ptr(mrb, rw);
music = Mix_LoadMUSType_RW(rwops, (Mix_MusicType) type, 0);
} else {
mrb_free(mrb, data);
mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong number of arguments.");
}
if (NULL == music) {
mrb_free(mrb, data);
mruby_sdl2_raise_error(mrb);
}
data->music = music;
DATA_PTR(self) = data;
DATA_TYPE(self) = &mrb_sdl2_mixer_music_data_type;
return self;
}
static void play_new_music()
{
music_start_time = 0; //reset status: no start time
want_new_music = true;
if(!preferences::music_on() || !mix_ok || !current_track.valid()) {
return;
}
const std::string& filename = current_track.file_path();
std::map<std::string,Mix_Music*>::const_iterator itor = music_cache.find(filename);
if(itor == music_cache.end()) {
LOG_AUDIO << "attempting to insert track '" << filename << "' into cache\n";
SDL_RWops *rwops = filesystem::load_RWops(filename);
Mix_Music* const music = Mix_LoadMUSType_RW(rwops, MUS_NONE, true); // SDL takes ownership of rwops
if(music == nullptr) {
ERR_AUDIO << "Could not load music file '" << filename << "': "
<< Mix_GetError() << "\n";
return;
}
itor = music_cache.insert(std::pair<std::string,Mix_Music*>(filename,music)).first;
last_track=current_track;
}
LOG_AUDIO << "Playing track '" << filename << "'\n";
int fading_time=current_track.ms_before();
if(no_fading)
{
fading_time=0;
}
const int res = Mix_FadeInMusic(itor->second, 1, fading_time);
if(res < 0)
{
ERR_AUDIO << "Could not play music: " << Mix_GetError() << " " << filename <<" " << std::endl;
}
want_new_music=false;
}
Mix_Music *Mix_LoadMUS_RW(SDL_RWops *rw)
{
return Mix_LoadMUSType_RW(rw, MUS_NONE, SDL_FALSE);
}
/* Load a music file */
Mix_Music *Mix_LoadMUS(const char *file)
{
SDL_RWops *rw;
Mix_Music *music;
Mix_MusicType type;
char *ext = strrchr(file, '.');
#ifdef CMD_MUSIC
if ( music_cmd ) {
/* Allocate memory for the music structure */
music = (Mix_Music *)SDL_malloc(sizeof(Mix_Music));
if ( music == NULL ) {
Mix_SetError("Out of memory");
return(NULL);
}
music->error = 0;
music->type = MUS_CMD;
music->data.cmd = MusicCMD_LoadSong(music_cmd, file);
if ( music->data.cmd == NULL ) {
SDL_free(music);
music == NULL;
}
return music;
}
#endif
rw = SDL_RWFromFile(file, "rb");
if ( rw == NULL ) {
Mix_SetError("Couldn't open '%s'", file);
return NULL;
}
/* Use the extension as a first guess on the file type */
type = MUS_NONE;
ext = strrchr(file, '.');
/* No need to guard these with #ifdef *_MUSIC stuff,
* since we simply call Mix_LoadMUSType_RW() later */
if ( ext ) {
++ext; /* skip the dot in the extension */
if ( MIX_string_equals(ext, "WAV") ) {
type = MUS_WAV;
} else if ( MIX_string_equals(ext, "MID") ||
MIX_string_equals(ext, "MIDI") ||
MIX_string_equals(ext, "KAR") ) {
type = MUS_MID;
} else if ( MIX_string_equals(ext, "OGG") ) {
type = MUS_OGG;
} else if ( MIX_string_equals(ext, "FLAC") ) {
type = MUS_FLAC;
} else if ( MIX_string_equals(ext, "MPG") ||
MIX_string_equals(ext, "MPEG") ||
MIX_string_equals(ext, "MP3") ||
MIX_string_equals(ext, "MAD") ) {
type = MUS_MP3;
}
}
if ( type == MUS_NONE ) {
type = detect_music_type(rw);
}
/* We need to know if a specific error occurs; if not, we'll set a
* generic one, so we clear the current one. */
Mix_SetError("");
music = Mix_LoadMUSType_RW(rw, type, SDL_TRUE);
if ( music == NULL && Mix_GetError()[0] == '\0' ) {
SDL_FreeRW(rw);
Mix_SetError("Couldn't open '%s'", file);
}
return music;
}
Mix_Music *Mix_LoadMUS_RW(SDL_RWops *src, int freesrc)
{
return Mix_LoadMUSType_RW(src, MUS_NONE, freesrc);
}
