Work on AudioServer
The center of this is now an ABuffer class in LibAudio.
ABuffer contains ASample, which has two channels (left/right) in
floating point for mixing purposes, in 44100hz.
This means that the loaders (AWavLoader in this case) needs to do some
manipulation to get things in the right format, but that we don't need
to care after format loading is done.
While we're at it, do some correctness fixes. PCM data is unsigned if
it's 8 bit, but 16 bit is signed. And /dev/audio also wants signed 16
bit audio, so give it what it wants.
On top of this, AudioServer now accepts requests to play a buffer.
The IPC mechanism here is pretty much a 1:1 copy-paste from
LibGUI/WindowServer. It can be generalized more in the future, but for
now I want to get AudioServer working decently first :)
Additionally, add a little "aplay" tool to load and play a WAV file. It
will break with large WAVs (run out of memory, heh...) but it's a start.
Future work needs to make AudioServer block buffer submission from
clients until it has played the buffer they are requesting to play.
2019-07-15 13:54:52 +03:00
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <AK/RefCounted.h>
|
|
|
|
#include <AK/ByteBuffer.h>
|
|
|
|
#include <AK/Types.h>
|
|
|
|
#include <AK/Vector.h>
|
2019-07-27 19:17:17 +03:00
|
|
|
#include <LibC/SharedBuffer.h>
|
Work on AudioServer
The center of this is now an ABuffer class in LibAudio.
ABuffer contains ASample, which has two channels (left/right) in
floating point for mixing purposes, in 44100hz.
This means that the loaders (AWavLoader in this case) needs to do some
manipulation to get things in the right format, but that we don't need
to care after format loading is done.
While we're at it, do some correctness fixes. PCM data is unsigned if
it's 8 bit, but 16 bit is signed. And /dev/audio also wants signed 16
bit audio, so give it what it wants.
On top of this, AudioServer now accepts requests to play a buffer.
The IPC mechanism here is pretty much a 1:1 copy-paste from
LibGUI/WindowServer. It can be generalized more in the future, but for
now I want to get AudioServer working decently first :)
Additionally, add a little "aplay" tool to load and play a WAV file. It
will break with large WAVs (run out of memory, heh...) but it's a start.
Future work needs to make AudioServer block buffer submission from
clients until it has played the buffer they are requesting to play.
2019-07-15 13:54:52 +03:00
|
|
|
|
|
|
|
// A single sample in an audio buffer.
|
|
|
|
// Values are floating point, and should range from -1.0 to +1.0
|
|
|
|
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)
|
|
|
|
{}
|
|
|
|
|
2019-07-17 10:43:43 +03:00
|
|
|
void clip()
|
Work on AudioServer
The center of this is now an ABuffer class in LibAudio.
ABuffer contains ASample, which has two channels (left/right) in
floating point for mixing purposes, in 44100hz.
This means that the loaders (AWavLoader in this case) needs to do some
manipulation to get things in the right format, but that we don't need
to care after format loading is done.
While we're at it, do some correctness fixes. PCM data is unsigned if
it's 8 bit, but 16 bit is signed. And /dev/audio also wants signed 16
bit audio, so give it what it wants.
On top of this, AudioServer now accepts requests to play a buffer.
The IPC mechanism here is pretty much a 1:1 copy-paste from
LibGUI/WindowServer. It can be generalized more in the future, but for
now I want to get AudioServer working decently first :)
Additionally, add a little "aplay" tool to load and play a WAV file. It
will break with large WAVs (run out of memory, heh...) but it's a start.
Future work needs to make AudioServer block buffer submission from
clients until it has played the buffer they are requesting to play.
2019-07-15 13:54:52 +03:00
|
|
|
{
|
|
|
|
if (left > 1)
|
|
|
|
left = 1;
|
|
|
|
else if (left < -1)
|
|
|
|
left = -1;
|
|
|
|
|
|
|
|
if (right > 1)
|
|
|
|
right = 1;
|
|
|
|
else if (right < -1)
|
|
|
|
right = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ASample& operator+=(const ASample& other)
|
|
|
|
{
|
|
|
|
left += other.left;
|
|
|
|
right += other.right;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
float left;
|
|
|
|
float right;
|
|
|
|
};
|
|
|
|
|
|
|
|
// 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);
|
2019-07-27 18:20:41 +03:00
|
|
|
static NonnullRefPtr<ABuffer> create_with_samples(Vector<ASample>&& samples)
|
|
|
|
{
|
|
|
|
return adopt(*new ABuffer(move(samples)));
|
|
|
|
}
|
2019-07-27 19:17:17 +03:00
|
|
|
static NonnullRefPtr<ABuffer> create_with_shared_buffer(NonnullRefPtr<SharedBuffer>&& buffer)
|
|
|
|
{
|
|
|
|
return adopt(*new ABuffer(move(buffer)));
|
|
|
|
}
|
Work on AudioServer
The center of this is now an ABuffer class in LibAudio.
ABuffer contains ASample, which has two channels (left/right) in
floating point for mixing purposes, in 44100hz.
This means that the loaders (AWavLoader in this case) needs to do some
manipulation to get things in the right format, but that we don't need
to care after format loading is done.
While we're at it, do some correctness fixes. PCM data is unsigned if
it's 8 bit, but 16 bit is signed. And /dev/audio also wants signed 16
bit audio, so give it what it wants.
On top of this, AudioServer now accepts requests to play a buffer.
The IPC mechanism here is pretty much a 1:1 copy-paste from
LibGUI/WindowServer. It can be generalized more in the future, but for
now I want to get AudioServer working decently first :)
Additionally, add a little "aplay" tool to load and play a WAV file. It
will break with large WAVs (run out of memory, heh...) but it's a start.
Future work needs to make AudioServer block buffer submission from
clients until it has played the buffer they are requesting to play.
2019-07-15 13:54:52 +03:00
|
|
|
|
2019-07-27 19:17:17 +03:00
|
|
|
const ASample* samples() const { return (const ASample*)data(); }
|
|
|
|
int sample_count() const { return m_buffer->size() / (int)sizeof(ASample); }
|
|
|
|
const void* data() const { return m_buffer->data(); }
|
|
|
|
int size_in_bytes() const { return m_buffer->size(); }
|
|
|
|
int shared_buffer_id() const { return m_buffer->shared_buffer_id(); }
|
Work on AudioServer
The center of this is now an ABuffer class in LibAudio.
ABuffer contains ASample, which has two channels (left/right) in
floating point for mixing purposes, in 44100hz.
This means that the loaders (AWavLoader in this case) needs to do some
manipulation to get things in the right format, but that we don't need
to care after format loading is done.
While we're at it, do some correctness fixes. PCM data is unsigned if
it's 8 bit, but 16 bit is signed. And /dev/audio also wants signed 16
bit audio, so give it what it wants.
On top of this, AudioServer now accepts requests to play a buffer.
The IPC mechanism here is pretty much a 1:1 copy-paste from
LibGUI/WindowServer. It can be generalized more in the future, but for
now I want to get AudioServer working decently first :)
Additionally, add a little "aplay" tool to load and play a WAV file. It
will break with large WAVs (run out of memory, heh...) but it's a start.
Future work needs to make AudioServer block buffer submission from
clients until it has played the buffer they are requesting to play.
2019-07-15 13:54:52 +03:00
|
|
|
|
|
|
|
private:
|
2019-07-27 19:17:17 +03:00
|
|
|
explicit ABuffer(Vector<ASample>&& samples)
|
|
|
|
: m_buffer(*SharedBuffer::create_with_size(samples.size() * sizeof(ASample)))
|
|
|
|
{
|
|
|
|
memcpy(m_buffer->data(), samples.data(), samples.size() * sizeof(ASample));
|
|
|
|
}
|
|
|
|
|
|
|
|
explicit ABuffer(NonnullRefPtr<SharedBuffer>&& buffer)
|
|
|
|
: m_buffer(move(buffer))
|
2019-07-27 18:20:41 +03:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2019-07-27 19:17:17 +03:00
|
|
|
NonnullRefPtr<SharedBuffer> m_buffer;
|
|
|
|
int m_sample_count { 0 };
|
Work on AudioServer
The center of this is now an ABuffer class in LibAudio.
ABuffer contains ASample, which has two channels (left/right) in
floating point for mixing purposes, in 44100hz.
This means that the loaders (AWavLoader in this case) needs to do some
manipulation to get things in the right format, but that we don't need
to care after format loading is done.
While we're at it, do some correctness fixes. PCM data is unsigned if
it's 8 bit, but 16 bit is signed. And /dev/audio also wants signed 16
bit audio, so give it what it wants.
On top of this, AudioServer now accepts requests to play a buffer.
The IPC mechanism here is pretty much a 1:1 copy-paste from
LibGUI/WindowServer. It can be generalized more in the future, but for
now I want to get AudioServer working decently first :)
Additionally, add a little "aplay" tool to load and play a WAV file. It
will break with large WAVs (run out of memory, heh...) but it's a start.
Future work needs to make AudioServer block buffer submission from
clients until it has played the buffer they are requesting to play.
2019-07-15 13:54:52 +03:00
|
|
|
};
|