264cc76ab4
Before, some loader plugins implemented their own buffering (FLAC&MP3), some didn't require any (WAV), and some didn't buffer at all (QOA). This meant that in practice, while you could load arbitrary amounts of samples from some loader plugins, you couldn't do that with some others. Also, it was ill-defined how many samples you would actually get back from a get_more_samples call. This commit fixes that by introducing a layer of abstraction between the loader and its plugins (because that's the whole point of having the extra class!). The plugins now only implement a load_chunks() function, which is much simpler to implement and allows plugins to play fast and loose with what they actually return. Basically, they can return many chunks of samples, where one chunk is simply a convenient block of samples to load. In fact, some loaders such as FLAC and QOA have separate internal functions for loading exactly one chunk. The loaders *should* load as many chunks as necessary for the sample count to be reached or surpassed (the latter simplifies loading loops in the implementations, since you don't need to know how large your next chunk is going to be; a problem for e.g. FLAC). If a plugin has no problems returning data of arbitrary size (currently WAV), it can return a single chunk that exactly (or roughly) matches the requested sample count. If a plugin is at the stream end, it can also return less samples than was requested! The loader can handle all of these cases and may call into load_chunk multiple times. If the plugin returns an empty chunk list (or only empty chunks; again, they can play fast and loose), the loader takes that as a stream end signal. Otherwise, the loader will always return exactly as many samples as the user requested. Buffering is handled by the loader, allowing any underlying plugin to deal with any weird sample count requirement the user throws at it (looking at you, SoundPlayer!). This (not accidentally!) makes QOA work in SoundPlayer.
67 lines
2.5 KiB
C++
67 lines
2.5 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/DeprecatedString.h>
|
|
#include <AK/FixedArray.h>
|
|
#include <AK/OwnPtr.h>
|
|
#include <AK/RefPtr.h>
|
|
#include <AK/Span.h>
|
|
#include <AK/StringView.h>
|
|
#include <LibAudio/Loader.h>
|
|
|
|
namespace Audio {
|
|
|
|
// constants for handling the WAV header data
|
|
static constexpr unsigned const WAVE_FORMAT_PCM = 0x0001; // PCM
|
|
static constexpr unsigned const WAVE_FORMAT_IEEE_FLOAT = 0x0003; // IEEE float
|
|
static constexpr unsigned const WAVE_FORMAT_ALAW = 0x0006; // 8-bit ITU-T G.711 A-law
|
|
static constexpr unsigned const WAVE_FORMAT_MULAW = 0x0007; // 8-bit ITU-T G.711 µ-law
|
|
static constexpr unsigned const WAVE_FORMAT_EXTENSIBLE = 0xFFFE; // Determined by SubFormat
|
|
|
|
// Parses and reads audio data from a WAV file.
|
|
class WavLoaderPlugin : public LoaderPlugin {
|
|
public:
|
|
explicit WavLoaderPlugin(NonnullOwnPtr<SeekableStream> stream);
|
|
static Result<NonnullOwnPtr<WavLoaderPlugin>, LoaderError> create(StringView path);
|
|
static Result<NonnullOwnPtr<WavLoaderPlugin>, LoaderError> create(Bytes buffer);
|
|
|
|
virtual ErrorOr<Vector<FixedArray<Sample>>, LoaderError> load_chunks(size_t samples_to_read_from_input) override;
|
|
|
|
virtual MaybeLoaderError reset() override { return seek(0); }
|
|
|
|
// sample_index 0 is the start of the raw audio sample data
|
|
// within the file/stream.
|
|
virtual MaybeLoaderError seek(int sample_index) override;
|
|
|
|
virtual int loaded_samples() override { return static_cast<int>(m_loaded_samples); }
|
|
virtual int total_samples() override { return static_cast<int>(m_total_samples); }
|
|
virtual u32 sample_rate() override { return m_sample_rate; }
|
|
virtual u16 num_channels() override { return m_num_channels; }
|
|
virtual DeprecatedString format_name() override { return "RIFF WAVE (.wav)"; }
|
|
virtual PcmSampleFormat pcm_format() override { return m_sample_format; }
|
|
|
|
private:
|
|
MaybeLoaderError initialize();
|
|
|
|
MaybeLoaderError parse_header();
|
|
|
|
LoaderSamples samples_from_pcm_data(Bytes const& data, size_t samples_to_read) const;
|
|
template<typename SampleReader>
|
|
MaybeLoaderError read_samples_from_stream(Stream& stream, SampleReader read_sample, FixedArray<Sample>& samples) const;
|
|
|
|
u32 m_sample_rate { 0 };
|
|
u16 m_num_channels { 0 };
|
|
PcmSampleFormat m_sample_format;
|
|
size_t m_byte_offset_of_data_samples { 0 };
|
|
|
|
size_t m_loaded_samples { 0 };
|
|
size_t m_total_samples { 0 };
|
|
};
|
|
|
|
}
|