Xargon/Duckstation
1
0
Fork 0
mirror of https://github.com/RetroDECK/Duckstation.git synced 2024-11-23 06:15:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Common/AudioStream: Fix race condition with resampling reset while reading

Browse source
This commit is contained in:
Connor McLaughlin 2021-01-16 02:54:41 +10:00
parent 4c9e0299ed
commit 6fbd970b55
2 changed files with 33 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
src/common/audio_stream.cpp
View file

@ -17,6 +17,9 @@ bool AudioStream::Reconfigure(u32 input_sample_rate /* = DefaultInputSampleRate
u32 output_sample_rate /* = DefaultOutputSampleRate */, u32 channels /* = 1 */,
u32 buffer_size /* = DefaultBufferSize */)
{
std::unique_lock<std::mutex> buffer_lock(m_buffer_mutex);
std::unique_lock<std::mutex> resampler_Lock(m_resampler_mutex);
DestroyResampler();
if (IsDeviceOpen())
CloseDevice();
@ -39,17 +42,24 @@ bool AudioStream::Reconfigure(u32 input_sample_rate /* = DefaultInputSampleRate
}
CreateResampler();
SetInputSampleRate(input_sample_rate);
InternalSetInputSampleRate(input_sample_rate);
return true;
}
void AudioStream::SetInputSampleRate(u32 sample_rate)
{
std::unique_lock<std::mutex> buffer_lock(m_buffer_mutex);
std::unique_lock<std::mutex> resampler_lock(m_resampler_mutex);
InternalSetInputSampleRate(sample_rate);
}
void AudioStream::InternalSetInputSampleRate(u32 sample_rate)
{
if (m_input_sample_rate == sample_rate)
return;
std::unique_lock<std::mutex> lock(m_buffer_mutex);
m_input_sample_rate = sample_rate;
m_resampler_ratio = static_cast<double>(m_output_sample_rate) / static_cast<double>(sample_rate);
src_set_ratio(static_cast<SRC_STATE*>(m_resampler_state), m_resampler_ratio);
@ -156,19 +166,22 @@ void AudioStream::ReadFrames(SampleType* samples, u32 num_frames, bool apply_vol
const u32 total_samples = num_frames * m_channels;
u32 samples_copied = 0;
{
m_buffer_mutex.lock();
std::unique_lock<std::mutex> buffer_lock(m_buffer_mutex);
if (m_input_sample_rate == m_output_sample_rate)
{
samples_copied = std::min(m_buffer.GetSize(), total_samples);
if (samples_copied > 0)
m_buffer.PopRange(samples, samples_copied);
m_buffer_mutex.unlock();
m_buffer_draining_cv.notify_one();
ReleaseBufferLock(std::move(buffer_lock));
}
else
{
ResampleInput();
if (m_resampled_buffer.GetSize() < total_samples)
ResampleInput(std::move(buffer_lock));
else
ReleaseBufferLock(std::move(buffer_lock));
samples_copied = std::min(m_resampled_buffer.GetSize(), total_samples);
if (samples_copied > 0)
m_resampled_buffer.PopRange(samples, samples_copied);
@ -251,6 +264,7 @@ void AudioStream::DropFrames(u32 count)
void AudioStream::EmptyBuffers()
{
std::unique_lock<std::mutex> lock(m_buffer_mutex);
std::unique_lock<std::mutex> resampler_lock(m_resampler_mutex);
m_buffer.Clear();
m_underflow_flag.store(false);
ResetResampler();
@ -280,8 +294,10 @@ void AudioStream::ResetResampler()
src_reset(static_cast<SRC_STATE*>(m_resampler_state));
}
void AudioStream::ResampleInput()
void AudioStream::ResampleInput(std::unique_lock<std::mutex> buffer_lock)
{
std::unique_lock<std::mutex> resampler_lock(m_resampler_mutex);
const u32 input_space_from_output = (m_resampled_buffer.GetSpace() * m_output_sample_rate) / m_input_sample_rate;
u32 remaining = std::min(m_buffer.GetSize(), input_space_from_output);
if (m_resample_in_buffer.size() < remaining)
@ -300,8 +316,7 @@ void AudioStream::ResampleInput()
}
}
m_buffer_mutex.unlock();
m_buffer_draining_cv.notify_one();
ReleaseBufferLock(std::move(buffer_lock));
const u32 potential_output_size =
(static_cast<u32>(m_resample_in_buffer.size()) * m_input_sample_rate) / m_output_sample_rate;

10
src/common/audio_stream.h
View file

@ -89,12 +89,19 @@ protected:
private:
ALWAYS_INLINE u32 GetBufferSpace() const { return (m_max_samples - m_buffer.GetSize()); }
ALWAYS_INLINE void ReleaseBufferLock(std::unique_lock<std::mutex> lock)
{
// lock is released implicitly by destruction
m_buffer_draining_cv.notify_one();
}
void EnsureBuffer(u32 size);
void CreateResampler();
void DestroyResampler();
void ResetResampler();
void ResampleInput();
void InternalSetInputSampleRate(u32 sample_rate);
void ResampleInput(std::unique_lock<std::mutex> buffer_lock);
HeapFIFOQueue<SampleType, MaxSamples> m_buffer;
mutable std::mutex m_buffer_mutex;
@ -110,6 +117,7 @@ private:
// Resampling
double m_resampler_ratio = 1.0;
void* m_resampler_state = nullptr;
std::mutex m_resampler_mutex;
HeapFIFOQueue<SampleType, MaxSamples> m_resampled_buffer;
std::vector<float> m_resample_in_buffer;
std::vector<float> m_resample_out_buffer;