mirror of
https://github.com/RGBCube/serenity
synced 2025-05-14 06:24:58 +00:00
LibAudio: Stop using and remove LOADER_TRY
It's no longer needed now that this code uses ErrorOr instead of Result.
Ran:
rg -lw LOADER_TRY Userland/Libraries/LibAudio \
| xargs sed -i '' 's/LOADER_TRY/TRY/g'
...and then manually fixed up Userland/Libraries/LibAudio/LoaderError.h
to not redefine TRY but instead remove the now-unused LOADER_TRY,
and ran clang-format.
This commit is contained in:
Nico Weber
Andrew Kaster
parent
9594b79d38
commit
5619bb3e04
6 changed files with 166 additions and 177 deletions
|
|
@ -62,15 +62,15 @@ 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, LOADER_TRY(m_stream->tell()), DeprecatedString::formatted("FLAC header: {}", msg) }; \
|
||||
} \
|
||||
#define FLAC_VERIFY(check, category, msg) \
|
||||
do { \
|
||||
if (!(check)) { \
|
||||
return LoaderError { category, TRY(m_stream->tell()), DeprecatedString::formatted("FLAC header: {}", msg) }; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
// Magic number
|
||||
u32 flac = LOADER_TRY(bit_input.read_bits<u32>(32));
|
||||
u32 flac = TRY(bit_input.read_bits<u32>(32));
|
||||
m_data_start_location += 4;
|
||||
FLAC_VERIFY(flac == 0x664C6143, LoaderError::Category::Format, "Magic number must be 'flaC'"); // "flaC"
|
||||
|
||||
|
|
@ -81,17 +81,17 @@ MaybeLoaderError FlacLoaderPlugin::parse_header()
|
|||
BigEndianInputBitStream streaminfo_data { MaybeOwned<Stream>(streaminfo_data_memory) };
|
||||
|
||||
// 11.10 METADATA_BLOCK_STREAMINFO
|
||||
m_min_block_size = LOADER_TRY(streaminfo_data.read_bits<u16>(16));
|
||||
m_min_block_size = TRY(streaminfo_data.read_bits<u16>(16));
|
||||
FLAC_VERIFY(m_min_block_size >= 16, LoaderError::Category::Format, "Minimum block size must be 16");
|
||||
m_max_block_size = LOADER_TRY(streaminfo_data.read_bits<u16>(16));
|
||||
m_max_block_size = TRY(streaminfo_data.read_bits<u16>(16));
|
||||
FLAC_VERIFY(m_max_block_size >= 16, LoaderError::Category::Format, "Maximum block size");
|
||||
m_min_frame_size = LOADER_TRY(streaminfo_data.read_bits<u32>(24));
|
||||
m_max_frame_size = LOADER_TRY(streaminfo_data.read_bits<u32>(24));
|
||||
m_sample_rate = LOADER_TRY(streaminfo_data.read_bits<u32>(20));
|
||||
m_min_frame_size = TRY(streaminfo_data.read_bits<u32>(24));
|
||||
m_max_frame_size = TRY(streaminfo_data.read_bits<u32>(24));
|
||||
m_sample_rate = TRY(streaminfo_data.read_bits<u32>(20));
|
||||
FLAC_VERIFY(m_sample_rate <= 655350, LoaderError::Category::Format, "Sample rate");
|
||||
m_num_channels = LOADER_TRY(streaminfo_data.read_bits<u8>(3)) + 1; // 0 = one channel
|
||||
m_num_channels = TRY(streaminfo_data.read_bits<u8>(3)) + 1; // 0 = one channel
|
||||
|
||||
m_bits_per_sample = LOADER_TRY(streaminfo_data.read_bits<u8>(5)) + 1;
|
||||
m_bits_per_sample = TRY(streaminfo_data.read_bits<u8>(5)) + 1;
|
||||
if (m_bits_per_sample <= 8) {
|
||||
// FIXME: Signed/Unsigned issues?
|
||||
m_sample_format = PcmSampleFormat::Uint8;
|
||||
|
|
@ -105,7 +105,7 @@ MaybeLoaderError FlacLoaderPlugin::parse_header()
|
|||
FLAC_VERIFY(false, LoaderError::Category::Format, "Sample bit depth too large");
|
||||
}
|
||||
|
||||
m_total_samples = LOADER_TRY(streaminfo_data.read_bits<u64>(36));
|
||||
m_total_samples = TRY(streaminfo_data.read_bits<u64>(36));
|
||||
if (m_total_samples == 0) {
|
||||
// "A value of zero here means the number of total samples is unknown."
|
||||
dbgln("FLAC Warning: File has unknown amount of samples, the loader will not stop before EOF");
|
||||
|
|
@ -113,7 +113,7 @@ MaybeLoaderError FlacLoaderPlugin::parse_header()
|
|||
}
|
||||
|
||||
VERIFY(streaminfo_data.is_aligned_to_byte_boundary());
|
||||
LOADER_TRY(streaminfo_data.read_until_filled({ m_md5_checksum, sizeof(m_md5_checksum) }));
|
||||
TRY(streaminfo_data.read_until_filled({ m_md5_checksum, sizeof(m_md5_checksum) }));
|
||||
|
||||
// Parse other blocks
|
||||
[[maybe_unused]] u16 meta_blocks_parsed = 1;
|
||||
|
|
@ -158,39 +158,39 @@ MaybeLoaderError FlacLoaderPlugin::load_picture(FlacRawMetadataBlock& block)
|
|||
|
||||
PictureData picture;
|
||||
|
||||
picture.type = static_cast<ID3PictureType>(LOADER_TRY(picture_block_bytes.read_bits(32)));
|
||||
picture.type = static_cast<ID3PictureType>(TRY(picture_block_bytes.read_bits(32)));
|
||||
|
||||
auto const mime_string_length = LOADER_TRY(picture_block_bytes.read_bits(32));
|
||||
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, LOADER_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" };
|
||||
|
||||
// "The MIME type string, in printable ASCII characters 0x20-0x7E."
|
||||
picture.mime_string = LOADER_TRY(String::from_stream(memory_stream, mime_string_length));
|
||||
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, LOADER_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" };
|
||||
}
|
||||
|
||||
auto const description_string_length = LOADER_TRY(picture_block_bytes.read_bits(32));
|
||||
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, LOADER_TRY(m_stream->tell()), "Picture description exceeds available data" };
|
||||
return LoaderError { LoaderError::Category::Format, TRY(m_stream->tell()), "Picture description exceeds available data" };
|
||||
|
||||
picture.description_string = LOADER_TRY(String::from_stream(memory_stream, description_string_length));
|
||||
picture.description_string = TRY(String::from_stream(memory_stream, description_string_length));
|
||||
|
||||
picture.width = LOADER_TRY(picture_block_bytes.read_bits(32));
|
||||
picture.height = LOADER_TRY(picture_block_bytes.read_bits(32));
|
||||
picture.width = TRY(picture_block_bytes.read_bits(32));
|
||||
picture.height = TRY(picture_block_bytes.read_bits(32));
|
||||
|
||||
picture.color_depth = LOADER_TRY(picture_block_bytes.read_bits(32));
|
||||
picture.colors = LOADER_TRY(picture_block_bytes.read_bits(32));
|
||||
picture.color_depth = TRY(picture_block_bytes.read_bits(32));
|
||||
picture.colors = TRY(picture_block_bytes.read_bits(32));
|
||||
|
||||
auto const picture_size = LOADER_TRY(picture_block_bytes.read_bits(32));
|
||||
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" };
|
||||
|
||||
LOADER_TRY(memory_stream.seek(picture_size, SeekMode::FromCurrentPosition));
|
||||
TRY(memory_stream.seek(picture_size, SeekMode::FromCurrentPosition));
|
||||
picture.data = Vector<u8> { block.data.bytes().slice(offset_before_seeking, picture_size) };
|
||||
|
||||
m_pictures.append(move(picture));
|
||||
|
|
@ -216,10 +216,10 @@ MaybeLoaderError FlacLoaderPlugin::load_seektable(FlacRawMetadataBlock& block)
|
|||
BigEndianInputBitStream seektable_bytes { MaybeOwned<Stream>(memory_stream) };
|
||||
for (size_t i = 0; i < block.length / 18; ++i) {
|
||||
// 11.14. SEEKPOINT
|
||||
u64 sample_index = LOADER_TRY(seektable_bytes.read_bits<u64>(64));
|
||||
u64 byte_offset = LOADER_TRY(seektable_bytes.read_bits<u64>(64));
|
||||
u64 sample_index = TRY(seektable_bytes.read_bits<u64>(64));
|
||||
u64 byte_offset = TRY(seektable_bytes.read_bits<u64>(64));
|
||||
// The sample count of a seek point is not relevant to us.
|
||||
[[maybe_unused]] u16 sample_count = LOADER_TRY(seektable_bytes.read_bits<u16>(16));
|
||||
[[maybe_unused]] u16 sample_count = TRY(seektable_bytes.read_bits<u16>(16));
|
||||
// Placeholder, to be ignored.
|
||||
if (sample_index == 0xFFFFFFFFFFFFFFFF)
|
||||
continue;
|
||||
|
|
@ -238,13 +238,13 @@ MaybeLoaderError FlacLoaderPlugin::load_seektable(FlacRawMetadataBlock& block)
|
|||
ErrorOr<FlacRawMetadataBlock, LoaderError> FlacLoaderPlugin::next_meta_block(BigEndianInputBitStream& bit_input)
|
||||
{
|
||||
// 11.7 METADATA_BLOCK_HEADER
|
||||
bool is_last_block = LOADER_TRY(bit_input.read_bit());
|
||||
bool is_last_block = TRY(bit_input.read_bit());
|
||||
// The block type enum constants agree with the specification
|
||||
FlacMetadataBlockType type = (FlacMetadataBlockType)LOADER_TRY(bit_input.read_bits<u8>(7));
|
||||
FlacMetadataBlockType type = (FlacMetadataBlockType)TRY(bit_input.read_bits<u8>(7));
|
||||
m_data_start_location += 1;
|
||||
FLAC_VERIFY(type != FlacMetadataBlockType::INVALID, LoaderError::Category::Format, "Invalid metadata block");
|
||||
|
||||
u32 block_length = LOADER_TRY(bit_input.read_bits<u32>(24));
|
||||
u32 block_length = TRY(bit_input.read_bits<u32>(24));
|
||||
m_data_start_location += 3;
|
||||
// Blocks can be zero-sized, which would trip up the raw data reader below.
|
||||
if (block_length == 0)
|
||||
|
|
@ -252,13 +252,13 @@ ErrorOr<FlacRawMetadataBlock, LoaderError> FlacLoaderPlugin::next_meta_block(Big
|
|||
.is_last_block = is_last_block,
|
||||
.type = type,
|
||||
.length = 0,
|
||||
.data = LOADER_TRY(ByteBuffer::create_uninitialized(0))
|
||||
.data = TRY(ByteBuffer::create_uninitialized(0))
|
||||
};
|
||||
auto block_data_result = ByteBuffer::create_uninitialized(block_length);
|
||||
FLAC_VERIFY(!block_data_result.is_error(), LoaderError::Category::IO, "Out of memory");
|
||||
auto block_data = block_data_result.release_value();
|
||||
|
||||
LOADER_TRY(bit_input.read_until_filled(block_data));
|
||||
TRY(bit_input.read_until_filled(block_data));
|
||||
|
||||
m_data_start_location += block_length;
|
||||
return FlacRawMetadataBlock {
|
||||
|
|
@ -288,7 +288,7 @@ MaybeLoaderError FlacLoaderPlugin::seek(int int_sample_index)
|
|||
// No seektable or no fitting entry: Perform normal forward read
|
||||
if (!maybe_target_seekpoint.has_value()) {
|
||||
if (sample_index < m_loaded_samples) {
|
||||
LOADER_TRY(m_stream->seek(m_data_start_location, SeekMode::SetPosition));
|
||||
TRY(m_stream->seek(m_data_start_location, SeekMode::SetPosition));
|
||||
m_loaded_samples = 0;
|
||||
}
|
||||
if (sample_index - m_loaded_samples == 0)
|
||||
|
|
@ -381,50 +381,50 @@ LoaderSamples FlacLoaderPlugin::next_frame()
|
|||
// TODO: Check the CRC-16 checksum by keeping track of read data.
|
||||
|
||||
// 11.22. FRAME_HEADER
|
||||
u16 sync_code = LOADER_TRY(bit_stream.read_bits<u16>(14));
|
||||
u16 sync_code = TRY(bit_stream.read_bits<u16>(14));
|
||||
FLAC_VERIFY(sync_code == 0b11111111111110, LoaderError::Category::Format, "Sync code");
|
||||
bool reserved_bit = LOADER_TRY(bit_stream.read_bit());
|
||||
bool reserved_bit = TRY(bit_stream.read_bit());
|
||||
FLAC_VERIFY(reserved_bit == 0, LoaderError::Category::Format, "Reserved frame header bit");
|
||||
// 11.22.2. BLOCKING STRATEGY
|
||||
[[maybe_unused]] bool blocking_strategy = LOADER_TRY(bit_stream.read_bit());
|
||||
[[maybe_unused]] bool blocking_strategy = TRY(bit_stream.read_bit());
|
||||
|
||||
u32 sample_count = TRY(convert_sample_count_code(LOADER_TRY(bit_stream.read_bits<u8>(4))));
|
||||
u32 sample_count = TRY(convert_sample_count_code(TRY(bit_stream.read_bits<u8>(4))));
|
||||
|
||||
u32 frame_sample_rate = TRY(convert_sample_rate_code(LOADER_TRY(bit_stream.read_bits<u8>(4))));
|
||||
u32 frame_sample_rate = TRY(convert_sample_rate_code(TRY(bit_stream.read_bits<u8>(4))));
|
||||
|
||||
u8 channel_type_num = LOADER_TRY(bit_stream.read_bits<u8>(4));
|
||||
u8 channel_type_num = TRY(bit_stream.read_bits<u8>(4));
|
||||
FLAC_VERIFY(channel_type_num < 0b1011, LoaderError::Category::Format, "Channel assignment");
|
||||
FlacFrameChannelType channel_type = (FlacFrameChannelType)channel_type_num;
|
||||
|
||||
u8 bit_depth = TRY(convert_bit_depth_code(LOADER_TRY(bit_stream.read_bits<u8>(3))));
|
||||
u8 bit_depth = TRY(convert_bit_depth_code(TRY(bit_stream.read_bits<u8>(3))));
|
||||
|
||||
reserved_bit = LOADER_TRY(bit_stream.read_bit());
|
||||
reserved_bit = TRY(bit_stream.read_bit());
|
||||
FLAC_VERIFY(reserved_bit == 0, LoaderError::Category::Format, "Reserved frame header end bit");
|
||||
|
||||
// 11.22.8. CODED NUMBER
|
||||
m_current_sample_or_frame = LOADER_TRY(read_utf8_char(bit_stream));
|
||||
m_current_sample_or_frame = TRY(read_utf8_char(bit_stream));
|
||||
|
||||
// Conditional header variables
|
||||
// 11.22.9. BLOCK SIZE INT
|
||||
if (sample_count == FLAC_BLOCKSIZE_AT_END_OF_HEADER_8) {
|
||||
sample_count = LOADER_TRY(bit_stream.read_bits<u32>(8)) + 1;
|
||||
sample_count = TRY(bit_stream.read_bits<u32>(8)) + 1;
|
||||
} else if (sample_count == FLAC_BLOCKSIZE_AT_END_OF_HEADER_16) {
|
||||
sample_count = LOADER_TRY(bit_stream.read_bits<u32>(16)) + 1;
|
||||
sample_count = TRY(bit_stream.read_bits<u32>(16)) + 1;
|
||||
}
|
||||
|
||||
// 11.22.10. SAMPLE RATE INT
|
||||
if (frame_sample_rate == FLAC_SAMPLERATE_AT_END_OF_HEADER_8) {
|
||||
frame_sample_rate = LOADER_TRY(bit_stream.read_bits<u32>(8)) * 1000;
|
||||
frame_sample_rate = TRY(bit_stream.read_bits<u32>(8)) * 1000;
|
||||
} else if (frame_sample_rate == FLAC_SAMPLERATE_AT_END_OF_HEADER_16) {
|
||||
frame_sample_rate = LOADER_TRY(bit_stream.read_bits<u32>(16));
|
||||
frame_sample_rate = TRY(bit_stream.read_bits<u32>(16));
|
||||
} else if (frame_sample_rate == FLAC_SAMPLERATE_AT_END_OF_HEADER_16X10) {
|
||||
frame_sample_rate = LOADER_TRY(bit_stream.read_bits<u32>(16)) * 10;
|
||||
frame_sample_rate = TRY(bit_stream.read_bits<u32>(16)) * 10;
|
||||
}
|
||||
|
||||
// It does not matter whether we extract the checksum from the digest here, or extract the digest 0x00 after processing the checksum.
|
||||
auto const calculated_checksum = checksum_stream->digest();
|
||||
// 11.22.11. FRAME CRC
|
||||
u8 specified_checksum = LOADER_TRY(bit_stream.read_bits<u8>(8));
|
||||
u8 specified_checksum = TRY(bit_stream.read_bits<u8>(8));
|
||||
VERIFY(bit_stream.is_aligned_to_byte_boundary());
|
||||
if (specified_checksum != calculated_checksum)
|
||||
dbgln("FLAC frame {}: Calculated header checksum {:02x} is different from specified checksum {:02x}", m_current_sample_or_frame, calculated_checksum, specified_checksum);
|
||||
|
|
@ -455,7 +455,7 @@ LoaderSamples FlacLoaderPlugin::next_frame()
|
|||
|
||||
// 11.23. FRAME_FOOTER
|
||||
// TODO: check checksum, see above
|
||||
[[maybe_unused]] u16 footer_checksum = LOADER_TRY(bit_stream.read_bits<u16>(16));
|
||||
[[maybe_unused]] u16 footer_checksum = TRY(bit_stream.read_bits<u16>(16));
|
||||
dbgln_if(AFLACLOADER_DEBUG, "Subframe footer checksum: {}", footer_checksum);
|
||||
|
||||
float sample_rescale = 1 / static_cast<float>(1 << (m_current_frame->bit_depth - 1));
|
||||
|
|
@ -628,11 +628,11 @@ ErrorOr<FlacSubframeHeader, LoaderError> FlacLoaderPlugin::next_subframe_header(
|
|||
}
|
||||
|
||||
// zero-bit padding
|
||||
if (LOADER_TRY(bit_stream.read_bit()) != 0)
|
||||
if (TRY(bit_stream.read_bit()) != 0)
|
||||
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Zero bit padding" };
|
||||
|
||||
// 11.25.1. SUBFRAME TYPE
|
||||
u8 subframe_code = LOADER_TRY(bit_stream.read_bits<u8>(6));
|
||||
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" };
|
||||
|
||||
|
|
@ -651,12 +651,12 @@ ErrorOr<FlacSubframeHeader, LoaderError> FlacLoaderPlugin::next_subframe_header(
|
|||
}
|
||||
|
||||
// 11.25.2. WASTED BITS PER SAMPLE FLAG
|
||||
bool has_wasted_bits = LOADER_TRY(bit_stream.read_bit());
|
||||
bool has_wasted_bits = TRY(bit_stream.read_bit());
|
||||
u8 k = 0;
|
||||
if (has_wasted_bits) {
|
||||
bool current_k_bit = 0;
|
||||
do {
|
||||
current_k_bit = LOADER_TRY(bit_stream.read_bit());
|
||||
current_k_bit = TRY(bit_stream.read_bit());
|
||||
++k;
|
||||
} while (current_k_bit != 1);
|
||||
}
|
||||
|
|
@ -676,7 +676,7 @@ ErrorOr<Vector<i64>, LoaderError> FlacLoaderPlugin::parse_subframe(FlacSubframeH
|
|||
switch (subframe_header.type) {
|
||||
case FlacSubframeType::Constant: {
|
||||
// 11.26. SUBFRAME_CONSTANT
|
||||
u64 constant_value = LOADER_TRY(bit_input.read_bits<u64>(subframe_header.bits_per_sample - subframe_header.wasted_bits_per_sample));
|
||||
u64 constant_value = TRY(bit_input.read_bits<u64>(subframe_header.bits_per_sample - subframe_header.wasted_bits_per_sample));
|
||||
dbgln_if(AFLACLOADER_DEBUG, "Constant subframe: {}", constant_value);
|
||||
|
||||
samples.ensure_capacity(m_current_frame->sample_count);
|
||||
|
|
@ -728,7 +728,7 @@ ErrorOr<Vector<i64>, LoaderError> FlacLoaderPlugin::decode_verbatim(FlacSubframe
|
|||
VERIFY(subframe.bits_per_sample - subframe.wasted_bits_per_sample != 0);
|
||||
for (size_t i = 0; i < m_current_frame->sample_count; ++i) {
|
||||
decoded.unchecked_append(sign_extend(
|
||||
LOADER_TRY(bit_input.read_bits<u64>(subframe.bits_per_sample - subframe.wasted_bits_per_sample)),
|
||||
TRY(bit_input.read_bits<u64>(subframe.bits_per_sample - subframe.wasted_bits_per_sample)),
|
||||
subframe.bits_per_sample - subframe.wasted_bits_per_sample));
|
||||
}
|
||||
|
||||
|
|
@ -750,24 +750,24 @@ ErrorOr<Vector<i64>, LoaderError> FlacLoaderPlugin::decode_custom_lpc(FlacSubfra
|
|||
// warm-up samples
|
||||
for (auto i = 0; i < subframe.order; ++i) {
|
||||
decoded.unchecked_append(sign_extend(
|
||||
LOADER_TRY(bit_input.read_bits<u64>(subframe.bits_per_sample - subframe.wasted_bits_per_sample)),
|
||||
TRY(bit_input.read_bits<u64>(subframe.bits_per_sample - subframe.wasted_bits_per_sample)),
|
||||
subframe.bits_per_sample - subframe.wasted_bits_per_sample));
|
||||
}
|
||||
|
||||
// precision of the coefficients
|
||||
u8 lpc_precision = LOADER_TRY(bit_input.read_bits<u8>(4));
|
||||
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" };
|
||||
lpc_precision += 1;
|
||||
|
||||
// shift needed on the data (signed!)
|
||||
i8 lpc_shift = static_cast<i8>(sign_extend(LOADER_TRY(bit_input.read_bits<u8>(5)), 5));
|
||||
i8 lpc_shift = static_cast<i8>(sign_extend(TRY(bit_input.read_bits<u8>(5)), 5));
|
||||
|
||||
Vector<i64> coefficients;
|
||||
coefficients.ensure_capacity(subframe.order);
|
||||
// read coefficients
|
||||
for (auto i = 0; i < subframe.order; ++i) {
|
||||
u64 raw_coefficient = LOADER_TRY(bit_input.read_bits<u64>(lpc_precision));
|
||||
u64 raw_coefficient = TRY(bit_input.read_bits<u64>(lpc_precision));
|
||||
i64 coefficient = sign_extend(raw_coefficient, lpc_precision);
|
||||
coefficients.unchecked_append(coefficient);
|
||||
}
|
||||
|
|
@ -809,7 +809,7 @@ ErrorOr<Vector<i64>, LoaderError> FlacLoaderPlugin::decode_fixed_lpc(FlacSubfram
|
|||
// warm-up samples
|
||||
for (auto i = 0; i < subframe.order; ++i) {
|
||||
decoded.unchecked_append(sign_extend(
|
||||
LOADER_TRY(bit_input.read_bits<u64>(subframe.bits_per_sample - subframe.wasted_bits_per_sample)),
|
||||
TRY(bit_input.read_bits<u64>(subframe.bits_per_sample - subframe.wasted_bits_per_sample)),
|
||||
subframe.bits_per_sample - subframe.wasted_bits_per_sample));
|
||||
}
|
||||
|
||||
|
|
@ -871,8 +871,8 @@ ErrorOr<Vector<i64>, LoaderError> FlacLoaderPlugin::decode_fixed_lpc(FlacSubfram
|
|||
MaybeLoaderError FlacLoaderPlugin::decode_residual(Vector<i64>& decoded, FlacSubframeHeader& subframe, BigEndianInputBitStream& bit_input)
|
||||
{
|
||||
// 11.30.1. RESIDUAL_CODING_METHOD
|
||||
auto residual_mode = static_cast<FlacResidualMode>(LOADER_TRY(bit_input.read_bits<u8>(2)));
|
||||
u8 partition_order = LOADER_TRY(bit_input.read_bits<u8>(4));
|
||||
auto residual_mode = static_cast<FlacResidualMode>(TRY(bit_input.read_bits<u8>(2)));
|
||||
u8 partition_order = TRY(bit_input.read_bits<u8>(4));
|
||||
size_t partitions = 1 << partition_order;
|
||||
|
||||
if (partitions > m_current_frame->sample_count)
|
||||
|
|
@ -903,7 +903,7 @@ MaybeLoaderError FlacLoaderPlugin::decode_residual(Vector<i64>& decoded, FlacSub
|
|||
ALWAYS_INLINE ErrorOr<Vector<i64>, LoaderError> FlacLoaderPlugin::decode_rice_partition(u8 partition_type, u32 partitions, u32 partition_index, FlacSubframeHeader& subframe, BigEndianInputBitStream& bit_input)
|
||||
{
|
||||
// 11.30.2.2. EXP GOLOMB PARTITION ENCODING PARAMETER and 11.30.3.2. EXP-GOLOMB2 PARTITION ENCODING PARAMETER
|
||||
u8 k = LOADER_TRY(bit_input.read_bits<u8>(partition_type));
|
||||
u8 k = TRY(bit_input.read_bits<u8>(partition_type));
|
||||
|
||||
u32 residual_sample_count;
|
||||
if (partitions == 0)
|
||||
|
|
@ -921,13 +921,13 @@ ALWAYS_INLINE ErrorOr<Vector<i64>, LoaderError> FlacLoaderPlugin::decode_rice_pa
|
|||
|
||||
// escape code for unencoded binary partition
|
||||
if (k == (1 << partition_type) - 1) {
|
||||
u8 unencoded_bps = LOADER_TRY(bit_input.read_bits<u8>(5));
|
||||
u8 unencoded_bps = TRY(bit_input.read_bits<u8>(5));
|
||||
for (size_t r = 0; r < residual_sample_count; ++r) {
|
||||
rice_partition[r] = LOADER_TRY(bit_input.read_bits<u8>(unencoded_bps));
|
||||
rice_partition[r] = TRY(bit_input.read_bits<u8>(unencoded_bps));
|
||||
}
|
||||
} else {
|
||||
for (size_t r = 0; r < residual_sample_count; ++r) {
|
||||
rice_partition[r] = LOADER_TRY(decode_unsigned_exp_golomb(k, bit_input));
|
||||
rice_partition[r] = TRY(decode_unsigned_exp_golomb(k, bit_input));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -44,12 +44,12 @@ static constexpr LoaderPluginInitializer s_initializers[] = {
|
|||
|
||||
ErrorOr<NonnullRefPtr<Loader>, LoaderError> Loader::create(StringView path)
|
||||
{
|
||||
auto stream = LOADER_TRY(Core::InputBufferedFile::create(LOADER_TRY(Core::File::open(path, Core::File::OpenMode::Read))));
|
||||
auto stream = TRY(Core::InputBufferedFile::create(TRY(Core::File::open(path, Core::File::OpenMode::Read))));
|
||||
return adopt_ref(*new (nothrow) Loader(TRY(Loader::create_plugin(move(stream)))));
|
||||
}
|
||||
ErrorOr<NonnullRefPtr<Loader>, LoaderError> Loader::create(Bytes buffer)
|
||||
{
|
||||
auto stream = LOADER_TRY(try_make<FixedMemoryStream>(buffer));
|
||||
auto stream = TRY(try_make<FixedMemoryStream>(buffer));
|
||||
return adopt_ref(*new (nothrow) Loader(TRY(Loader::create_plugin(move(stream)))));
|
||||
}
|
||||
|
||||
|
|
@ -70,7 +70,7 @@ LoaderSamples Loader::get_more_samples(size_t samples_to_read_from_input)
|
|||
{
|
||||
size_t remaining_samples = total_samples() - loaded_samples();
|
||||
size_t samples_to_read = min(remaining_samples, samples_to_read_from_input);
|
||||
auto samples = LOADER_TRY(FixedArray<Sample>::create(samples_to_read));
|
||||
auto samples = TRY(FixedArray<Sample>::create(samples_to_read));
|
||||
|
||||
size_t sample_index = 0;
|
||||
|
||||
|
|
@ -98,11 +98,11 @@ LoaderSamples Loader::get_more_samples(size_t samples_to_read_from_input)
|
|||
if (count < chunk.size()) {
|
||||
auto remaining_samples_count = chunk.size() - count;
|
||||
// We will always have an empty buffer at this point!
|
||||
LOADER_TRY(m_buffer.try_append(chunk.span().offset(count), remaining_samples_count));
|
||||
TRY(m_buffer.try_append(chunk.span().offset(count), remaining_samples_count));
|
||||
}
|
||||
} else {
|
||||
// We're now past what the user requested. Transfer the entirety of the data into the buffer.
|
||||
LOADER_TRY(m_buffer.try_append(chunk.data(), chunk.size()));
|
||||
TRY(m_buffer.try_append(chunk.data(), chunk.size()));
|
||||
}
|
||||
sample_index += chunk.size();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -94,14 +94,3 @@ struct Formatter<Audio::LoaderError> : Formatter<FormatString> {
|
|||
};
|
||||
|
||||
}
|
||||
|
||||
// Convenience TRY-like macro to convert an Error to a LoaderError
|
||||
#define LOADER_TRY(expression) \
|
||||
({ \
|
||||
auto&& _temporary_result = (expression); \
|
||||
if (_temporary_result.is_error()) \
|
||||
return LoaderError(_temporary_result.release_error()); \
|
||||
static_assert(!::AK::Detail::IsLvalueReference<decltype(_temporary_result.release_value())>, \
|
||||
"Do not return a reference from a fallible expression"); \
|
||||
_temporary_result.release_value(); \
|
||||
})
|
||||
|
|
|
|||
|
|
@ -49,13 +49,13 @@ bool MP3LoaderPlugin::sniff(SeekableStream& stream)
|
|||
ErrorOr<NonnullOwnPtr<LoaderPlugin>, LoaderError> MP3LoaderPlugin::create(NonnullOwnPtr<SeekableStream> stream)
|
||||
{
|
||||
auto loader = make<MP3LoaderPlugin>(move(stream));
|
||||
LOADER_TRY(loader->initialize());
|
||||
TRY(loader->initialize());
|
||||
return loader;
|
||||
}
|
||||
|
||||
MaybeLoaderError MP3LoaderPlugin::initialize()
|
||||
{
|
||||
m_bitstream = LOADER_TRY(try_make<BigEndianInputBitStream>(MaybeOwned<Stream>(*m_stream)));
|
||||
m_bitstream = TRY(try_make<BigEndianInputBitStream>(MaybeOwned<Stream>(*m_stream)));
|
||||
|
||||
TRY(synchronize());
|
||||
|
||||
|
|
@ -69,7 +69,7 @@ MaybeLoaderError MP3LoaderPlugin::initialize()
|
|||
|
||||
TRY(build_seek_table());
|
||||
|
||||
LOADER_TRY(m_stream->seek(0, SeekMode::SetPosition));
|
||||
TRY(m_stream->seek(0, SeekMode::SetPosition));
|
||||
|
||||
return {};
|
||||
}
|
||||
|
|
@ -80,7 +80,7 @@ MaybeLoaderError MP3LoaderPlugin::reset()
|
|||
m_current_frame = {};
|
||||
m_synthesis_buffer = {};
|
||||
m_loaded_samples = 0;
|
||||
LOADER_TRY(m_bit_reservoir.discard(m_bit_reservoir.used_buffer_size()));
|
||||
TRY(m_bit_reservoir.discard(m_bit_reservoir.used_buffer_size()));
|
||||
m_bitstream->align_to_byte_boundary();
|
||||
return {};
|
||||
}
|
||||
|
|
@ -89,12 +89,12 @@ MaybeLoaderError MP3LoaderPlugin::seek(int const position)
|
|||
{
|
||||
auto seek_entry = m_seek_table.seek_point_before(position);
|
||||
if (seek_entry.has_value()) {
|
||||
LOADER_TRY(m_stream->seek(seek_entry->byte_offset, SeekMode::SetPosition));
|
||||
TRY(m_stream->seek(seek_entry->byte_offset, SeekMode::SetPosition));
|
||||
m_loaded_samples = seek_entry->sample_index;
|
||||
}
|
||||
m_current_frame = {};
|
||||
m_synthesis_buffer = {};
|
||||
LOADER_TRY(m_bit_reservoir.discard(m_bit_reservoir.used_buffer_size()));
|
||||
TRY(m_bit_reservoir.discard(m_bit_reservoir.used_buffer_size()));
|
||||
m_bitstream->align_to_byte_boundary();
|
||||
return {};
|
||||
}
|
||||
|
|
@ -104,7 +104,7 @@ ErrorOr<Vector<FixedArray<Sample>>, LoaderError> MP3LoaderPlugin::load_chunks(si
|
|||
int samples_to_read = samples_to_read_from_input;
|
||||
Vector<FixedArray<Sample>> frames;
|
||||
while (samples_to_read > 0) {
|
||||
FixedArray<Sample> samples = LOADER_TRY(FixedArray<Sample>::create(MP3::frame_size));
|
||||
FixedArray<Sample> samples = TRY(FixedArray<Sample>::create(MP3::frame_size));
|
||||
|
||||
if (!m_current_frame.has_value()) {
|
||||
auto maybe_frame = read_next_frame();
|
||||
|
|
@ -150,7 +150,7 @@ MaybeLoaderError MP3LoaderPlugin::build_seek_table()
|
|||
m_bitstream->align_to_byte_boundary();
|
||||
|
||||
while (!synchronize().is_error()) {
|
||||
auto const frame_pos = -2 + LOADER_TRY(m_stream->seek(0, SeekMode::FromCurrentPosition));
|
||||
auto const frame_pos = -2 + TRY(m_stream->seek(0, SeekMode::FromCurrentPosition));
|
||||
|
||||
auto error_or_header = read_header();
|
||||
if (error_or_header.is_error() || error_or_header.value().id != 1 || error_or_header.value().layer != 3) {
|
||||
|
|
@ -160,9 +160,9 @@ MaybeLoaderError MP3LoaderPlugin::build_seek_table()
|
|||
sample_count += MP3::frame_size;
|
||||
|
||||
if (frame_count % 10 == 0)
|
||||
LOADER_TRY(m_seek_table.insert_seek_point({ static_cast<u64>(sample_count), frame_pos }));
|
||||
TRY(m_seek_table.insert_seek_point({ static_cast<u64>(sample_count), frame_pos }));
|
||||
|
||||
LOADER_TRY(m_stream->seek(error_or_header.value().frame_size - 6, SeekMode::FromCurrentPosition));
|
||||
TRY(m_stream->seek(error_or_header.value().frame_size - 6, SeekMode::FromCurrentPosition));
|
||||
|
||||
// TODO: This is just here to clear the bitstream buffer.
|
||||
// Bitstream should have a method to sync its state to the underlying stream.
|
||||
|
|
@ -175,26 +175,26 @@ MaybeLoaderError MP3LoaderPlugin::build_seek_table()
|
|||
ErrorOr<MP3::Header, LoaderError> MP3LoaderPlugin::read_header()
|
||||
{
|
||||
MP3::Header header;
|
||||
header.id = LOADER_TRY(m_bitstream->read_bit());
|
||||
header.layer = MP3::Tables::LayerNumberLookup[LOADER_TRY(m_bitstream->read_bits(2))];
|
||||
header.id = TRY(m_bitstream->read_bit());
|
||||
header.layer = MP3::Tables::LayerNumberLookup[TRY(m_bitstream->read_bits(2))];
|
||||
if (header.layer <= 0)
|
||||
return LoaderError { LoaderError::Category::Format, m_loaded_samples, "Frame header contains invalid layer number." };
|
||||
header.protection_bit = LOADER_TRY(m_bitstream->read_bit());
|
||||
header.bitrate = MP3::Tables::BitratesPerLayerLookup[header.layer - 1][LOADER_TRY(m_bitstream->read_bits(4))];
|
||||
header.protection_bit = TRY(m_bitstream->read_bit());
|
||||
header.bitrate = MP3::Tables::BitratesPerLayerLookup[header.layer - 1][TRY(m_bitstream->read_bits(4))];
|
||||
if (header.bitrate <= 0)
|
||||
return LoaderError { LoaderError::Category::Format, m_loaded_samples, "Frame header contains invalid bitrate." };
|
||||
header.samplerate = MP3::Tables::SampleratesLookup[LOADER_TRY(m_bitstream->read_bits(2))];
|
||||
header.samplerate = MP3::Tables::SampleratesLookup[TRY(m_bitstream->read_bits(2))];
|
||||
if (header.samplerate <= 0)
|
||||
return LoaderError { LoaderError::Category::Format, m_loaded_samples, "Frame header contains invalid samplerate." };
|
||||
header.padding_bit = LOADER_TRY(m_bitstream->read_bit());
|
||||
header.private_bit = LOADER_TRY(m_bitstream->read_bit());
|
||||
header.mode = static_cast<MP3::Mode>(LOADER_TRY(m_bitstream->read_bits(2)));
|
||||
header.mode_extension = static_cast<MP3::ModeExtension>(LOADER_TRY(m_bitstream->read_bits(2)));
|
||||
header.copyright_bit = LOADER_TRY(m_bitstream->read_bit());
|
||||
header.original_bit = LOADER_TRY(m_bitstream->read_bit());
|
||||
header.emphasis = static_cast<MP3::Emphasis>(LOADER_TRY(m_bitstream->read_bits(2)));
|
||||
header.padding_bit = TRY(m_bitstream->read_bit());
|
||||
header.private_bit = TRY(m_bitstream->read_bit());
|
||||
header.mode = static_cast<MP3::Mode>(TRY(m_bitstream->read_bits(2)));
|
||||
header.mode_extension = static_cast<MP3::ModeExtension>(TRY(m_bitstream->read_bits(2)));
|
||||
header.copyright_bit = TRY(m_bitstream->read_bit());
|
||||
header.original_bit = TRY(m_bitstream->read_bit());
|
||||
header.emphasis = static_cast<MP3::Emphasis>(TRY(m_bitstream->read_bits(2)));
|
||||
if (!header.protection_bit)
|
||||
header.crc16 = LOADER_TRY(m_bitstream->read_bits<u16>(16));
|
||||
header.crc16 = TRY(m_bitstream->read_bits<u16>(16));
|
||||
header.frame_size = 144 * header.bitrate * 1000 / header.samplerate + header.padding_bit;
|
||||
header.slot_count = header.frame_size - ((header.channel_count() == 2 ? 32 : 17) + (header.protection_bit ? 0 : 2) + 4);
|
||||
return header;
|
||||
|
|
@ -204,7 +204,7 @@ MaybeLoaderError MP3LoaderPlugin::synchronize(BigEndianInputBitStream& stream, s
|
|||
{
|
||||
size_t one_counter = 0;
|
||||
while (one_counter < 12 && !stream.is_eof()) {
|
||||
bool const bit = LOADER_TRY(stream.read_bit());
|
||||
bool const bit = TRY(stream.read_bit());
|
||||
one_counter = bit ? one_counter + 1 : 0;
|
||||
if (!bit) {
|
||||
stream.align_to_byte_boundary();
|
||||
|
|
@ -247,8 +247,8 @@ ErrorOr<MP3::MP3Frame, LoaderError> MP3LoaderPlugin::read_frame_data(MP3::Header
|
|||
auto& buffer = maybe_buffer.value();
|
||||
|
||||
size_t old_reservoir_size = m_bit_reservoir.used_buffer_size();
|
||||
LOADER_TRY(m_bitstream->read_until_filled(buffer));
|
||||
LOADER_TRY(m_bit_reservoir.write_until_depleted(buffer));
|
||||
TRY(m_bitstream->read_until_filled(buffer));
|
||||
TRY(m_bit_reservoir.write_until_depleted(buffer));
|
||||
|
||||
// If we don't have enough data in the reservoir to process this frame, skip it (but keep the data).
|
||||
if (old_reservoir_size < static_cast<size_t>(frame.main_data_begin))
|
||||
|
|
@ -326,46 +326,46 @@ ErrorOr<MP3::MP3Frame, LoaderError> MP3LoaderPlugin::read_frame_data(MP3::Header
|
|||
|
||||
MaybeLoaderError MP3LoaderPlugin::read_side_information(MP3::MP3Frame& frame)
|
||||
{
|
||||
frame.main_data_begin = LOADER_TRY(m_bitstream->read_bits(9));
|
||||
frame.main_data_begin = TRY(m_bitstream->read_bits(9));
|
||||
|
||||
if (frame.header.channel_count() == 1) {
|
||||
frame.private_bits = LOADER_TRY(m_bitstream->read_bits(5));
|
||||
frame.private_bits = TRY(m_bitstream->read_bits(5));
|
||||
} else {
|
||||
frame.private_bits = LOADER_TRY(m_bitstream->read_bits(3));
|
||||
frame.private_bits = TRY(m_bitstream->read_bits(3));
|
||||
}
|
||||
|
||||
for (size_t channel_index = 0; channel_index < frame.header.channel_count(); channel_index++) {
|
||||
for (size_t scale_factor_selection_info_band = 0; scale_factor_selection_info_band < 4; scale_factor_selection_info_band++) {
|
||||
frame.channels[channel_index].scale_factor_selection_info[scale_factor_selection_info_band] = LOADER_TRY(m_bitstream->read_bit());
|
||||
frame.channels[channel_index].scale_factor_selection_info[scale_factor_selection_info_band] = TRY(m_bitstream->read_bit());
|
||||
}
|
||||
}
|
||||
|
||||
for (size_t granule_index = 0; granule_index < 2; granule_index++) {
|
||||
for (size_t channel_index = 0; channel_index < frame.header.channel_count(); channel_index++) {
|
||||
auto& granule = frame.channels[channel_index].granules[granule_index];
|
||||
granule.part_2_3_length = LOADER_TRY(m_bitstream->read_bits(12));
|
||||
granule.big_values = LOADER_TRY(m_bitstream->read_bits(9));
|
||||
granule.global_gain = LOADER_TRY(m_bitstream->read_bits(8));
|
||||
granule.scalefac_compress = LOADER_TRY(m_bitstream->read_bits(4));
|
||||
granule.window_switching_flag = LOADER_TRY(m_bitstream->read_bit());
|
||||
granule.part_2_3_length = TRY(m_bitstream->read_bits(12));
|
||||
granule.big_values = TRY(m_bitstream->read_bits(9));
|
||||
granule.global_gain = TRY(m_bitstream->read_bits(8));
|
||||
granule.scalefac_compress = TRY(m_bitstream->read_bits(4));
|
||||
granule.window_switching_flag = TRY(m_bitstream->read_bit());
|
||||
if (granule.window_switching_flag) {
|
||||
granule.block_type = static_cast<MP3::BlockType>(LOADER_TRY(m_bitstream->read_bits(2)));
|
||||
granule.mixed_block_flag = LOADER_TRY(m_bitstream->read_bit());
|
||||
granule.block_type = static_cast<MP3::BlockType>(TRY(m_bitstream->read_bits(2)));
|
||||
granule.mixed_block_flag = TRY(m_bitstream->read_bit());
|
||||
for (size_t region = 0; region < 2; region++)
|
||||
granule.table_select[region] = LOADER_TRY(m_bitstream->read_bits(5));
|
||||
granule.table_select[region] = TRY(m_bitstream->read_bits(5));
|
||||
for (size_t window = 0; window < 3; window++)
|
||||
granule.sub_block_gain[window] = LOADER_TRY(m_bitstream->read_bits(3));
|
||||
granule.sub_block_gain[window] = TRY(m_bitstream->read_bits(3));
|
||||
granule.region0_count = (granule.block_type == MP3::BlockType::Short && !granule.mixed_block_flag) ? 8 : 7;
|
||||
granule.region1_count = 36;
|
||||
} else {
|
||||
for (size_t region = 0; region < 3; region++)
|
||||
granule.table_select[region] = LOADER_TRY(m_bitstream->read_bits(5));
|
||||
granule.region0_count = LOADER_TRY(m_bitstream->read_bits(4));
|
||||
granule.region1_count = LOADER_TRY(m_bitstream->read_bits(3));
|
||||
granule.table_select[region] = TRY(m_bitstream->read_bits(5));
|
||||
granule.region0_count = TRY(m_bitstream->read_bits(4));
|
||||
granule.region1_count = TRY(m_bitstream->read_bits(3));
|
||||
}
|
||||
granule.preflag = LOADER_TRY(m_bitstream->read_bit());
|
||||
granule.scalefac_scale = LOADER_TRY(m_bitstream->read_bit());
|
||||
granule.count1table_select = LOADER_TRY(m_bitstream->read_bit());
|
||||
granule.preflag = TRY(m_bitstream->read_bit());
|
||||
granule.scalefac_scale = TRY(m_bitstream->read_bit());
|
||||
granule.count1table_select = TRY(m_bitstream->read_bit());
|
||||
}
|
||||
}
|
||||
return {};
|
||||
|
|
@ -551,21 +551,21 @@ MaybeLoaderError MP3LoaderPlugin::read_huffman_data(MP3::MP3Frame& frame, BigEnd
|
|||
int y = entry.code->symbol.y;
|
||||
|
||||
if (x == 15 && tree->linbits > 0) {
|
||||
x += LOADER_TRY(reservoir.read_bits(tree->linbits));
|
||||
x += TRY(reservoir.read_bits(tree->linbits));
|
||||
granule_bits_read += tree->linbits;
|
||||
}
|
||||
if (x != 0) {
|
||||
if (LOADER_TRY(reservoir.read_bit()))
|
||||
if (TRY(reservoir.read_bit()))
|
||||
x = -x;
|
||||
granule_bits_read++;
|
||||
}
|
||||
|
||||
if (y == 15 && tree->linbits > 0) {
|
||||
y += LOADER_TRY(reservoir.read_bits(tree->linbits));
|
||||
y += TRY(reservoir.read_bits(tree->linbits));
|
||||
granule_bits_read += tree->linbits;
|
||||
}
|
||||
if (y != 0) {
|
||||
if (LOADER_TRY(reservoir.read_bit()))
|
||||
if (TRY(reservoir.read_bit()))
|
||||
y = -y;
|
||||
granule_bits_read++;
|
||||
}
|
||||
|
|
@ -589,7 +589,7 @@ MaybeLoaderError MP3LoaderPlugin::read_huffman_data(MP3::MP3Frame& frame, BigEnd
|
|||
if (v != 0) {
|
||||
if (granule_bits_read >= granule.part_2_3_length)
|
||||
break;
|
||||
if (LOADER_TRY(reservoir.read_bit()))
|
||||
if (TRY(reservoir.read_bit()))
|
||||
v = -v;
|
||||
granule_bits_read++;
|
||||
}
|
||||
|
|
@ -597,7 +597,7 @@ MaybeLoaderError MP3LoaderPlugin::read_huffman_data(MP3::MP3Frame& frame, BigEnd
|
|||
if (w != 0) {
|
||||
if (granule_bits_read >= granule.part_2_3_length)
|
||||
break;
|
||||
if (LOADER_TRY(reservoir.read_bit()))
|
||||
if (TRY(reservoir.read_bit()))
|
||||
w = -w;
|
||||
granule_bits_read++;
|
||||
}
|
||||
|
|
@ -605,7 +605,7 @@ MaybeLoaderError MP3LoaderPlugin::read_huffman_data(MP3::MP3Frame& frame, BigEnd
|
|||
if (x != 0) {
|
||||
if (granule_bits_read >= granule.part_2_3_length)
|
||||
break;
|
||||
if (LOADER_TRY(reservoir.read_bit()))
|
||||
if (TRY(reservoir.read_bit()))
|
||||
x = -x;
|
||||
granule_bits_read++;
|
||||
}
|
||||
|
|
@ -613,7 +613,7 @@ MaybeLoaderError MP3LoaderPlugin::read_huffman_data(MP3::MP3Frame& frame, BigEnd
|
|||
if (y != 0) {
|
||||
if (granule_bits_read >= granule.part_2_3_length)
|
||||
break;
|
||||
if (LOADER_TRY(reservoir.read_bit()))
|
||||
if (TRY(reservoir.read_bit()))
|
||||
y = -y;
|
||||
granule_bits_read++;
|
||||
}
|
||||
|
|
@ -633,7 +633,7 @@ MaybeLoaderError MP3LoaderPlugin::read_huffman_data(MP3::MP3Frame& frame, BigEnd
|
|||
// 2.4.3.4.6: "If there are more Huffman code bits than necessary to decode 576 values
|
||||
// they are regarded as stuffing bits and discarded."
|
||||
for (size_t i = granule_bits_read; i < granule.part_2_3_length; i++) {
|
||||
LOADER_TRY(reservoir.read_bit());
|
||||
TRY(reservoir.read_bit());
|
||||
}
|
||||
|
||||
return {};
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ bool QOALoaderPlugin::sniff(SeekableStream& stream)
|
|||
ErrorOr<NonnullOwnPtr<LoaderPlugin>, LoaderError> QOALoaderPlugin::create(NonnullOwnPtr<SeekableStream> stream)
|
||||
{
|
||||
auto loader = make<QOALoaderPlugin>(move(stream));
|
||||
LOADER_TRY(loader->initialize());
|
||||
TRY(loader->initialize());
|
||||
return loader;
|
||||
}
|
||||
|
||||
|
|
@ -46,46 +46,46 @@ MaybeLoaderError QOALoaderPlugin::initialize()
|
|||
|
||||
MaybeLoaderError QOALoaderPlugin::parse_header()
|
||||
{
|
||||
u32 header_magic = LOADER_TRY(m_stream->read_value<BigEndian<u32>>());
|
||||
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'" };
|
||||
|
||||
m_total_samples = LOADER_TRY(m_stream->read_value<BigEndian<u32>>());
|
||||
m_total_samples = TRY(m_stream->read_value<BigEndian<u32>>());
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
MaybeLoaderError QOALoaderPlugin::load_one_frame(Span<Sample>& target, IsFirstFrame is_first_frame)
|
||||
{
|
||||
QOA::FrameHeader header = LOADER_TRY(m_stream->read_value<QOA::FrameHeader>());
|
||||
QOA::FrameHeader header = TRY(m_stream->read_value<QOA::FrameHeader>());
|
||||
|
||||
if (header.num_channels > 8)
|
||||
dbgln("QOALoader: Warning: QOA frame at {} has more than 8 channels ({}), this is not supported by the reference implementation.", LOADER_TRY(m_stream->tell()) - sizeof(QOA::FrameHeader), header.num_channels);
|
||||
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, LOADER_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" };
|
||||
if (header.sample_count > QOA::max_frame_samples)
|
||||
return LoaderError { LoaderError::Category::Format, LOADER_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" };
|
||||
|
||||
// We weren't given a large enough buffer; signal that we didn't write anything and return.
|
||||
if (header.sample_count > target.size()) {
|
||||
target = target.trim(0);
|
||||
LOADER_TRY(m_stream->seek(-sizeof(QOA::frame_header_size), AK::SeekMode::FromCurrentPosition));
|
||||
TRY(m_stream->seek(-sizeof(QOA::frame_header_size), AK::SeekMode::FromCurrentPosition));
|
||||
return {};
|
||||
}
|
||||
|
||||
target = target.trim(header.sample_count);
|
||||
|
||||
auto lms_states = LOADER_TRY(FixedArray<QOA::LMSState>::create(header.num_channels));
|
||||
auto lms_states = TRY(FixedArray<QOA::LMSState>::create(header.num_channels));
|
||||
for (size_t channel = 0; channel < header.num_channels; ++channel) {
|
||||
auto history_packed = LOADER_TRY(m_stream->read_value<BigEndian<u64>>());
|
||||
auto weights_packed = LOADER_TRY(m_stream->read_value<BigEndian<u64>>());
|
||||
auto history_packed = TRY(m_stream->read_value<BigEndian<u64>>());
|
||||
auto weights_packed = TRY(m_stream->read_value<BigEndian<u64>>());
|
||||
lms_states[channel] = { history_packed, weights_packed };
|
||||
}
|
||||
|
||||
// We pre-allocate very large arrays here, but that's the last allocation of the QOA loader!
|
||||
// Everything else is just shuffling data around.
|
||||
// (We will also be using all of the arrays in every frame but the last one.)
|
||||
auto channels = LOADER_TRY((FixedArray<Array<i16, QOA::max_frame_samples>>::create(header.num_channels)));
|
||||
auto channels = TRY((FixedArray<Array<i16, QOA::max_frame_samples>>::create(header.num_channels)));
|
||||
|
||||
// There's usually (and at maximum) 256 slices per channel, but less at the very end.
|
||||
// If the final slice would be partial, we still need to decode it; integer division would tell us that this final slice doesn't exist.
|
||||
|
|
@ -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, LOADER_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" };
|
||||
if (m_num_channels != header.num_channels)
|
||||
m_has_uniform_channel_count = false;
|
||||
}
|
||||
|
|
@ -148,17 +148,17 @@ ErrorOr<Vector<FixedArray<Sample>>, LoaderError> QOALoaderPlugin::load_chunks(si
|
|||
size_t current_loaded_samples = 0;
|
||||
|
||||
while (current_loaded_samples < samples_to_read) {
|
||||
auto samples = LOADER_TRY(FixedArray<Sample>::create(QOA::max_frame_samples));
|
||||
auto samples = TRY(FixedArray<Sample>::create(QOA::max_frame_samples));
|
||||
auto slice_to_load_into = samples.span();
|
||||
TRY(this->load_one_frame(slice_to_load_into, is_first_frame));
|
||||
is_first_frame = IsFirstFrame::No;
|
||||
VERIFY(slice_to_load_into.size() <= QOA::max_frame_samples);
|
||||
current_loaded_samples += slice_to_load_into.size();
|
||||
if (slice_to_load_into.size() != samples.size()) {
|
||||
auto smaller_samples = LOADER_TRY(FixedArray<Sample>::create(slice_to_load_into));
|
||||
auto smaller_samples = TRY(FixedArray<Sample>::create(slice_to_load_into));
|
||||
samples.swap(smaller_samples);
|
||||
}
|
||||
LOADER_TRY(frames.try_append(move(samples)));
|
||||
TRY(frames.try_append(move(samples)));
|
||||
|
||||
if (slice_to_load_into.size() != samples.size())
|
||||
break;
|
||||
|
|
@ -170,14 +170,14 @@ ErrorOr<Vector<FixedArray<Sample>>, LoaderError> QOALoaderPlugin::load_chunks(si
|
|||
|
||||
MaybeLoaderError QOALoaderPlugin::reset()
|
||||
{
|
||||
LOADER_TRY(m_stream->seek(QOA::header_size, AK::SeekMode::SetPosition));
|
||||
TRY(m_stream->seek(QOA::header_size, AK::SeekMode::SetPosition));
|
||||
m_loaded_samples = 0;
|
||||
// Read the first frame, then seek back to the beginning. This is necessary since the first frame contains the sample rate and channel count.
|
||||
auto frame_samples = LOADER_TRY(FixedArray<Sample>::create(QOA::max_frame_samples));
|
||||
auto frame_samples = TRY(FixedArray<Sample>::create(QOA::max_frame_samples));
|
||||
auto span = frame_samples.span();
|
||||
LOADER_TRY(load_one_frame(span, IsFirstFrame::Yes));
|
||||
TRY(load_one_frame(span, IsFirstFrame::Yes));
|
||||
|
||||
LOADER_TRY(m_stream->seek(QOA::header_size, AK::SeekMode::SetPosition));
|
||||
TRY(m_stream->seek(QOA::header_size, AK::SeekMode::SetPosition));
|
||||
m_loaded_samples = 0;
|
||||
return {};
|
||||
}
|
||||
|
|
@ -189,14 +189,14 @@ 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, LOADER_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"sv };
|
||||
/// 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.
|
||||
auto const frame_of_sample = static_cast<size_t>(AK::floor<double>(static_cast<double>(sample_index) / static_cast<double>(QOA::max_frame_samples)));
|
||||
auto const frame_size = QOA::frame_header_size + m_num_channels * (QOA::lms_state_size + sizeof(QOA::PackedSlice) * QOA::max_slices_per_frame);
|
||||
auto const byte_index = QOA::header_size + frame_of_sample * frame_size;
|
||||
LOADER_TRY(m_stream->seek(byte_index, AK::SeekMode::SetPosition));
|
||||
TRY(m_stream->seek(byte_index, AK::SeekMode::SetPosition));
|
||||
m_loaded_samples = frame_of_sample * QOA::max_frame_samples;
|
||||
return {};
|
||||
}
|
||||
|
|
@ -205,7 +205,7 @@ MaybeLoaderError QOALoaderPlugin::read_one_slice(QOA::LMSState& lms_state, Span<
|
|||
{
|
||||
VERIFY(samples.size() == QOA::slice_samples);
|
||||
|
||||
auto packed_slice = LOADER_TRY(m_stream->read_value<BigEndian<u64>>());
|
||||
auto packed_slice = TRY(m_stream->read_value<BigEndian<u64>>());
|
||||
auto unpacked_slice = unpack_slice(packed_slice);
|
||||
|
||||
for (size_t i = 0; i < QOA::slice_samples; ++i) {
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ bool WavLoaderPlugin::sniff(SeekableStream& stream)
|
|||
ErrorOr<NonnullOwnPtr<LoaderPlugin>, LoaderError> WavLoaderPlugin::create(NonnullOwnPtr<SeekableStream> stream)
|
||||
{
|
||||
auto loader = make<WavLoaderPlugin>(move(stream));
|
||||
LOADER_TRY(loader->parse_header());
|
||||
TRY(loader->parse_header());
|
||||
return loader;
|
||||
}
|
||||
|
||||
|
|
@ -52,12 +52,12 @@ MaybeLoaderError WavLoaderPlugin::read_samples_from_stream(Stream& stream, Sampl
|
|||
switch (m_num_channels) {
|
||||
case 1:
|
||||
for (auto& sample : samples)
|
||||
sample = Sample(LOADER_TRY(read_sample(stream)));
|
||||
sample = Sample(TRY(read_sample(stream)));
|
||||
break;
|
||||
case 2:
|
||||
for (auto& sample : samples) {
|
||||
auto left_channel_sample = LOADER_TRY(read_sample(stream));
|
||||
auto right_channel_sample = LOADER_TRY(read_sample(stream));
|
||||
auto left_channel_sample = TRY(read_sample(stream));
|
||||
auto right_channel_sample = TRY(read_sample(stream));
|
||||
sample = Sample(left_channel_sample, right_channel_sample);
|
||||
}
|
||||
break;
|
||||
|
|
@ -106,7 +106,7 @@ static ErrorOr<double> read_sample(Stream& stream)
|
|||
|
||||
LoaderSamples WavLoaderPlugin::samples_from_pcm_data(Bytes const& data, size_t samples_to_read) const
|
||||
{
|
||||
FixedArray<Sample> samples = LOADER_TRY(FixedArray<Sample>::create(samples_to_read));
|
||||
FixedArray<Sample> samples = TRY(FixedArray<Sample>::create(samples_to_read));
|
||||
FixedMemoryStream stream { data };
|
||||
|
||||
switch (m_sample_format) {
|
||||
|
|
@ -151,8 +151,8 @@ ErrorOr<Vector<FixedArray<Sample>>, LoaderError> WavLoaderPlugin::load_chunks(si
|
|||
bytes_to_read, m_num_channels, m_sample_rate,
|
||||
pcm_bits_per_sample(m_sample_format), sample_format_name(m_sample_format));
|
||||
|
||||
auto sample_data = LOADER_TRY(ByteBuffer::create_zeroed(bytes_to_read));
|
||||
LOADER_TRY(m_stream->read_until_filled(sample_data.bytes()));
|
||||
auto sample_data = TRY(ByteBuffer::create_zeroed(bytes_to_read));
|
||||
TRY(m_stream->read_until_filled(sample_data.bytes()));
|
||||
|
||||
// m_loaded_samples should contain the amount of actually loaded samples
|
||||
m_loaded_samples += samples_to_read;
|
||||
|
|
@ -169,7 +169,7 @@ MaybeLoaderError WavLoaderPlugin::seek(int sample_index)
|
|||
|
||||
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));
|
||||
|
||||
LOADER_TRY(m_stream->seek(sample_offset, SeekMode::SetPosition));
|
||||
TRY(m_stream->seek(sample_offset, SeekMode::SetPosition));
|
||||
|
||||
m_loaded_samples = sample_index;
|
||||
return {};
|
||||
|
|
@ -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>(LOADER_TRY(m_stream->tell())), DeprecatedString::formatted("WAV header: {}", msg) }; \
|
||||
} \
|
||||
#define CHECK(check, category, msg) \
|
||||
do { \
|
||||
if (!(check)) { \
|
||||
return LoaderError { category, static_cast<size_t>(TRY(m_stream->tell())), DeprecatedString::formatted("WAV header: {}", msg) }; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
auto riff = TRY(m_stream->read_value<RIFF::ChunkID>());
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue