RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-06-01 10:38:13 +00:00
Code Issues Activity Actions

LibAudio: Fixed stuttery playback of audio

Browse source 
When playing an ABuffer, the count of samples were determined by the
size of the SharedBuffer. This caused small pauses of up to 512
samples during the playback, when the size of the shared buffer was
rounded up to a multiple of 4096. This problem was amplified by the
fact that the AResampleHelper was created every time a new chunk of
audio was to be processed, causing inconsistencies in the playback of
wav files.
This commit is contained in:
Till Mayer 2019-10-16 15:31:01 +02:00 • committed by Andreas Kling
parent 7e97e1c5d9
commit 4c8341d080
6 changed files with 78 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

47
Libraries/LibAudio/ABuffer.h
View file

@ -1,6 +1,5 @@
#pragma once
#include <AK/RefCounted.h>
#include <AK/ByteBuffer.h>
#include <AK/Types.h>
#include <AK/Vector.h>
@ -12,19 +11,22 @@ struct ASample {
ASample()
: left(0)
, right(0)
{}
{
}
// For mono
ASample(float left)
: left(left)
, right(left)
{}
{
}
// For stereo
ASample(float left, float right)
: left(left)
, right(right)
{}
{
}
void clip()
{
@ -57,38 +59,57 @@ struct ASample {
float right;
};
// Small helper to resample from one playback rate to another
// This isn't really "smart", in that we just insert (or drop) samples.
// Should do better...
class AResampleHelper {
public:
AResampleHelper(float source, float target);
void process_sample(float sample_l, float sample_r);
bool read_sample(float& next_l, float& next_r);
private:
const float m_ratio;
float m_current_ratio { 0 };
float m_last_sample_l { 0 };
float m_last_sample_r { 0 };
};
// A buffer of audio samples, normalized to 44100hz.
class ABuffer : public RefCounted<ABuffer> {
public:
static RefPtr<ABuffer> from_pcm_data(ByteBuffer& data, int num_channels, int bits_per_sample, int source_rate);
static RefPtr<ABuffer> from_pcm_data(ByteBuffer& data, AResampleHelper& resampler, int num_channels, int bits_per_sample);
static NonnullRefPtr<ABuffer> create_with_samples(Vector<ASample>&& samples)
{
return adopt(*new ABuffer(move(samples)));
}
static NonnullRefPtr<ABuffer> create_with_shared_buffer(NonnullRefPtr<SharedBuffer>&& buffer)
static NonnullRefPtr<ABuffer> create_with_shared_buffer(NonnullRefPtr<SharedBuffer>&& buffer, int sample_count)
{
return adopt(*new ABuffer(move(buffer)));
return adopt(*new ABuffer(move(buffer), sample_count));
}
const ASample* samples() const { return (const ASample*)data(); }
int sample_count() const { return m_buffer->size() / (int)sizeof(ASample); }
int sample_count() const { return m_sample_count; }
const void* data() const { return m_buffer->data(); }
int size_in_bytes() const { return m_buffer->size(); }
int size_in_bytes() const { return m_sample_count * (int)sizeof(ASample); }
int shared_buffer_id() const { return m_buffer->shared_buffer_id(); }
SharedBuffer& shared_buffer() { return *m_buffer; }
private:
explicit ABuffer(Vector<ASample>&& samples)
: m_buffer(*SharedBuffer::create_with_size(samples.size() * sizeof(ASample)))
: m_buffer(*SharedBuffer::create_with_size(samples.size() * sizeof(ASample))),
m_sample_count(samples.size())
{
memcpy(m_buffer->data(), samples.data(), samples.size() * sizeof(ASample));
}
explicit ABuffer(NonnullRefPtr<SharedBuffer>&& buffer)
: m_buffer(move(buffer))
explicit ABuffer(NonnullRefPtr<SharedBuffer>&& buffer, int sample_count)
: m_buffer(move(buffer)),
m_sample_count(sample_count)
{
}
NonnullRefPtr<SharedBuffer> m_buffer;
int m_sample_count { 0 };
const int m_sample_count;
};