dolphin-emu/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-10-07 07:43:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

AudioCommon: Migrate logging over to fmt

Browse Source 
printf specifiers, begone!
This commit is contained in:
Lioncash 2020-10-21 13:32:25 -04:00
parent 09e87b79f1
commit 22a79289d3
9 changed files with 69 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
Source/Core/AudioCommon/AlsaSoundStream.cpp
View File

@ -64,7 +64,7 @@ void AlsaSound::SoundLoop()
}
else if (rc < 0)
{
ERROR_LOG(AUDIO, "writei fail: %s", snd_strerror(rc));
ERROR_LOG_FMT(AUDIO, "writei fail: {}", snd_strerror(rc));
}
}
if (m_thread_status.load() == ALSAThreadStatus::PAUSED)
@ -107,7 +107,7 @@ bool AlsaSound::AlsaInit()
err = snd_pcm_open(&handle, "default", SND_PCM_STREAM_PLAYBACK, 0);
if (err < 0)
{
ERROR_LOG(AUDIO, "Audio open error: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "Audio open error: {}", snd_strerror(err));
return false;
}
@ -116,21 +116,21 @@ bool AlsaSound::AlsaInit()
err = snd_pcm_hw_params_any(handle, hwparams);
if (err < 0)
{
ERROR_LOG(AUDIO, "Broken configuration for this PCM: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "Broken configuration for this PCM: {}", snd_strerror(err));
return false;
}
err = snd_pcm_hw_params_set_access(handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0)
{
ERROR_LOG(AUDIO, "Access type not available: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "Access type not available: {}", snd_strerror(err));
return false;
}
err = snd_pcm_hw_params_set_format(handle, hwparams, SND_PCM_FORMAT_S16_LE);
if (err < 0)
{
ERROR_LOG(AUDIO, "Sample format not available: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "Sample format not available: {}", snd_strerror(err));
return false;
}
@ -138,14 +138,14 @@ bool AlsaSound::AlsaInit()
err = snd_pcm_hw_params_set_rate_near(handle, hwparams, &sample_rate, &dir);
if (err < 0)
{
ERROR_LOG(AUDIO, "Rate not available: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "Rate not available: {}", snd_strerror(err));
return false;
}
err = snd_pcm_hw_params_set_channels(handle, hwparams, CHANNEL_COUNT);
if (err < 0)
{
ERROR_LOG(AUDIO, "Channels count not available: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "Channels count not available: {}", snd_strerror(err));
return false;
}
@ -153,7 +153,7 @@ bool AlsaSound::AlsaInit()
err = snd_pcm_hw_params_set_periods_max(handle, hwparams, &periods, &dir);
if (err < 0)
{
ERROR_LOG(AUDIO, "Cannot set maximum periods per buffer: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "Cannot set maximum periods per buffer: {}", snd_strerror(err));
return false;
}
@ -161,28 +161,28 @@ bool AlsaSound::AlsaInit()
err = snd_pcm_hw_params_set_buffer_size_max(handle, hwparams, &buffer_size_max);
if (err < 0)
{
ERROR_LOG(AUDIO, "Cannot set maximum buffer size: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "Cannot set maximum buffer size: {}", snd_strerror(err));
return false;
}
err = snd_pcm_hw_params(handle, hwparams);
if (err < 0)
{
ERROR_LOG(AUDIO, "Unable to install hw params: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "Unable to install hw params: {}", snd_strerror(err));
return false;
}
err = snd_pcm_hw_params_get_buffer_size(hwparams, &buffer_size);
if (err < 0)
{
ERROR_LOG(AUDIO, "Cannot get buffer size: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "Cannot get buffer size: {}", snd_strerror(err));
return false;
}
err = snd_pcm_hw_params_get_periods_max(hwparams, &periods, &dir);
if (err < 0)
{
ERROR_LOG(AUDIO, "Cannot get periods: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "Cannot get periods: {}", snd_strerror(err));
return false;
}
@ -195,41 +195,41 @@ bool AlsaSound::AlsaInit()
// it is probably a bad idea to try to send more than one buffer of data
if ((unsigned int)frames_to_deliver > buffer_size)
frames_to_deliver = buffer_size;
NOTICE_LOG(AUDIO,
"ALSA gave us a %ld sample \"hardware\" buffer with %d periods. Will send %d "
"samples per fragments.",
buffer_size, periods, frames_to_deliver);
NOTICE_LOG_FMT(AUDIO,
"ALSA gave us a {} sample \"hardware\" buffer with {} periods. Will send {} "
"samples per fragments.",
buffer_size, periods, frames_to_deliver);
snd_pcm_sw_params_alloca(&swparams);
err = snd_pcm_sw_params_current(handle, swparams);
if (err < 0)
{
ERROR_LOG(AUDIO, "cannot init sw params: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "cannot init sw params: {}", snd_strerror(err));
return false;
}
err = snd_pcm_sw_params_set_start_threshold(handle, swparams, 0U);
if (err < 0)
{
ERROR_LOG(AUDIO, "cannot set start thresh: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "cannot set start thresh: {}", snd_strerror(err));
return false;
}
err = snd_pcm_sw_params(handle, swparams);
if (err < 0)
{
ERROR_LOG(AUDIO, "cannot set sw params: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "cannot set sw params: {}", snd_strerror(err));
return false;
}
err = snd_pcm_prepare(handle);
if (err < 0)
{
ERROR_LOG(AUDIO, "Unable to prepare: %s", snd_strerror(err));
ERROR_LOG_FMT(AUDIO, "Unable to prepare: {}", snd_strerror(err));
return false;
}
NOTICE_LOG(AUDIO, "ALSA successfully initialized.");
NOTICE_LOG_FMT(AUDIO, "ALSA successfully initialized.");
return true;
}

15
Source/Core/AudioCommon/AudioCommon.cpp
View File

@ -54,16 +54,15 @@ void InitSoundStream()
if (!g_sound_stream)
{
WARN_LOG(AUDIO, "Unknown backend %s, using %s instead.", backend.c_str(),
GetDefaultSoundBackend().c_str());
WARN_LOG_FMT(AUDIO, "Unknown backend {}, using {} instead.", backend, GetDefaultSoundBackend());
backend = GetDefaultSoundBackend();
g_sound_stream = CreateSoundStreamForBackend(GetDefaultSoundBackend());
}
if (!g_sound_stream || !g_sound_stream->Init())
{
WARN_LOG(AUDIO, "Could not initialize backend %s, using %s instead.", backend.c_str(),
BACKEND_NULLSOUND);
WARN_LOG_FMT(AUDIO, "Could not initialize backend {}, using {} instead.", backend,
BACKEND_NULLSOUND);
g_sound_stream = std::make_unique<NullSound>();
g_sound_stream->Init();
}
@ -83,7 +82,7 @@ void InitSoundStream()
void ShutdownSoundStream()
{
INFO_LOG(AUDIO, "Shutting down sound stream");
INFO_LOG_FMT(AUDIO, "Shutting down sound stream");
if (SConfig::GetInstance().m_DumpAudio && s_audio_dump_start)
StopAudioDump();
@ -91,7 +90,7 @@ void ShutdownSoundStream()
SetSoundStreamRunning(false);
g_sound_stream.reset();
INFO_LOG(AUDIO, "Done shutting down sound stream");
INFO_LOG_FMT(AUDIO, "Done shutting down sound stream");
}
std::string GetDefaultSoundBackend()
@ -180,9 +179,9 @@ void SetSoundStreamRunning(bool running)
if (g_sound_stream->SetRunning(running))
return;
if (running)
ERROR_LOG(AUDIO, "Error starting stream.");
ERROR_LOG_FMT(AUDIO, "Error starting stream.");
else
ERROR_LOG(AUDIO, "Error stopping stream.");
ERROR_LOG_FMT(AUDIO, "Error stopping stream.");
}
void SendAIBuffer(const short* samples, unsigned int num_samples)

4
Source/Core/AudioCommon/AudioStretcher.cpp
View File

@ -58,8 +58,8 @@ void AudioStretcher::ProcessSamples(const short* in, unsigned int num_in, unsign
m_stretch_ratio = std::max(m_stretch_ratio, 0.1);
m_sound_touch.setTempo(m_stretch_ratio);
DEBUG_LOG(AUDIO, "Audio stretching: samples:%u/%u ratio:%f backlog:%f gain: %f", num_in, num_out,
m_stretch_ratio, backlog_fullness, lpf_gain);
DEBUG_LOG_FMT(AUDIO, "Audio stretching: samples:{}/{} ratio:{} backlog:{} gain: {}", num_in,
num_out, m_stretch_ratio, backlog_fullness, lpf_gain);
m_sound_touch.putSamples(in, num_in);
}

4
Source/Core/AudioCommon/CubebStream.cpp
View File

@ -56,8 +56,8 @@ bool CubebStream::Init()
u32 minimum_latency = 0;
if (cubeb_get_min_latency(m_ctx.get(), &params, &minimum_latency) != CUBEB_OK)
ERROR_LOG(AUDIO, "Error getting minimum latency");
INFO_LOG(AUDIO, "Minimum latency: %i frames", minimum_latency);
ERROR_LOG_FMT(AUDIO, "Error getting minimum latency");
INFO_LOG_FMT(AUDIO, "Minimum latency: {} frames", minimum_latency);
return cubeb_stream_init(m_ctx.get(), &m_stream, "Dolphin Audio Output", nullptr, nullptr,
nullptr, &params, std::max(BUFFER_SAMPLES, minimum_latency),

8
Source/Core/AudioCommon/CubebUtils.cpp
View File

@ -38,7 +38,7 @@ static void DestroyContext(cubeb* ctx)
cubeb_destroy(ctx);
if (cubeb_set_log_callback(CUBEB_LOG_DISABLED, nullptr) != CUBEB_OK)
{
ERROR_LOG(AUDIO, "Error removing cubeb log callback");
ERROR_LOG_FMT(AUDIO, "Error removing cubeb log callback");
}
}
@ -59,16 +59,16 @@ std::shared_ptr<cubeb> CubebUtils::GetContext()
}
if (cubeb_set_log_callback(CUBEB_LOG_NORMAL, LogCallback) != CUBEB_OK)
{
ERROR_LOG(AUDIO, "Error setting cubeb log callback");
ERROR_LOG_FMT(AUDIO, "Error setting cubeb log callback");
}
cubeb* ctx;
if (cubeb_init(&ctx, "Dolphin", nullptr) != CUBEB_OK)
{
ERROR_LOG(AUDIO, "Error initializing cubeb library");
ERROR_LOG_FMT(AUDIO, "Error initializing cubeb library");
return nullptr;
}
INFO_LOG(AUDIO, "Cubeb initialized using %s backend", cubeb_get_backend_id(ctx));
INFO_LOG_FMT(AUDIO, "Cubeb initialized using {} backend", cubeb_get_backend_id(ctx));
weak = shared = {ctx, DestroyContext};
return shared;

24
Source/Core/AudioCommon/Mixer.cpp
View File

@ -36,7 +36,7 @@ Mixer::Mixer(unsigned int BackendSampleRate)
m_surround_decoder(BackendSampleRate,
DPL2QualityToFrameBlockSize(Config::Get(Config::MAIN_DPL2_QUALITY)))
{
INFO_LOG(AUDIO_INTERFACE, "Mixer is initialized");
INFO_LOG_FMT(AUDIO_INTERFACE, "Mixer is initialized");
}
Mixer::~Mixer()
@ -193,7 +193,7 @@ unsigned int Mixer::MixSurround(float* samples, unsigned int num_samples)
size_t available_frames = Mix(m_scratch_buffer.data(), static_cast<u32>(needed_frames));
if (available_frames != needed_frames)
{
ERROR_LOG(AUDIO, "Error decoding surround frames.");
ERROR_LOG_FMT(AUDIO, "Error decoding surround frames.");
return 0;
}
@ -296,17 +296,17 @@ void Mixer::StartLogDTKAudio(const std::string& filename)
{
m_log_dtk_audio = true;
m_wave_writer_dtk.SetSkipSilence(false);
NOTICE_LOG(AUDIO, "Starting DTK Audio logging");
NOTICE_LOG_FMT(AUDIO, "Starting DTK Audio logging");
}
else
{
m_wave_writer_dtk.Stop();
NOTICE_LOG(AUDIO, "Unable to start DTK Audio logging");
NOTICE_LOG_FMT(AUDIO, "Unable to start DTK Audio logging");
}
}
else
{
WARN_LOG(AUDIO, "DTK Audio logging has already been started");
WARN_LOG_FMT(AUDIO, "DTK Audio logging has already been started");
}
}
@ -316,11 +316,11 @@ void Mixer::StopLogDTKAudio()
{
m_log_dtk_audio = false;
m_wave_writer_dtk.Stop();
NOTICE_LOG(AUDIO, "Stopping DTK Audio logging");
NOTICE_LOG_FMT(AUDIO, "Stopping DTK Audio logging");
}
else
{
WARN_LOG(AUDIO, "DTK Audio logging has already been stopped");
WARN_LOG_FMT(AUDIO, "DTK Audio logging has already been stopped");
}
}
@ -333,17 +333,17 @@ void Mixer::StartLogDSPAudio(const std::string& filename)
{
m_log_dsp_audio = true;
m_wave_writer_dsp.SetSkipSilence(false);
NOTICE_LOG(AUDIO, "Starting DSP Audio logging");
NOTICE_LOG_FMT(AUDIO, "Starting DSP Audio logging");
}
else
{
m_wave_writer_dsp.Stop();
NOTICE_LOG(AUDIO, "Unable to start DSP Audio logging");
NOTICE_LOG_FMT(AUDIO, "Unable to start DSP Audio logging");
}
}
else
{
WARN_LOG(AUDIO, "DSP Audio logging has already been started");
WARN_LOG_FMT(AUDIO, "DSP Audio logging has already been started");
}
}
@ -353,11 +353,11 @@ void Mixer::StopLogDSPAudio()
{
m_log_dsp_audio = false;
m_wave_writer_dsp.Stop();
NOTICE_LOG(AUDIO, "Stopping DSP Audio logging");
NOTICE_LOG_FMT(AUDIO, "Stopping DSP Audio logging");
}
else
{
WARN_LOG(AUDIO, "DSP Audio logging has already been stopped");
WARN_LOG_FMT(AUDIO, "DSP Audio logging has already been stopped");
}
}

12
Source/Core/AudioCommon/OpenALStream.cpp
View File

@ -101,7 +101,7 @@ bool OpenALStream::Init()
}
const char* default_device_dame = palcGetString(nullptr, ALC_DEFAULT_DEVICE_SPECIFIER);
INFO_LOG(AUDIO, "Found OpenAL device %s", default_device_dame);
INFO_LOG_FMT(AUDIO, "Found OpenAL device {}", default_device_dame);
ALCdevice* device = palcOpenDevice(default_device_dame);
if (!device)
@ -204,7 +204,7 @@ static ALenum CheckALError(const char* desc)
break;
}
ERROR_LOG(AUDIO, "Error %s: %08x %s", desc, err, type.c_str());
ERROR_LOG_FMT(AUDIO, "Error {}: {:08x} {}", desc, err, type);
}
return err;
@ -246,8 +246,8 @@ void OpenALStream::SoundLoop()
frames_per_buffer = OAL_MAX_FRAMES;
}
INFO_LOG(AUDIO, "Using %d buffers, each with %d audio frames for a total of %d.", OAL_BUFFERS,
frames_per_buffer, frames_per_buffer * OAL_BUFFERS);
INFO_LOG_FMT(AUDIO, "Using {} buffers, each with {} audio frames for a total of {}.", OAL_BUFFERS,
frames_per_buffer, frames_per_buffer * OAL_BUFFERS);
// Should we make these larger just in case the mixer ever sends more samples
// than what we request?
@ -352,8 +352,8 @@ void OpenALStream::SoundLoop()
if (err == AL_INVALID_ENUM)
{
// 5.1 is not supported by the host, fallback to stereo
WARN_LOG(AUDIO,
"Unable to set 5.1 surround mode. Updating OpenAL Soft might fix this issue.");
WARN_LOG_FMT(
AUDIO, "Unable to set 5.1 surround mode. Updating OpenAL Soft might fix this issue.");
use_surround = false;
}
}

