293 lines
8.6 KiB
C++
293 lines
8.6 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program 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 <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "common/scummsys.h"
|
|
|
|
#if defined(SDL_BACKEND)
|
|
|
|
#include "backends/mixer/sdl/sdl-mixer.h"
|
|
#include "common/debug.h"
|
|
#include "common/system.h"
|
|
#include "common/config-manager.h"
|
|
#include "common/textconsole.h"
|
|
|
|
#if defined(PLAYSTATION3) || defined(PSP2) || defined(NINTENDO_SWITCH)
|
|
#define SAMPLES_PER_SEC 48000
|
|
#elif defined(__MINT__)
|
|
#define SAMPLES_PER_SEC 49170
|
|
#else
|
|
#define SAMPLES_PER_SEC 44100
|
|
#endif
|
|
|
|
SdlMixerManager::SdlMixerManager() : _isSubsystemInitialized(false), _isAudioOpen(false) {
|
|
}
|
|
|
|
SdlMixerManager::~SdlMixerManager() {
|
|
if (_mixer)
|
|
_mixer->setReady(false);
|
|
|
|
#if SDL_VERSION_ATLEAST(3, 0, 0)
|
|
SDL_CloseAudioDevice(SDL_GetAudioStreamDevice(_stream));
|
|
SDL_DestroyAudioStream(_stream);
|
|
#else
|
|
if (_isAudioOpen)
|
|
SDL_CloseAudio();
|
|
#endif
|
|
|
|
if (_isSubsystemInitialized)
|
|
SDL_QuitSubSystem(SDL_INIT_AUDIO);
|
|
}
|
|
|
|
void SdlMixerManager::init() {
|
|
bool isDisabled = ConfMan.hasKey("disable_sdl_audio") && ConfMan.getBool("disable_sdl_audio");
|
|
|
|
if (isDisabled) {
|
|
warning("SDL audio subsystem was forcibly disabled by disable_sdl_audio option");
|
|
return;
|
|
}
|
|
|
|
// Get the desired audio specs
|
|
SDL_AudioSpec desired = getAudioSpec(SAMPLES_PER_SEC);
|
|
|
|
// Start SDL Audio subsystem
|
|
#if SDL_VERSION_ATLEAST(3, 0, 0)
|
|
if (!SDL_InitSubSystem(SDL_INIT_AUDIO)) {
|
|
#else
|
|
if (SDL_InitSubSystem(SDL_INIT_AUDIO) == -1) {
|
|
#endif
|
|
warning("Could not initialize SDL audio subsystem: %s", SDL_GetError());
|
|
return;
|
|
}
|
|
|
|
_isSubsystemInitialized = true;
|
|
|
|
#if SDL_VERSION_ATLEAST(2, 0, 0)
|
|
const char *sdlDriverName = SDL_GetCurrentAudioDriver();
|
|
#else
|
|
const int maxNameLen = 20;
|
|
char sdlDriverName[maxNameLen];
|
|
sdlDriverName[0] = '\0';
|
|
SDL_AudioDriverName(sdlDriverName, maxNameLen);
|
|
#endif
|
|
debug(1, "Using SDL Audio Driver \"%s\"", sdlDriverName);
|
|
|
|
#if SDL_VERSION_ATLEAST(3, 0, 0)
|
|
_isAudioOpen = true;
|
|
_obtained = desired;
|
|
#else
|
|
// Needed as SDL_OpenAudio as of SDL-1.2.14 mutates fields in
|
|
// "desired" if used directly.
|
|
SDL_AudioSpec fmt = desired;
|
|
|
|
// Start SDL audio with the desired specs
|
|
if (SDL_OpenAudio(&fmt, &_obtained) != 0) {
|
|
warning("Could not open audio device: %s", SDL_GetError());
|
|
return;
|
|
}
|
|
|
|
_isAudioOpen = true;
|
|
|
|
// The obtained sample format is not supported by the mixer, call
|
|
// SDL_OpenAudio again with NULL as the second argument to force
|
|
// SDL to do resampling to the desired audio spec.
|
|
if (_obtained.format != desired.format) {
|
|
debug(1, "SDL mixer sound format: %d differs from desired: %d", _obtained.format, desired.format);
|
|
SDL_CloseAudio();
|
|
|
|
if (SDL_OpenAudio(&fmt, nullptr) != 0) {
|
|
warning("Could not open audio device: %s", SDL_GetError());
|
|
return;
|
|
}
|
|
|
|
_obtained = desired;
|
|
}
|
|
#endif
|
|
|
|
debug(1, "Output sample rate: %d Hz", _obtained.freq);
|
|
if (_obtained.freq != desired.freq)
|
|
warning("SDL mixer output sample rate: %d differs from desired: %d", _obtained.freq, desired.freq);
|
|
|
|
#if !SDL_VERSION_ATLEAST(3, 0, 0)
|
|
debug(1, "Output buffer size: %d samples", _obtained.samples);
|
|
if (_obtained.samples != desired.samples)
|
|
warning("SDL mixer output buffer size: %d differs from desired: %d", _obtained.samples, desired.samples);
|
|
|
|
debug(1, "Output channels: %d", _obtained.channels);
|
|
if (_obtained.channels != 1 && _obtained.channels != 2)
|
|
error("SDL mixer output requires mono or stereo output device");
|
|
#endif
|
|
|
|
int desiredSamples = 0;
|
|
#if SDL_VERSION_ATLEAST(3, 0, 0)
|
|
SDL_GetAudioDeviceFormat(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &_obtained, &desiredSamples);
|
|
#else
|
|
desiredSamples = desired.samples;
|
|
#endif
|
|
|
|
_mixer = new Audio::MixerImpl(_obtained.freq, _obtained.channels >= 2, desiredSamples);
|
|
assert(_mixer);
|
|
_mixer->setReady(true);
|
|
|
|
startAudio();
|
|
}
|
|
|
|
#if !SDL_VERSION_ATLEAST(3, 0, 0)
|
|
static uint32 roundDownPowerOfTwo(uint32 samples) {
|
|
// Public domain code from Sean Eron Anderson
|
|
// https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
|
|
uint32 rounded = samples;
|
|
--rounded;
|
|
rounded |= rounded >> 1;
|
|
rounded |= rounded >> 2;
|
|
rounded |= rounded >> 4;
|
|
rounded |= rounded >> 8;
|
|
rounded |= rounded >> 16;
|
|
++rounded;
|
|
|
|
if (rounded != samples)
|
|
rounded >>= 1;
|
|
|
|
return rounded;
|
|
}
|
|
#endif
|
|
|
|
SDL_AudioSpec SdlMixerManager::getAudioSpec(uint32 outputRate) {
|
|
SDL_AudioSpec desired;
|
|
|
|
// There was once a GUI option for this, which was removed. Configurability
|
|
// is retained for advanced users only who wish to use the commandline
|
|
// option (--output-rate) or modify their ScummVM config file directly.
|
|
uint32 freq = 0;
|
|
if (ConfMan.hasKey("output_rate"))
|
|
freq = ConfMan.getInt("output_rate");
|
|
if (freq <= 0)
|
|
freq = outputRate;
|
|
|
|
uint32 channels = 2;
|
|
if (ConfMan.hasKey("output_channels"))
|
|
channels = ConfMan.getInt("output_channels");
|
|
if (channels > 2 || channels <= 0)
|
|
channels = 2;
|
|
|
|
// One SDL "sample" is a complete audio frame (i.e. all channels = 1 sample)
|
|
uint32 samples = 0;
|
|
|
|
// Different games and host systems have different performance
|
|
// characteristics which are not easily measured, so allow advanced users to
|
|
// tweak their audio buffer size if they are experience excess latency or
|
|
// drop-outs by setting this value in their ScummVM config file directly
|
|
if (ConfMan.hasKey("audio_buffer_size", Common::ConfigManager::kApplicationDomain))
|
|
samples = ConfMan.getInt("audio_buffer_size", Common::ConfigManager::kApplicationDomain);
|
|
|
|
// 256 is an arbitrary minimum; 32768 is the largest power-of-two value
|
|
// representable with uint16
|
|
if (samples < 256 || samples > 32768)
|
|
// By default, hold no more than 45ms worth of samples to avoid
|
|
// perceptable audio lag (ATSC IS-191). For reference, DOSBox (as of Sep
|
|
// 2017) uses a buffer size of 1024 samples by default for a 16-bit
|
|
// stereo 44kHz mixer, which happens to be the next lowest power of two
|
|
// below 45ms.
|
|
samples = freq / (1000.0 / 45);
|
|
|
|
memset(&desired, 0, sizeof(desired));
|
|
desired.freq = freq;
|
|
desired.channels = channels;
|
|
#if SDL_VERSION_ATLEAST(3, 0, 0)
|
|
desired.format = SDL_AUDIO_S16;
|
|
#else
|
|
desired.format = AUDIO_S16SYS;
|
|
desired.samples = roundDownPowerOfTwo(samples);
|
|
desired.callback = sdlCallback;
|
|
desired.userdata = this;
|
|
#endif
|
|
|
|
return desired;
|
|
}
|
|
|
|
void SdlMixerManager::startAudio() {
|
|
// Start the sound system
|
|
#if SDL_VERSION_ATLEAST(3, 0, 0)
|
|
_stream = SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &_obtained, sdlCallback, this);
|
|
if (_stream)
|
|
SDL_ResumeAudioDevice(SDL_GetAudioStreamDevice(_stream));
|
|
#else
|
|
SDL_PauseAudio(0);
|
|
#endif
|
|
}
|
|
|
|
void SdlMixerManager::callbackHandler(byte *samples, int len) {
|
|
assert(_mixer);
|
|
_mixer->mixCallback(samples, len);
|
|
}
|
|
|
|
#if SDL_VERSION_ATLEAST(3, 0, 0)
|
|
void SdlMixerManager::sdlCallback(void *userdata, SDL_AudioStream *stream, int additional_amount, int total_amount) {
|
|
if (additional_amount > 0) {
|
|
Uint8 *data = SDL_stack_alloc(Uint8, additional_amount);
|
|
if (data) {
|
|
SdlMixerManager *manager = (SdlMixerManager *)userdata;
|
|
assert(manager);
|
|
manager->callbackHandler(data, additional_amount);
|
|
SDL_PutAudioStreamData(stream, data, additional_amount);
|
|
SDL_stack_free(data);
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
void SdlMixerManager::sdlCallback(void *this_, byte *samples, int len) {
|
|
SdlMixerManager *manager = (SdlMixerManager *)this_;
|
|
assert(manager);
|
|
|
|
manager->callbackHandler(samples, len);
|
|
}
|
|
#endif
|
|
|
|
void SdlMixerManager::suspendAudio() {
|
|
#if SDL_VERSION_ATLEAST(3, 0, 0)
|
|
SDL_CloseAudioDevice(SDL_GetAudioStreamDevice(_stream));
|
|
SDL_DestroyAudioStream(_stream);
|
|
#else
|
|
SDL_CloseAudio();
|
|
#endif
|
|
_audioSuspended = true;
|
|
}
|
|
|
|
int SdlMixerManager::resumeAudio() {
|
|
if (!_audioSuspended)
|
|
return -2;
|
|
#if SDL_VERSION_ATLEAST(3, 0, 0)
|
|
_stream = SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &_obtained, sdlCallback, this);
|
|
if(!_stream)
|
|
return -1;
|
|
if (SDL_ResumeAudioDevice(SDL_GetAudioStreamDevice(_stream)))
|
|
return -1;
|
|
#else
|
|
if (SDL_OpenAudio(&_obtained, nullptr) < 0) {
|
|
return -1;
|
|
}
|
|
SDL_PauseAudio(0);
|
|
#endif
|
|
_audioSuspended = false;
|
|
return 0;
|
|
}
|
|
|
|
#endif
|