mirror of
https://github.com/RGBCube/serenity
synced 2025-05-31 19:38:12 +00:00
b92df530d3
The old FIXME asserting that Core::AnonymousBuffer cannot be invalid or zero-sized is no longer accurate. Add a default constructor for Audio::Buffer that has all invalid state instead of going to the OS to allocate a 1 sample buffer for the "no more samples" states in the WAV and FLAC plugins.
129 lines
4.3 KiB
C++
129 lines
4.3 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
* Copyright (c) 2021, kleines Filmröllchen <filmroellchen@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <AK/ByteBuffer.h>
|
|
#include <AK/Error.h>
|
|
#include <AK/FixedArray.h>
|
|
#include <AK/MemoryStream.h>
|
|
#include <AK/NonnullRefPtr.h>
|
|
#include <AK/RefPtr.h>
|
|
#include <AK/String.h>
|
|
#include <AK/Types.h>
|
|
#include <AK/Vector.h>
|
|
#include <AK/kmalloc.h>
|
|
#include <LibAudio/Sample.h>
|
|
#include <LibCore/AnonymousBuffer.h>
|
|
#include <string.h>
|
|
|
|
namespace Audio {
|
|
using namespace AK::Exponentials;
|
|
|
|
// Supported PCM sample formats.
|
|
enum PcmSampleFormat : u8 {
|
|
Uint8,
|
|
Int16,
|
|
Int24,
|
|
Int32,
|
|
Float32,
|
|
Float64,
|
|
};
|
|
|
|
// Most of the read code only cares about how many bits to read or write
|
|
u16 pcm_bits_per_sample(PcmSampleFormat format);
|
|
String sample_format_name(PcmSampleFormat format);
|
|
|
|
// 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...
|
|
template<typename SampleType>
|
|
class ResampleHelper {
|
|
public:
|
|
ResampleHelper(u32 source, u32 target);
|
|
|
|
// To be used as follows:
|
|
// while the resampler doesn't need a new sample, read_sample(current) and store the resulting samples.
|
|
// as long as the resampler needs a new sample, process_sample(current)
|
|
|
|
// Stores a new sample
|
|
void process_sample(SampleType sample_l, SampleType sample_r);
|
|
// Assigns the given sample to its correct value and returns false if there is a new sample required
|
|
bool read_sample(SampleType& next_l, SampleType& next_r);
|
|
Vector<SampleType> resample(Vector<SampleType> to_resample);
|
|
|
|
void reset();
|
|
|
|
u32 source() const { return m_source; }
|
|
u32 target() const { return m_target; }
|
|
|
|
private:
|
|
const u32 m_source;
|
|
const u32 m_target;
|
|
u32 m_current_ratio { 0 };
|
|
SampleType m_last_sample_l;
|
|
SampleType m_last_sample_r;
|
|
};
|
|
|
|
// A buffer of audio samples.
|
|
class Buffer : public RefCounted<Buffer> {
|
|
public:
|
|
static ErrorOr<NonnullRefPtr<Buffer>> from_pcm_data(ReadonlyBytes data, int num_channels, PcmSampleFormat sample_format);
|
|
static ErrorOr<NonnullRefPtr<Buffer>> from_pcm_stream(InputMemoryStream& stream, int num_channels, PcmSampleFormat sample_format, int num_samples);
|
|
template<ArrayLike<Sample> ArrayT>
|
|
static ErrorOr<NonnullRefPtr<Buffer>> create_with_samples(ArrayT&& samples)
|
|
{
|
|
return adopt_nonnull_ref_or_enomem(new (nothrow) Buffer(move(samples)));
|
|
}
|
|
static ErrorOr<NonnullRefPtr<Buffer>> create_with_anonymous_buffer(Core::AnonymousBuffer buffer, i32 buffer_id, int sample_count)
|
|
{
|
|
return adopt_nonnull_ref_or_enomem(new (nothrow) Buffer(move(buffer), buffer_id, sample_count));
|
|
}
|
|
static NonnullRefPtr<Buffer> create_empty()
|
|
{
|
|
// If we can't allocate an empty buffer, things are in a very bad state.
|
|
return MUST(adopt_nonnull_ref_or_enomem(new (nothrow) Buffer));
|
|
}
|
|
|
|
Sample const* samples() const { return (const Sample*)data(); }
|
|
int sample_count() const { return m_sample_count; }
|
|
void const* data() const { return m_buffer.data<void>(); }
|
|
int size_in_bytes() const { return m_sample_count * (int)sizeof(Sample); }
|
|
int id() const { return m_id; }
|
|
Core::AnonymousBuffer const& anonymous_buffer() const { return m_buffer; }
|
|
|
|
private:
|
|
template<ArrayLike<Sample> ArrayT>
|
|
explicit Buffer(ArrayT&& samples)
|
|
: m_buffer(Core::AnonymousBuffer::create_with_size(samples.size() * sizeof(Sample)).release_value())
|
|
, m_id(allocate_id())
|
|
, m_sample_count(samples.size())
|
|
{
|
|
memcpy(m_buffer.data<void>(), samples.data(), samples.size() * sizeof(Sample));
|
|
}
|
|
|
|
explicit Buffer(Core::AnonymousBuffer buffer, i32 buffer_id, int sample_count)
|
|
: m_buffer(move(buffer))
|
|
, m_id(buffer_id)
|
|
, m_sample_count(sample_count)
|
|
{
|
|
}
|
|
|
|
// Empty Buffer representation, to avoid tiny anonymous buffers in EOF states
|
|
Buffer() = default;
|
|
|
|
static i32 allocate_id();
|
|
|
|
Core::AnonymousBuffer m_buffer;
|
|
const i32 m_id { -1 };
|
|
const int m_sample_count { 0 };
|
|
};
|
|
|
|
// This only works for double resamplers, and therefore cannot be part of the class
|
|
ErrorOr<NonnullRefPtr<Buffer>> resample_buffer(ResampleHelper<double>& resampler, Buffer const& to_resample);
|
|
|
|
}
|