14
Source/Core/AudioCommon/PulseAudioStream.cpp
View File

@ -22,7 +22,7 @@ bool PulseAudio::Init()
m_stereo = !SConfig::GetInstance().ShouldUseDPL2Decoder();
m_channels = m_stereo ? 2 : 6; // will tell PA we use a Stereo or 5.0 channel setup
NOTICE_LOG(AUDIO, "PulseAudio backend using %d channels", m_channels);
NOTICE_LOG_FMT(AUDIO, "PulseAudio backend using {} channels", m_channels);
m_run_thread.Set();
m_thread = std::thread(&PulseAudio::SoundLoop, this);
@ -47,7 +47,7 @@ void PulseAudio::SoundLoop()
m_pa_error = pa_mainloop_iterate(m_pa_ml, 1, nullptr);
if (m_pa_error < 0)
ERROR_LOG(AUDIO, "PulseAudio error: %s", pa_strerror(m_pa_error));
ERROR_LOG_FMT(AUDIO, "PulseAudio error: {}", pa_strerror(m_pa_error));
PulseShutdown();
}
@ -73,7 +73,7 @@ bool PulseAudio::PulseInit()
if (m_pa_connected == 2 || m_pa_error < 0)
{
ERROR_LOG(AUDIO, "PulseAudio failed to initialize: %s", pa_strerror(m_pa_error));
ERROR_LOG_FMT(AUDIO, "PulseAudio failed to initialize: {}", pa_strerror(m_pa_error));
return false;
}
@ -123,11 +123,11 @@ bool PulseAudio::PulseInit()
m_pa_error = pa_stream_connect_playback(m_pa_s, nullptr, &m_pa_ba, flags, nullptr, nullptr);
if (m_pa_error < 0)
{
ERROR_LOG(AUDIO, "PulseAudio failed to initialize: %s", pa_strerror(m_pa_error));
ERROR_LOG_FMT(AUDIO, "PulseAudio failed to initialize: {}", pa_strerror(m_pa_error));
return false;
}
INFO_LOG(AUDIO, "Pulse successfully initialized");
INFO_LOG_FMT(AUDIO, "Pulse successfully initialized");
return true;
}
@ -161,7 +161,7 @@ void PulseAudio::UnderflowCallback(pa_stream* s)
pa_operation* op = pa_stream_set_buffer_attr(s, &m_pa_ba, nullptr, nullptr);
pa_operation_unref(op);
WARN_LOG(AUDIO, "pulseaudio underflow, new latency: %d bytes", m_pa_ba.tlength);
WARN_LOG_FMT(AUDIO, "pulseaudio underflow, new latency: {} bytes", m_pa_ba.tlength);
}
void PulseAudio::WriteCallback(pa_stream* s, size_t length)
@ -190,7 +190,7 @@ void PulseAudio::WriteCallback(pa_stream* s, size_t length)
}
else
{
ERROR_LOG(AUDIO, "Unsupported number of PA channels requested: %d", (int)m_channels);
ERROR_LOG_FMT(AUDIO, "Unsupported number of PA channels requested: {}", m_channels);
return;
}
}

