/***************************************************************************** * Copyright (c) 2014 Ted John * OpenRCT2, an open source clone of Roller Coaster Tycoon 2. * * This file is part of OpenRCT2. * * OpenRCT2 is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * You should have received a copy of the GNU General Public License * along with this program. If not, see . *****************************************************************************/ extern "C" { #include "../config.h" #include "../platform/platform.h" #include "../localisation/localisation.h" #include "audio.h" } #include "mixer.h" Mixer gMixer; Source::~Source() { } unsigned long Source::GetSome(unsigned long offset, const uint8** data, unsigned long length) { if (offset >= Length()) { return 0; } unsigned long size = length; if (offset + length > Length()) { size = Length() - offset; } return Read(offset, data, size); } unsigned long Source::Length() { return length; } const AudioFormat& Source::Format() { return format; } Source_Null::Source_Null() { length = 0; } unsigned long Source_Null::Read(unsigned long offset, const uint8** data, unsigned long length) { return 0; } Source_Sample::Source_Sample() { data = 0; length = 0; issdlwav = false; } Source_Sample::~Source_Sample() { Unload(); } unsigned long Source_Sample::Read(unsigned long offset, const uint8** data, unsigned long length) { *data = &Source_Sample::data[offset]; return length; } bool Source_Sample::LoadWAV(const char* filename) { log_verbose("Source_Sample::LoadWAV(%s)", filename); Unload(); SDL_RWops* rw = SDL_RWFromFile(filename, "rb"); if (rw == NULL) { log_verbose("Error loading %s", filename); return false; } SDL_AudioSpec audiospec; memset(&audiospec, 0, sizeof(audiospec)); SDL_AudioSpec* spec = SDL_LoadWAV_RW(rw, false, &audiospec, &data, (Uint32*)&length); SDL_RWclose(rw); if (spec != NULL) { format.freq = spec->freq; format.format = spec->format; format.channels = spec->channels; issdlwav = true; } else { log_verbose("Error loading %s, unsupported WAV format", filename); return false; } return true; } bool Source_Sample::LoadCSS1(const char *filename, unsigned int offset) { log_verbose("Source_Sample::LoadCSS1(%s, %d)", filename, offset); Unload(); SDL_RWops* rw = SDL_RWFromFile(filename, "rb"); if (rw == NULL) { log_verbose("Unable to load %s", filename); return false; } Uint32 numsounds; SDL_RWread(rw, &numsounds, sizeof(numsounds), 1); if (offset > numsounds) { SDL_RWclose(rw); return false; } SDL_RWseek(rw, offset * 4, RW_SEEK_CUR); Uint32 soundoffset; SDL_RWread(rw, &soundoffset, sizeof(soundoffset), 1); SDL_RWseek(rw, soundoffset, RW_SEEK_SET); Uint32 soundsize; SDL_RWread(rw, &soundsize, sizeof(soundsize), 1); length = soundsize; struct WaveFormatEx { Uint16 encoding; Uint16 channels; Uint32 frequency; Uint32 byterate; Uint16 blockalign; Uint16 bitspersample; Uint16 extrasize; } waveformat; SDL_RWread(rw, &waveformat, sizeof(waveformat), 1); format.freq = waveformat.frequency; format.format = AUDIO_S16LSB; format.channels = waveformat.channels; data = new (std::nothrow) uint8[length]; if (!data) { log_verbose("Unable to allocate data"); SDL_RWclose(rw); return false; } SDL_RWread(rw, data, length, 1); SDL_RWclose(rw); return true; } void Source_Sample::Unload() { if (data) { if (issdlwav) { SDL_FreeWAV(data); } else { delete[] data; } data = 0; } issdlwav = false; length = 0; } bool Source_Sample::Convert(AudioFormat format) { if(Source_Sample::format.format != format.format || Source_Sample::format.channels != format.channels || Source_Sample::format.freq != format.freq){ SDL_AudioCVT cvt; if (SDL_BuildAudioCVT(&cvt, Source_Sample::format.format, Source_Sample::format.channels, Source_Sample::format.freq, format.format, format.channels, format.freq) < 0) { return false; } cvt.len = length; cvt.buf = (Uint8*)new uint8[cvt.len * cvt.len_mult]; memcpy(cvt.buf, data, length); if (SDL_ConvertAudio(&cvt) < 0) { delete[] cvt.buf; return false; } Unload(); data = cvt.buf; length = cvt.len_cvt; Source_Sample::format = format; return true; } return false; } Source_SampleStream::Source_SampleStream() { length = 0; rw = NULL; buffer = 0; buffersize = 0; } Source_SampleStream::~Source_SampleStream() { Unload(); } unsigned long Source_SampleStream::Read(unsigned long offset, const uint8** data, unsigned long length) { if (length > buffersize) { if (buffer) { delete[] buffer; } buffer = new (std::nothrow) uint8[length]; if (!buffer) { return 0; } buffersize = length; } Sint64 currentposition = SDL_RWtell(rw); if (currentposition == -1) { return 0; } if (currentposition - databegin != offset) { Sint64 newposition = SDL_RWseek(rw, databegin + offset, SEEK_SET); if (newposition == -1) { return 0; } currentposition = newposition; } *data = buffer; int read = SDL_RWread(rw, buffer, 1, length); if (read == -1) { return 0; } return read; } bool Source_SampleStream::LoadWAV(SDL_RWops* rw) { Unload(); if (rw == NULL) { return false; } Source_SampleStream::rw = rw; Uint32 chunk_id = SDL_ReadLE32(rw); const Uint32 RIFF = 0x46464952; if (chunk_id != RIFF) { log_verbose("Not a WAV file"); return false; } Uint32 chunk_size = SDL_ReadLE32(rw); Uint32 chunk_format = SDL_ReadLE32(rw); const Uint32 WAVE = 0x45564157; if (chunk_format != WAVE) { log_verbose("Not in WAVE format"); return false; } const Uint32 FMT = 0x20746D66; Uint32 fmtchunk_size = FindChunk(rw, FMT); if (!fmtchunk_size) { log_verbose("Could not find FMT chunk"); return false; } Uint64 chunkstart = SDL_RWtell(rw); struct WaveFormat { Uint16 encoding; Uint16 channels; Uint32 frequency; Uint32 byterate; Uint16 blockalign; Uint16 bitspersample; } waveformat; SDL_RWread(rw, &waveformat, sizeof(waveformat), 1); SDL_RWseek(rw, chunkstart + fmtchunk_size, RW_SEEK_SET); const Uint16 pcmformat = 0x0001; if (waveformat.encoding != pcmformat) { log_verbose("Not in proper format"); return false; } format.freq = waveformat.frequency; switch (waveformat.bitspersample) { case 8: format.format = AUDIO_U8; break; case 16: format.format = AUDIO_S16LSB; break; default: log_verbose("Invalid bits per sample"); return false; break; } format.channels = waveformat.channels; const Uint32 DATA = 0x61746164; Uint32 datachunk_size = FindChunk(rw, DATA); if (!datachunk_size) { log_verbose("Could not find DATA chunk"); return false; } length = datachunk_size; databegin = SDL_RWtell(rw); return true; } Uint32 Source_SampleStream::FindChunk(SDL_RWops* rw, Uint32 wanted_id) { Uint32 subchunk_id = SDL_ReadLE32(rw); Uint32 subchunk_size = SDL_ReadLE32(rw); if (subchunk_id == wanted_id) { return subchunk_size; } const Uint32 FACT = 0x74636166; const Uint32 LIST = 0x5453494c; const Uint32 BEXT = 0x74786562; const Uint32 JUNK = 0x4B4E554A; while (subchunk_id == FACT || subchunk_id == LIST || subchunk_id == BEXT || subchunk_id == JUNK) { SDL_RWseek(rw, subchunk_size, RW_SEEK_CUR); subchunk_id = SDL_ReadLE32(rw); subchunk_size = SDL_ReadLE32(rw); if (subchunk_id == wanted_id) { return subchunk_size; } } return 0; } void Source_SampleStream::Unload() { if (rw) { SDL_RWclose(rw); rw = NULL; } length = 0; if (buffer) { delete[] buffer; buffer = 0; } buffersize = 0; } Channel::Channel() { resampler = 0; SetRate(1); SetVolume(SDL_MIX_MAXVOLUME); oldvolume = 0; oldvolume_l = 0; oldvolume_r = 0; SetPan(0.5f); done = true; stopping = false; source = 0; deletesourceondone = false; group = MIXER_GROUP_NONE; } Channel::~Channel() { if (resampler) { speex_resampler_destroy(resampler); resampler = 0; } if (deletesourceondone) { delete source; } } void Channel::Play(Source& source, int loop = MIXER_LOOP_NONE) { Channel::source = &source; Channel::loop = loop; offset = 0; done = false; } void Channel::SetRate(double rate) { Channel::rate = rate; if (Channel::rate < 0.001) { Channel::rate = 0.001; } } void Channel::SetVolume(int volume) { Channel::volume = volume; if (volume > SDL_MIX_MAXVOLUME) { Channel::volume = SDL_MIX_MAXVOLUME; } if (volume < 0) { Channel::volume = 0; } } void Channel::SetPan(float pan) { Channel::pan = pan; if (pan > 1) { Channel::pan = 1; } if (pan < 0) { Channel::pan = 0; } double decibels = (abs(Channel::pan - 0.5) * 2.0) * 100.0; double attenuation = pow(10, decibels / 20.0); if (Channel::pan <= 0.5) { volume_l = 1.0; volume_r = float(1.0 / attenuation); } else { volume_r = 1.0; volume_l = float(1.0 / attenuation); } } bool Channel::IsPlaying() { return !done; } unsigned long Channel::GetOffset() { return offset; } bool Channel::SetOffset(unsigned long offset) { if (source && offset < source->Length()) { int samplesize = source->Format().channels * source->Format().BytesPerSample(); Channel::offset = (offset / samplesize) * samplesize; return true; } return false; } void Channel::SetGroup(int group) { Channel::group = group; } Mixer::Mixer() { effectbuffer = 0; volume = 1; for (int i = 0; i < countof(css1sources); i++) { css1sources[i] = 0; } for (int i = 0; i < countof(musicsources); i++) { musicsources[i] = 0; } } void Mixer::Init(const char* device) { Close(); SDL_AudioSpec want, have; SDL_zero(want); want.freq = 44100; want.format = AUDIO_S16SYS; want.channels = 2; want.samples = 1024; want.callback = Callback; want.userdata = this; deviceid = SDL_OpenAudioDevice(device, 0, &want, &have, 0); format.format = have.format; format.channels = have.channels; format.freq = have.freq; const char* filename = get_file_path(PATH_ID_CSS1); for (int i = 0; i < countof(css1sources); i++) { Source_Sample* source_sample = new Source_Sample; if (source_sample->LoadCSS1(filename, i)) { source_sample->Convert(format); // convert to audio output format, saves some cpu usage but requires a bit more memory, optional css1sources[i] = source_sample; } else { css1sources[i] = &source_null; delete source_sample; } } effectbuffer = new uint8[(have.samples * format.BytesPerSample() * format.channels)]; SDL_PauseAudioDevice(deviceid, 0); } void Mixer::Close() { Lock(); while (channels.begin() != channels.end()) { delete *(channels.begin()); channels.erase(channels.begin()); } Unlock(); SDL_CloseAudioDevice(deviceid); for (int i = 0; i < countof(css1sources); i++) { if (css1sources[i] && css1sources[i] != &source_null) { delete css1sources[i]; css1sources[i] = 0; } } for (int i = 0; i < countof(musicsources); i++) { if (musicsources[i] && musicsources[i] != &source_null) { delete musicsources[i]; musicsources[i] = 0; } } if (effectbuffer) { delete[] effectbuffer; effectbuffer = 0; } } void Mixer::Lock() { SDL_LockAudioDevice(deviceid); } void Mixer::Unlock() { SDL_UnlockAudioDevice(deviceid); } Channel* Mixer::Play(Source& source, int loop, bool deleteondone, bool deletesourceondone) { Lock(); Channel* newchannel = new (std::nothrow) Channel; if (newchannel) { newchannel->Play(source, loop); newchannel->deleteondone = deleteondone; newchannel->deletesourceondone = deletesourceondone; channels.push_back(newchannel); } Unlock(); return newchannel; } void Mixer::Stop(Channel& channel) { Lock(); channel.stopping = true; Unlock(); } bool Mixer::LoadMusic(int pathid) { if (pathid >= countof(musicsources)) { return false; } if (!musicsources[pathid]) { const char* filename = get_file_path(pathid); Source_Sample* source_sample = new Source_Sample; if (source_sample->LoadWAV(filename)) { musicsources[pathid] = source_sample; return true; } else { delete source_sample; musicsources[pathid] = &source_null; return false; } } else { return true; } } void Mixer::SetVolume(float volume) { Mixer::volume = volume; } void SDLCALL Mixer::Callback(void* arg, uint8* stream, int length) { Mixer* mixer = (Mixer*)arg; memset(stream, 0, length); std::list::iterator i = mixer->channels.begin(); while (i != mixer->channels.end()) { mixer->MixChannel(*(*i), stream, length); if (((*i)->done && (*i)->deleteondone) || (*i)->stopping) { delete (*i); i = mixer->channels.erase(i); } else { i++; } } } void Mixer::MixChannel(Channel& channel, uint8* data, int length) { if (channel.source && channel.source->Length() > 0 && !channel.done && gConfigSound.sound) { AudioFormat streamformat = channel.source->Format(); int loaded = 0; SDL_AudioCVT cvt; cvt.len_ratio = 1; do { int samplesize = format.channels * format.BytesPerSample(); int samples = length / samplesize; int samplesloaded = loaded / samplesize; double rate = 1; if (format.format == AUDIO_S16SYS) { rate = channel.rate; } int samplestoread = (int)((samples - samplesloaded) * rate); int lengthloaded = 0; if (channel.offset < channel.source->Length()) { bool mustconvert = false; if (MustConvert(*channel.source)) { if (SDL_BuildAudioCVT(&cvt, streamformat.format, streamformat.channels, streamformat.freq, Mixer::format.format, Mixer::format.channels, Mixer::format.freq) == -1) { break; } mustconvert = true; } const uint8* datastream = 0; int toread = (int)(samplestoread / cvt.len_ratio) * samplesize; int readfromstream = (channel.source->GetSome(channel.offset, &datastream, toread)); if (readfromstream == 0) { break; } uint8* dataconverted = 0; const uint8* tomix = 0; if (mustconvert) { // tofix: there seems to be an issue with converting audio using SDL_ConvertAudio in the callback vs preconverted, can cause pops and static depending on sample rate and channels if (Convert(cvt, datastream, readfromstream, &dataconverted)) { tomix = dataconverted; lengthloaded = cvt.len_cvt; } else { break; } } else { tomix = datastream; lengthloaded = readfromstream; } bool effectbufferloaded = false; if (rate != 1 && format.format == AUDIO_S16SYS) { int in_len = (int)((double)lengthloaded / samplesize); int out_len = samples; if (!channel.resampler) { channel.resampler = speex_resampler_init(format.channels, format.freq, format.freq, 0, 0); } if (readfromstream == toread) { // use buffer lengths for conversion ratio so that it fits exactly speex_resampler_set_rate(channel.resampler, in_len, samples - samplesloaded); } else { // reached end of stream so we cant use buffer length as resampling ratio speex_resampler_set_rate(channel.resampler, format.freq, (int)(format.freq * (1 / rate))); } speex_resampler_process_interleaved_int(channel.resampler, (const spx_int16_t*)tomix, (spx_uint32_t*)&in_len, (spx_int16_t*)effectbuffer, (spx_uint32_t*)&out_len); effectbufferloaded = true; tomix = effectbuffer; lengthloaded = (out_len * samplesize); } if (channel.pan != 0.5f && format.channels == 2) { if (!effectbufferloaded) { memcpy(effectbuffer, tomix, lengthloaded); effectbufferloaded = true; tomix = effectbuffer; } switch (format.format) { case AUDIO_S16SYS: EffectPanS16(channel, (sint16*)effectbuffer, lengthloaded / samplesize); break; case AUDIO_U8: EffectPanU8(channel, (uint8*)effectbuffer, lengthloaded / samplesize); break; } } int mixlength = lengthloaded; if (loaded + mixlength > length) { mixlength = length - loaded; } float volumeadjust = volume; volumeadjust *= (gConfigSound.master_volume / 100.0f); if (channel.group == MIXER_GROUP_MUSIC) { volumeadjust *= (gConfigSound.music_volume / 100.0f); } int startvolume = (int)(channel.oldvolume * volumeadjust); int endvolume = (int)(channel.volume * volumeadjust); if (channel.stopping) { endvolume = 0; } int mixvolume = (int)(channel.volume * volumeadjust); if (startvolume != endvolume) { // fade between volume levels to smooth out sound and minimize clicks from sudden volume changes if (!effectbufferloaded) { memcpy(effectbuffer, tomix, lengthloaded); effectbufferloaded = true; tomix = effectbuffer; } mixvolume = SDL_MIX_MAXVOLUME; // set to max since we are adjusting the volume ourselves int fadelength = mixlength / format.BytesPerSample(); switch (format.format) { case AUDIO_S16SYS: EffectFadeS16((sint16*)effectbuffer, fadelength, startvolume, endvolume); break; case AUDIO_U8: EffectFadeU8((uint8*)effectbuffer, fadelength, startvolume, endvolume); break; } } SDL_MixAudioFormat(&data[loaded], tomix, format.format, mixlength, mixvolume); if (dataconverted) { delete[] dataconverted; } channel.offset += readfromstream; } loaded += lengthloaded; if (channel.loop != 0 && channel.offset >= channel.source->Length()) { if (channel.loop != -1) { channel.loop--; } channel.offset = 0; } } while(loaded < length && channel.loop != 0 && !channel.stopping); channel.oldvolume = channel.volume; channel.oldvolume_l = channel.volume_l; channel.oldvolume_r = channel.volume_r; if (channel.loop == 0 && channel.offset >= channel.source->Length()) { channel.done = true; } } } void Mixer::EffectPanS16(Channel& channel, sint16* data, int length) { for (int i = 0; i < length * 2; i += 2) { float t = (float)i / (length * 2); data[i] = (sint16)(data[i] * ((1.0 - t) * channel.oldvolume_l + t * channel.volume_l)); data[i + 1] = (sint16)(data[i + 1] * ((1.0 - t) * channel.oldvolume_r + t * channel.volume_r)); } } void Mixer::EffectPanU8(Channel& channel, uint8* data, int length) { for (int i = 0; i < length * 2; i += 2) { float t = (float)i / (length * 2); data[i] = (uint8)(data[i] * ((1.0 - t) * channel.oldvolume_l + t * channel.volume_l)); data[i + 1] = (uint8)(data[i + 1] * ((1.0 - t) * channel.oldvolume_r + t * channel.volume_r)); } } void Mixer::EffectFadeS16(sint16* data, int length, int startvolume, int endvolume) { float startvolume_f = (float)startvolume / SDL_MIX_MAXVOLUME; float endvolume_f = (float)endvolume / SDL_MIX_MAXVOLUME; for (int i = 0; i < length; i++) { float t = (float)i / length; data[i] = (sint16)(data[i] * ((1 - t) * startvolume_f + t * endvolume_f)); } } void Mixer::EffectFadeU8(uint8* data, int length, int startvolume, int endvolume) { float startvolume_f = (float)startvolume / SDL_MIX_MAXVOLUME; float endvolume_f = (float)endvolume / SDL_MIX_MAXVOLUME; for (int i = 0; i < length; i++) { float t = (float)i / length; data[i] = (uint8)(data[i] * ((1 - t) * startvolume_f + t * endvolume_f)); } } bool Mixer::MustConvert(Source& source) { const AudioFormat sourceformat = source.Format(); if (sourceformat.format != format.format || sourceformat.channels != format.channels || sourceformat.freq != format.freq) { return true; } return false; } bool Mixer::Convert(SDL_AudioCVT& cvt, const uint8* data, unsigned long length, uint8** dataout) { if (length == 0 || cvt.len_mult == 0) { return false; } cvt.len = length; cvt.buf = (Uint8*)new uint8[cvt.len * cvt.len_mult]; memcpy(cvt.buf, data, length); if (SDL_ConvertAudio(&cvt) < 0) { delete[] cvt.buf; return false; } *dataout = cvt.buf; return true; } void Mixer_Init(const char* device) { gMixer.Init(device); } void* Mixer_Play_Effect(int id, int loop, int volume, float pan, double rate, int deleteondone) { if (!gConfigSound.sound) { return 0; } if (id >= countof(gMixer.css1sources)) { return 0; } gMixer.Lock(); Channel* channel = gMixer.Play(*gMixer.css1sources[id], loop, deleteondone != 0, false); if (channel) { channel->SetVolume(volume); channel->SetPan(pan); channel->SetRate(rate); } gMixer.Unlock(); return channel; } void Mixer_Stop_Channel(void* channel) { gMixer.Stop(*(Channel*)channel); } void Mixer_Channel_Volume(void* channel, int volume) { gMixer.Lock(); ((Channel*)channel)->SetVolume(volume); gMixer.Unlock(); } void Mixer_Channel_Pan(void* channel, float pan) { gMixer.Lock(); ((Channel*)channel)->SetPan(pan); gMixer.Unlock(); } void Mixer_Channel_Rate(void* channel, double rate) { gMixer.Lock(); ((Channel*)channel)->SetRate(rate); gMixer.Unlock(); } int Mixer_Channel_IsPlaying(void* channel) { return ((Channel*)channel)->IsPlaying(); } unsigned long Mixer_Channel_GetOffset(void* channel) { return ((Channel*)channel)->GetOffset(); } int Mixer_Channel_SetOffset(void* channel, unsigned long offset) { return ((Channel*)channel)->SetOffset(offset); } void Mixer_Channel_SetGroup(void* channel, int group) { ((Channel*)channel)->SetGroup(group); } void* Mixer_Play_Music(int pathid, int loop, int streaming) { if (!gConfigSound.sound) { return 0; } if (streaming) { const utf8 *filename = get_file_path(pathid); SDL_RWops* rw = SDL_RWFromFile(filename, "rb"); if (rw == NULL) { return 0; } Source_SampleStream* source_samplestream = new Source_SampleStream; if (source_samplestream->LoadWAV(rw)) { Channel* channel = gMixer.Play(*source_samplestream, loop, false, true); if (!channel) { delete source_samplestream; } else { channel->SetGroup(MIXER_GROUP_MUSIC); } return channel; } else { delete source_samplestream; return 0; } } else { if (gMixer.LoadMusic(pathid)) { Channel* channel = gMixer.Play(*gMixer.musicsources[pathid], MIXER_LOOP_INFINITE, false, false); if (channel) { channel->SetGroup(MIXER_GROUP_MUSIC); } return channel; } } return 0; } void Mixer_SetVolume(float volume) { gMixer.SetVolume(volume); }