system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-07-09 10:37:24 +00:00
Code Issues Projects Releases Wiki Activity

LibAudio: Replace DeprecatedFlyString with FlyString

Browse Source
This commit is contained in:
FujiBookPro 2024-05-27 15:27:01 -04:00 committed by Andrew Kaster
parent 3b05c81070
commit 728f42f8f5
6 changed files with 62 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
Userland/Libraries/LibAudio/FlacLoader.cpp
View File

@ -63,11 +63,11 @@ MaybeLoaderError FlacLoaderPlugin::parse_header()
BigEndianInputBitStream bit_input { MaybeOwned<Stream>(*m_stream) };
// A mixture of VERIFY and the non-crashing TRY().
#define FLAC_VERIFY(check, category, msg) \
do { \
if (!(check)) { \
return LoaderError { category, TRY(m_stream->tell()), ByteString::formatted("FLAC header: {}", msg) }; \
} \
#define FLAC_VERIFY(check, category, msg) \
do { \
if (!(check)) { \
return LoaderError { category, TRY(m_stream->tell()), TRY(String::formatted("FLAC header: {}", msg)) }; \
} \
} while (0)
// Magic number
@ -165,19 +165,19 @@ MaybeLoaderError FlacLoaderPlugin::load_picture(FlacRawMetadataBlock& block)
auto const mime_string_length = TRY(picture_block_bytes.read_bits(32));
auto offset_before_seeking = memory_stream.offset();
if (offset_before_seeking + mime_string_length >= block.data.size())
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "Picture MIME type exceeds available data" };
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "Picture MIME type exceeds available data"_fly_string };
// "The MIME type string, in printable ASCII characters 0x20-0x7E."
picture.mime_string = TRY(String::from_stream(memory_stream, mime_string_length));
for (auto code_point : picture.mime_string.code_points()) {
if (code_point < 0x20 || code_point > 0x7E)
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "Picture MIME type is not ASCII in range 0x20 - 0x7E" };
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "Picture MIME type is not ASCII in range 0x20 - 0x7E"_fly_string };
}
auto const description_string_length = TRY(picture_block_bytes.read_bits(32));
offset_before_seeking = memory_stream.offset();
if (offset_before_seeking + description_string_length >= block.data.size())
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "Picture description exceeds available data" };
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "Picture description exceeds available data"_fly_string };
picture.description_string = TRY(String::from_stream(memory_stream, description_string_length));
@ -190,7 +190,7 @@ MaybeLoaderError FlacLoaderPlugin::load_picture(FlacRawMetadataBlock& block)
auto const picture_size = TRY(picture_block_bytes.read_bits(32));
offset_before_seeking = memory_stream.offset();
if (offset_before_seeking + picture_size > block.data.size())
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(TRY(m_stream->tell())), "Picture size exceeds available data" };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(TRY(m_stream->tell())), "Picture size exceeds available data"_fly_string };
TRY(memory_stream.seek(picture_size, SeekMode::FromCurrentPosition));
picture.data = Vector<u8> { block.data.bytes().slice(offset_before_seeking, picture_size) };
@ -305,7 +305,7 @@ MaybeLoaderError FlacLoaderPlugin::seek(int int_sample_index)
dbgln_if(AFLACLOADER_DEBUG, "Seeking to seektable: sample index {}, byte offset {}", target_seekpoint.sample_index, target_seekpoint.byte_offset);
auto position = target_seekpoint.byte_offset + m_data_start_location;
if (m_stream->seek(static_cast<i64>(position), SeekMode::SetPosition).is_error())
return LoaderError { LoaderError::Category::IO, m_loaded_samples, ByteString::formatted("Invalid seek position {}", position) };
return LoaderError { LoaderError::Category::IO, m_loaded_samples, TRY(String::formatted("Invalid seek position {}", position)) };
m_loaded_samples = target_seekpoint.sample_index;
}
}
@ -367,11 +367,11 @@ ErrorOr<Vector<FixedArray<Sample>>, LoaderError> FlacLoaderPlugin::load_chunks(s
// 11.21. FRAME
LoaderSamples FlacLoaderPlugin::next_frame()
{
#define FLAC_VERIFY(check, category, msg) \
do { \
if (!(check)) { \
return LoaderError { category, static_cast<size_t>(m_current_sample_or_frame), ByteString::formatted("FLAC header: {}", msg) }; \
} \
#define FLAC_VERIFY(check, category, msg) \
do { \
if (!(check)) { \
return LoaderError { category, static_cast<size_t>(m_current_sample_or_frame), TRY(String::formatted("FLAC header: {}", msg)) }; \
} \
} while (0)
auto frame_byte_index = TRY(m_stream->tell());
@ -538,7 +538,7 @@ ErrorOr<u32, LoaderError> FlacLoaderPlugin::convert_sample_count_code(u8 sample_
// single codes
switch (sample_count_code) {
case 0:
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Reserved block size" };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Reserved block size"_fly_string };
case 1:
return 192;
case 6:
@ -587,7 +587,7 @@ ErrorOr<u32, LoaderError> FlacLoaderPlugin::convert_sample_rate_code(u8 sample_r
case 14:
return FLAC_SAMPLERATE_AT_END_OF_HEADER_16X10;
default:
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Invalid sample rate code" };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Invalid sample rate code"_fly_string };
}
}
@ -602,7 +602,7 @@ ErrorOr<u8, LoaderError> FlacLoaderPlugin::convert_bit_depth_code(u8 bit_depth_c
case 2:
return 12;
case 3:
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Reserved sample size" };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Reserved sample size"_fly_string };
case 4:
return 16;
case 5:
@ -612,7 +612,7 @@ ErrorOr<u8, LoaderError> FlacLoaderPlugin::convert_bit_depth_code(u8 bit_depth_c
case 7:
return 32;
default:
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), ByteString::formatted("Unsupported sample size {}", bit_depth_code) };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), TRY(String::formatted("Unsupported sample size {}", bit_depth_code)) };
}
}
@ -649,12 +649,12 @@ ErrorOr<FlacSubframeHeader, LoaderError> FlacLoaderPlugin::next_subframe_header(
// zero-bit padding
if (TRY(bit_stream.read_bit()) != 0)
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Zero bit padding" };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Zero bit padding"_fly_string };
// 11.25.1. SUBFRAME TYPE
u8 subframe_code = TRY(bit_stream.read_bits<u8>(6));
if ((subframe_code >= 0b000010 && subframe_code <= 0b000111) || (subframe_code > 0b001100 && subframe_code < 0b100000))
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Subframe type" };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Subframe type"_fly_string };
FlacSubframeType subframe_type;
u8 order = 0;
@ -722,7 +722,7 @@ ErrorOr<void, LoaderError> FlacLoaderPlugin::parse_subframe(Vector<i64>& samples
break;
}
default:
return LoaderError { LoaderError::Category::Unimplemented, static_cast<size_t>(m_current_sample_or_frame), "Unhandled FLAC subframe type" };
return LoaderError { LoaderError::Category::Unimplemented, static_cast<size_t>(m_current_sample_or_frame), "Unhandled FLAC subframe type"_fly_string };
}
for (size_t i = 0; i < samples.size(); ++i) {
@ -750,7 +750,7 @@ ErrorOr<Vector<i64>, LoaderError> FlacLoaderPlugin::decode_verbatim(FlacSubframe
return LoaderError {
LoaderError::Category::Format,
TRY(m_stream->tell()),
"Effective verbatim bits per sample are zero"sv,
"Effective verbatim bits per sample are zero"_fly_string,
};
}
for (size_t i = 0; i < m_current_frame->sample_count; ++i) {
@ -768,7 +768,7 @@ ErrorOr<void, LoaderError> FlacLoaderPlugin::decode_custom_lpc(Vector<i64>& deco
{
// LPC must provide at least as many samples as its order.
if (subframe.order > m_current_frame->sample_count)
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Too small frame for LPC order" };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Too small frame for LPC order"_fly_string };
decoded.ensure_capacity(m_current_frame->sample_count);
@ -776,7 +776,7 @@ ErrorOr<void, LoaderError> FlacLoaderPlugin::decode_custom_lpc(Vector<i64>& deco
return LoaderError {
LoaderError::Category::Format,
TRY(m_stream->tell()),
"Effective verbatim bits per sample are zero"sv,
"Effective verbatim bits per sample are zero"_fly_string,
};
}
// warm-up samples
@ -789,7 +789,7 @@ ErrorOr<void, LoaderError> FlacLoaderPlugin::decode_custom_lpc(Vector<i64>& deco
// precision of the coefficients
u8 lpc_precision = TRY(bit_input.read_bits<u8>(4));
if (lpc_precision == 0b1111)
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Invalid linear predictor coefficient precision" };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Invalid linear predictor coefficient precision"_fly_string };
lpc_precision += 1;
// shift needed on the data (signed!)
@ -832,7 +832,7 @@ ErrorOr<Vector<i64>, LoaderError> FlacLoaderPlugin::decode_fixed_lpc(FlacSubfram
{
// LPC must provide at least as many samples as its order.
if (subframe.order > m_current_frame->sample_count)
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Too small frame for LPC order" };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Too small frame for LPC order"_fly_string };
Vector<i64> decoded;
decoded.ensure_capacity(m_current_frame->sample_count);
@ -841,7 +841,7 @@ ErrorOr<Vector<i64>, LoaderError> FlacLoaderPlugin::decode_fixed_lpc(FlacSubfram
return LoaderError {
LoaderError::Category::Format,
TRY(m_stream->tell()),
"Effective verbatim bits per sample are zero"sv,
"Effective verbatim bits per sample are zero"_fly_string,
};
}
// warm-up samples
@ -900,7 +900,7 @@ ErrorOr<Vector<i64>, LoaderError> FlacLoaderPlugin::decode_fixed_lpc(FlacSubfram
decoded[i] += 4 * decoded[i - 1] - 6 * decoded[i - 2] + 4 * decoded[i - 3] - decoded[i - 4];
break;
default:
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), ByteString::formatted("Unrecognized predictor order {}", subframe.order) };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), TRY(String::formatted("Unrecognized predictor order {}", subframe.order)) };
}
return decoded;
}
@ -917,11 +917,11 @@ MaybeLoaderError FlacLoaderPlugin::decode_residual(Vector<i64>& decoded, FlacSub
dbgln_if(AFLACLOADER_DEBUG, " {}-bit Rice partitions, {} total (order {})", residual_mode == FlacResidualMode::Rice4Bit ? "4"sv : "5"sv, partitions, partition_order);
if (partitions > m_current_frame->sample_count)
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Too many Rice partitions, each partition must contain at least one sample" };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Too many Rice partitions, each partition must contain at least one sample"_fly_string };
// “The partition order MUST be such that the block size is evenly divisible by the number of partitions.”
// FIXME: Check “The partition order also MUST be such that the (block size >> partition order) is larger than the predictor order.”
if (m_current_frame->sample_count % partitions != 0)
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "Block size is not evenly divisible by number of partitions" };
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "Block size is not evenly divisible by number of partitions"_fly_string };
if (residual_mode == FlacResidualMode::Rice4Bit) {
// 11.30.2. RESIDUAL_CODING_METHOD_PARTITIONED_EXP_GOLOMB
@ -940,7 +940,7 @@ MaybeLoaderError FlacLoaderPlugin::decode_residual(Vector<i64>& decoded, FlacSub
decoded.extend(move(rice_partition));
}
} else
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Reserved residual coding method" };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Reserved residual coding method"_fly_string };
return {};
}
@ -959,7 +959,7 @@ ALWAYS_INLINE ErrorOr<Vector<i64>, LoaderError> FlacLoaderPlugin::decode_rice_pa
residual_sample_count = m_current_frame->sample_count / partitions;
if (partition_index == 0) {
if (subframe.order > residual_sample_count)
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "First Rice partition must advertise more residuals than LPC order" };
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "First Rice partition must advertise more residuals than LPC order"_fly_string };
residual_sample_count -= subframe.order;
}