16
Source/Core/AudioCommon/WASAPIStream.cpp
View File

@ -60,12 +60,12 @@ bool WASAPIStream::isValid()
return true;
}
static bool HandleWinAPI(std::string message, HRESULT result)
static bool HandleWinAPI(std::string_view message, HRESULT result)
{
if (result != S_OK)
{
_com_error err(result);
std::string error = TStrToUTF8(err.ErrorMessage()).c_str();
std::string error = TStrToUTF8(err.ErrorMessage());
switch (result)
{
@ -74,7 +74,7 @@ static bool HandleWinAPI(std::string message, HRESULT result)
break;
}
ERROR_LOG(AUDIO, "WASAPI: %s: %s", message.c_str(), error.c_str());
ERROR_LOG_FMT(AUDIO, "WASAPI: {}: {}", message, error);
}
return result == S_OK;
@ -236,8 +236,8 @@ bool WASAPIStream::SetRunning(bool running)
if (!device)
{
ERROR_LOG(AUDIO, "Can't find device '%s', falling back to default",
SConfig::GetInstance().sWASAPIDevice.c_str());
ERROR_LOG_FMT(AUDIO, "Can't find device '{}', falling back to default",
SConfig::GetInstance().sWASAPIDevice);
result = m_enumerator->GetDefaultAudioEndpoint(eRender, eConsole, &device);
}
}
@ -261,7 +261,7 @@ bool WASAPIStream::SetRunning(bool running)
device_properties->GetValue(PKEY_Device_FriendlyName, &device_name);
INFO_LOG(AUDIO, "Using audio endpoint '%s'", TStrToUTF8(device_name.pwszVal).c_str());
INFO_LOG_FMT(AUDIO, "Using audio endpoint '{}'", TStrToUTF8(device_name.pwszVal));
PropVariantClear(&device_name);
@ -280,7 +280,7 @@ bool WASAPIStream::SetRunning(bool running)
result = m_audio_client->GetDevicePeriod(nullptr, &device_period);
device_period += SConfig::GetInstance().iLatency * (10000 / m_format.Format.nChannels);
INFO_LOG(AUDIO, "Audio period set to %d", device_period);
INFO_LOG_FMT(AUDIO, "Audio period set to {}", device_period);
if (!HandleWinAPI("Failed to obtain device period", result))
{
@ -384,7 +384,7 @@ bool WASAPIStream::SetRunning(bool running)
device->Release();
INFO_LOG(AUDIO, "WASAPI: Successfully initialized!");
INFO_LOG_FMT(AUDIO, "WASAPI: Successfully initialized!");
m_running = true;
m_thread = std::thread([this] { SoundLoop(); });