RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 22:47:45 +00:00
Code Issues Activity Actions

LibAudio: New error propagation API in Loader and Buffer

Browse source 
Previously, a libc-like out-of-line error information was used in the
loader and its plugins. Now, all functions that may fail to do their job
return some sort of Result. The universally-used error type ist the new
LoaderError, which can contain information about the general error
category (such as file format, I/O, unimplemented features), an error
description, and location information, such as file index or sample
index.

Additionally, the loader plugins try to do as little work as possible in
their constructors. Right after being constructed, a user should call
initialize() and check the errors returned from there. (This is done
transparently by Loader itself.) If a constructor caused an error, the
call to initialize should check and return it immediately.

This opportunity was used to rework a lot of the internal error
propagation in both loader classes, especially FlacLoader. Therefore, a
couple of other refactorings may have sneaked in as well.

The adoption of LibAudio users is minimal. Piano's adoption is not
important, as the code will receive major refactoring in the near future
anyways. SoundPlayer's adoption is also less important, as changes to
refactor it are in the works as well. aplay's adoption is the best and
may serve as an example for other users. It also includes new buffering
behavior.

Buffer also gets some attention, making it OOM-safe and thereby also
propagating its errors to the user.
This commit is contained in:
kleines Filmröllchen 2021-11-27 17:00:19 +01:00 • committed by Brian Gianforcaro
parent ec8bd8116d
commit 96d02a3e75
19 changed files with 406 additions and 397 deletions
Download patch file Download diff file Expand all files Collapse all files

60
Userland/Libraries/LibAudio/Loader.h
View file

@ -7,10 +7,15 @@
#pragma once
#include <AK/ByteBuffer.h>
#include <AK/NonnullOwnPtr.h>
#include <AK/NonnullRefPtr.h>
#include <AK/RefCounted.h>
#include <AK/RefPtr.h>
#include <AK/Result.h>
#include <AK/StringView.h>
#include <AK/Try.h>
#include <LibAudio/Buffer.h>
#include <LibAudio/LoaderError.h>
#include <LibCore/File.h>
namespace Audio {
@ -18,20 +23,20 @@ namespace Audio {
static const String empty_string = "";
static String no_plugin_error = "No loader plugin available";
using LoaderSamples = Result<NonnullRefPtr<Buffer>, LoaderError>;
using MaybeLoaderError = Result<void, LoaderError>;
class LoaderPlugin {
public:
virtual ~LoaderPlugin() { }
virtual bool sniff() = 0;
virtual MaybeLoaderError initialize() = 0;
virtual bool has_error() { return false; }
virtual const String& error_string() { return empty_string; }
virtual LoaderSamples get_more_samples(size_t max_bytes_to_read_from_input = 128 * KiB) = 0;
virtual RefPtr<Buffer> get_more_samples(size_t max_bytes_to_read_from_input = 128 * KiB) = 0;
virtual MaybeLoaderError reset() = 0;
virtual void reset() = 0;
virtual void seek(const int sample_index) = 0;
virtual MaybeLoaderError seek(const int sample_index) = 0;
// total_samples() and loaded_samples() should be independent
// of the number of channels.
@ -51,37 +56,28 @@ public:
class Loader : public RefCounted<Loader> {
public:
static NonnullRefPtr<Loader> create(StringView path) { return adopt_ref(*new Loader(path)); }
static NonnullRefPtr<Loader> create(const ByteBuffer& buffer) { return adopt_ref(*new Loader(buffer)); }
static Result<NonnullRefPtr<Loader>, LoaderError> create(StringView path) { return adopt_ref(*new Loader(TRY(try_create(path)))); }
static Result<NonnullRefPtr<Loader>, LoaderError> create(ByteBuffer const& buffer) { return adopt_ref(*new Loader(TRY(try_create(buffer)))); }
bool has_error() const { return m_plugin ? m_plugin->has_error() : true; }
const String& error_string() const { return m_plugin ? m_plugin->error_string() : no_plugin_error; }
LoaderSamples get_more_samples(size_t max_bytes_to_read_from_input = 128 * KiB) const { return m_plugin->get_more_samples(max_bytes_to_read_from_input); }
RefPtr<Buffer> get_more_samples(size_t max_bytes_to_read_from_input = 128 * KiB) const { return m_plugin ? m_plugin->get_more_samples(max_bytes_to_read_from_input) : nullptr; }
MaybeLoaderError reset() const { return m_plugin->reset(); }
MaybeLoaderError seek(const int position) const { return m_plugin->seek(position); }
void reset() const
{
if (m_plugin)
m_plugin->reset();
}
void seek(const int position) const
{
if (m_plugin)
m_plugin->seek(position);
}
int loaded_samples() const { return m_plugin ? m_plugin->loaded_samples() : 0; }
int total_samples() const { return m_plugin ? m_plugin->total_samples() : 0; }
u32 sample_rate() const { return m_plugin ? m_plugin->sample_rate() : 0; }
u16 num_channels() const { return m_plugin ? m_plugin->num_channels() : 0; }
u16 bits_per_sample() const { return m_plugin ? pcm_bits_per_sample(m_plugin->pcm_format()) : 0; }
RefPtr<Core::File> file() const { return m_plugin ? m_plugin->file() : nullptr; }
int loaded_samples() const { return m_plugin->loaded_samples(); }
int total_samples() const { return m_plugin->total_samples(); }
u32 sample_rate() const { return m_plugin->sample_rate(); }
u16 num_channels() const { return m_plugin->num_channels(); }
u16 bits_per_sample() const { return pcm_bits_per_sample(m_plugin->pcm_format()); }
RefPtr<Core::File> file() const { return m_plugin->file(); }
private:
explicit Loader(StringView path);
explicit Loader(const ByteBuffer& buffer);
static Result<NonnullOwnPtr<LoaderPlugin>, LoaderError> try_create(StringView path);
static Result<NonnullOwnPtr<LoaderPlugin>, LoaderError> try_create(ByteBuffer const& buffer);
mutable OwnPtr<LoaderPlugin> m_plugin;
explicit Loader(NonnullOwnPtr<LoaderPlugin>);
mutable NonnullOwnPtr<LoaderPlugin> m_plugin;
};
}