2
Userland/Libraries/LibAudio/Loader.cpp
View File

@ -66,7 +66,7 @@ ErrorOr<NonnullOwnPtr<LoaderPlugin>, LoaderError> Loader::create_plugin(NonnullO
TRY(stream->seek(0, SeekMode::SetPosition));
}
return LoaderError { "No loader plugin available" };
return LoaderError { "No loader plugin available"_fly_string };
}
LoaderSamples Loader::get_more_samples(size_t samples_to_read_from_input)

13
Userland/Libraries/LibAudio/LoaderError.h
View File

@ -8,6 +8,7 @@
#include <AK/DeprecatedFlyString.h>
#include <AK/Error.h>
#include <AK/FlyString.h>
#include <errno.h>
namespace Audio {
@ -28,20 +29,20 @@ struct LoaderError {
Category category { Category::Unknown };
// Binary index: where in the file the error occurred.
size_t index { 0 };
DeprecatedFlyString description { ByteString::empty() };
FlyString description { ""_fly_string };
constexpr LoaderError() = default;
LoaderError(Category category, size_t index, DeprecatedFlyString description)
LoaderError(Category category, size_t index, FlyString description)
: category(category)
, index(index)
, description(move(description))
{
}
LoaderError(DeprecatedFlyString description)
LoaderError(FlyString description)
: description(move(description))
{
}
LoaderError(Category category, DeprecatedFlyString description)
LoaderError(Category category, FlyString description)
: category(category)
, description(move(description))
{
@ -54,11 +55,11 @@ struct LoaderError {
{
if (error.is_errno()) {
auto code = error.code();
description = ByteString::formatted("{} ({})", strerror(code), code);
description = String::formatted("{} ({})", strerror(code), code).release_value_but_fixme_should_propagate_errors();
if (code == EBADF || code == EBUSY || code == EEXIST || code == EIO || code == EISDIR || code == ENOENT || code == ENOMEM || code == EPIPE)
category = Category::IO;
} else {
description = error.string_literal();
description = FlyString::from_utf8(error.string_literal()).release_value_but_fixme_should_propagate_errors();
}
}
};

20
Userland/Libraries/LibAudio/MP3Loader.cpp
View File

@ -166,19 +166,19 @@ ErrorOr<MP3::Header, LoaderError> MP3LoaderPlugin::read_header(SeekableStream& s
{
auto bitstream = BigEndianInputBitStream(MaybeOwned<Stream>(stream));
if (TRY(bitstream.read_bits(4)) != 0xF)
return LoaderError { LoaderError::Category::Format, sample_index, "Frame header did not start with sync code." };
return LoaderError { LoaderError::Category::Format, sample_index, "Frame header did not start with sync code."_fly_string };
MP3::Header header;
header.id = TRY(bitstream.read_bit());
header.layer = MP3::Tables::LayerNumberLookup[TRY(bitstream.read_bits(2))];
if (header.layer <= 0)
return LoaderError { LoaderError::Category::Format, sample_index, "Frame header contains invalid layer number." };
return LoaderError { LoaderError::Category::Format, sample_index, "Frame header contains invalid layer number."_fly_string };
header.protection_bit = TRY(bitstream.read_bit());
header.bitrate = MP3::Tables::BitratesPerLayerLookup[header.layer - 1][TRY(bitstream.read_bits(4))];
if (header.bitrate <= 0)
return LoaderError { LoaderError::Category::Format, sample_index, "Frame header contains invalid bitrate." };
return LoaderError { LoaderError::Category::Format, sample_index, "Frame header contains invalid bitrate."_fly_string };
header.samplerate = MP3::Tables::SampleratesLookup[TRY(bitstream.read_bits(2))];
if (header.samplerate <= 0)
return LoaderError { LoaderError::Category::Format, sample_index, "Frame header contains invalid samplerate." };
return LoaderError { LoaderError::Category::Format, sample_index, "Frame header contains invalid samplerate."_fly_string };
header.padding_bit = TRY(bitstream.read_bit());
header.private_bit = TRY(bitstream.read_bit());
header.mode = static_cast<MP3::Mode>(TRY(bitstream.read_bits(2)));
@ -221,7 +221,7 @@ ErrorOr<MP3::Header, LoaderError> MP3LoaderPlugin::synchronize_and_read_header(S
}
return header_result.value();
}
return LoaderError { LoaderError::Category::Format, sample_index, "Failed to synchronize." };
return LoaderError { LoaderError::Category::Format, sample_index, "Failed to synchronize."_fly_string };
}
ErrorOr<MP3::Header, LoaderError> MP3LoaderPlugin::synchronize_and_read_header()
@ -242,7 +242,7 @@ ErrorOr<MP3::MP3Frame, LoaderError> MP3LoaderPlugin::read_frame_data(MP3::Header
auto maybe_buffer = ByteBuffer::create_uninitialized(header.slot_count);
if (maybe_buffer.is_error())
return LoaderError { LoaderError::Category::IO, m_loaded_samples, "Out of memory" };
return LoaderError { LoaderError::Category::IO, m_loaded_samples, "Out of memory"_fly_string };
auto& buffer = maybe_buffer.value();
size_t old_reservoir_size = m_bit_reservoir.used_buffer_size();
@ -539,7 +539,7 @@ MaybeLoaderError MP3LoaderPlugin::read_huffman_data(MP3::MP3Frame& frame, BigEnd
}
if (!tree || tree->nodes.is_empty()) {
return LoaderError { LoaderError::Category::Format, m_loaded_samples, "Frame references invalid huffman table." };
return LoaderError { LoaderError::Category::Format, m_loaded_samples, "Frame references invalid huffman table."_fly_string };
}
// Assumption: There's enough bits to read. 32 is just a placeholder for "unlimited".
@ -547,7 +547,7 @@ MaybeLoaderError MP3LoaderPlugin::read_huffman_data(MP3::MP3Frame& frame, BigEnd
auto const entry = MP3::Tables::Huffman::huffman_decode(reservoir, tree->nodes, 32);
granule_bits_read += entry.bits_read;
if (!entry.code.has_value())
return LoaderError { LoaderError::Category::Format, m_loaded_samples, "Frame contains invalid huffman data." };
return LoaderError { LoaderError::Category::Format, m_loaded_samples, "Frame contains invalid huffman data."_fly_string };
int x = entry.code->symbol.x;
int y = entry.code->symbol.y;
@ -585,7 +585,7 @@ MaybeLoaderError MP3LoaderPlugin::read_huffman_data(MP3::MP3Frame& frame, BigEnd
auto const entry = MP3::Tables::Huffman::huffman_decode(reservoir, count1table, granule.part_2_3_length - granule_bits_read);
granule_bits_read += entry.bits_read;
if (!entry.code.has_value())
return LoaderError { LoaderError::Category::Format, m_loaded_samples, "Frame contains invalid huffman data." };
return LoaderError { LoaderError::Category::Format, m_loaded_samples, "Frame contains invalid huffman data."_fly_string };
int v = entry.code->symbol.v;
if (v != 0) {
if (granule_bits_read >= granule.part_2_3_length)
@ -628,7 +628,7 @@ MaybeLoaderError MP3LoaderPlugin::read_huffman_data(MP3::MP3Frame& frame, BigEnd
}
if (granule_bits_read > granule.part_2_3_length) {
return LoaderError { LoaderError::Category::Format, m_loaded_samples, "Read too many bits from bit reservoir." };
return LoaderError { LoaderError::Category::Format, m_loaded_samples, "Read too many bits from bit reservoir."_fly_string };
}
// 2.4.3.4.6: "If there are more Huffman code bits than necessary to decode 576 values

10
Userland/Libraries/LibAudio/QOALoader.cpp
View File

@ -48,7 +48,7 @@ MaybeLoaderError QOALoaderPlugin::parse_header()
{
u32 header_magic = TRY(m_stream->read_value<BigEndian<u32>>());
if (header_magic != QOA::magic)
return LoaderError { LoaderError::Category::Format, 0, "QOA header: Magic number must be 'qoaf'" };
return LoaderError { LoaderError::Category::Format, 0, "QOA header: Magic number must be 'qoaf'"_fly_string };
m_total_samples = TRY(m_stream->read_value<BigEndian<u32>>());
@ -62,9 +62,9 @@ MaybeLoaderError QOALoaderPlugin::load_one_frame(Span<Sample>& target, IsFirstFr
if (header.num_channels > 8)
dbgln("QOALoader: Warning: QOA frame at {} has more than 8 channels ({}), this is not supported by the reference implementation.", TRY(m_stream->tell()) - sizeof(QOA::FrameHeader), header.num_channels);
if (header.num_channels == 0)
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "QOA frame: Number of channels must be greater than 0" };
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "QOA frame: Number of channels must be greater than 0"_fly_string };
if (header.sample_count > QOA::max_frame_samples)
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "QOA frame: Too many samples in frame" };
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "QOA frame: Too many samples in frame"_fly_string };
// We weren't given a large enough buffer; signal that we didn't write anything and return.
if (header.sample_count > target.size()) {
@ -105,7 +105,7 @@ MaybeLoaderError QOALoaderPlugin::load_one_frame(Span<Sample>& target, IsFirstFr
m_sample_rate = header.sample_rate;
} else {
if (m_sample_rate != header.sample_rate)
return LoaderError { LoaderError::Category::Unimplemented, TRY(m_stream->tell()), "QOA: Differing sample rate in non-initial frame" };
return LoaderError { LoaderError::Category::Unimplemented, TRY(m_stream->tell()), "QOA: Differing sample rate in non-initial frame"_fly_string };
if (m_num_channels != header.num_channels)
m_has_uniform_channel_count = false;
}
@ -189,7 +189,7 @@ MaybeLoaderError QOALoaderPlugin::seek(int sample_index)
// A QOA file consists of 8 bytes header followed by a number of usually fixed-size frames.
// This fixed bitrate allows us to seek in constant time.
if (!m_has_uniform_channel_count)
return LoaderError { LoaderError::Category::Unimplemented, TRY(m_stream->tell()), "QOA with non-uniform channel count is currently not seekable"sv };
return LoaderError { LoaderError::Category::Unimplemented, TRY(m_stream->tell()), "QOA with non-uniform channel count is currently not seekable"_fly_string };
/// FIXME: Change the Loader API to use size_t.
VERIFY(sample_index >= 0);
// We seek to the frame "before"; i.e. the frame that contains that sample.

12
Userland/Libraries/LibAudio/WavLoader.cpp
View File

@ -165,7 +165,7 @@ MaybeLoaderError WavLoaderPlugin::seek(int sample_index)
{
dbgln_if(AWAVLOADER_DEBUG, "seek sample_index {}", sample_index);
if (sample_index < 0 || sample_index >= static_cast<int>(m_total_samples))
return LoaderError { LoaderError::Category::Internal, m_loaded_samples, "Seek outside the sample range" };
return LoaderError { LoaderError::Category::Internal, m_loaded_samples, "Seek outside the sample range"_fly_string };
size_t sample_offset = m_byte_offset_of_data_samples + static_cast<size_t>(sample_index * m_num_channels * (pcm_bits_per_sample(m_sample_format) / 8));
@ -178,11 +178,11 @@ MaybeLoaderError WavLoaderPlugin::seek(int sample_index)
// Specification reference: http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
MaybeLoaderError WavLoaderPlugin::parse_header()
{
#define CHECK(check, category, msg) \
do { \
if (!(check)) { \
return LoaderError { category, static_cast<size_t>(TRY(m_stream->tell())), ByteString::formatted("WAV header: {}", msg) }; \
} \
#define CHECK(check, category, msg) \
do { \
if (!(check)) { \
return LoaderError { category, static_cast<size_t>(TRY(m_stream->tell())), TRY(String::formatted("WAV header: {}", msg)) }; \
} \
} while (0)
auto file_header = TRY(m_stream->read_value<RIFF::FileHeader>());