Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-06 08:10:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibAudio/FlacLoader.cpp

949 lines
41 KiB
C++
Raw Normal View History

LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
/*
Everywhere: Use my new serenityos.org e-mail :^)
2022-01-13 12:07:00 +01:00
* Copyright (c) 2021, kleines Filmröllchen <filmroellchen@serenityos.org>
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/Debug.h>
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-08 19:23:00 -05:00
#include <AK/DeprecatedFlyString.h>
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
#include <AK/DeprecatedString.h>
LibAudio: Remove frame-wise copys from FlacLoader Previously, FlacLoader would read the data for each frame into a separate vector, which are then combined via extend() in the end. This incurs an avoidable copy per frame. By having the next_frame() function write into a given Span, there's only one vector allocated per call to get_more_samples(). This increases performance by at least 100% realtime, as measured by abench, from about 1200%-1300% to (usually) 1400% on complex test files.
2021-12-17 18:42:36 +01:00
#include <AK/FixedArray.h>
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
#include <AK/Format.h>
AK: Move integral log2 and exp to IntegerMath.h
2022-01-29 16:51:02 +01:00
#include <AK/IntegralMath.h>
Everywhere: Use AK/Math.h if applicable AK's version should see better inlining behaviors, than the LibM one. We avoid mixed usage for now though. Also clean up some stale math includes and improper floatingpoint usage.
2021-07-17 18:29:28 +02:00
#include <AK/Math.h>
LibAudio: Handle stream errors in FlacLoader The FlacLoader already has numerous checks for invalid data reads and for invalid stream states, but it never actually handles the stream errors on the stream object. By handling them properly we can actually run FuzzFlacLoader for longer than a few seconds before it hits the first assertion :^).
2021-08-01 05:42:09 -06:00
#include <AK/ScopeGuard.h>
LibAudio: Add an adjustable buffer size to FlacLoader This makes it easier to fine-tune the optimal input buffer size.
2021-12-16 23:18:49 +01:00
#include <AK/StdLibExtras.h>
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
#include <AK/Try.h>
LibAudio: Remove frame-wise copys from FlacLoader Previously, FlacLoader would read the data for each frame into a separate vector, which are then combined via extend() in the end. This incurs an avoidable copy per frame. By having the next_frame() function write into a given Span, there's only one vector allocated per call to get_more_samples(). This increases performance by at least 100% realtime, as measured by abench, from about 1200%-1300% to (usually) 1400% on complex test files.
2021-12-17 18:42:36 +01:00
#include <AK/TypedTransfer.h>
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
#include <AK/UFixedBigInt.h>
#include <LibAudio/FlacLoader.h>
#include <LibAudio/FlacTypes.h>
#include <LibAudio/LoaderError.h>
LibAudio+Userland: Remove Audio::LegacyBuffer The file is now renamed to Queue.h, and the Resampler APIs with LegacyBuffer are also removed. These changes look large because nobody actually needs Buffer.h (or Queue.h). It was mostly transitive dependencies on the massive list of includes in that header, which are now almost all gone. Instead, we include common things like Sample.h directly, which should give faster compile times as very few files actually need Queue.h.
2022-04-23 12:30:36 +02:00
#include <LibAudio/Resampler.h>
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
#include <LibCore/MemoryStream.h>
#include <LibCore/Stream.h>
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
namespace Audio {
AK: Move `Stream` and `SeekableStream` from `LibCore` `Stream` will be qualified as `AK::Stream` until we remove the `Core::Stream` namespace. `IODevice` now reuses the `SeekMode` that is defined by `SeekableStream`, since defining its own would require us to qualify it with `AK::SeekMode` everywhere.
2023-01-22 05:09:11 +01:00
FlacLoaderPlugin::FlacLoaderPlugin(NonnullOwnPtr<SeekableStream> stream)
LibAudio: Switch LoaderPlugin to a more traditional constructor pattern This now prepares all the needed (fallible) components before actually constructing a LoaderPlugin object, so we are no longer filling them in at an arbitrary later point in time.
2022-12-05 00:41:23 +01:00
: LoaderPlugin(move(stream))
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
}
LibAudio: Remove `try_` prefix from fallible LoaderPlugin methods
2023-01-28 20:12:17 +00:00
Result<NonnullOwnPtr<FlacLoaderPlugin>, LoaderError> FlacLoaderPlugin::create(StringView path)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
LibAudio: Switch LoaderPlugin to a more traditional constructor pattern This now prepares all the needed (fallible) components before actually constructing a LoaderPlugin object, so we are no longer filling them in at an arbitrary later point in time.
2022-12-05 00:41:23 +01:00
auto stream = LOADER_TRY(Core::Stream::BufferedFile::create(LOADER_TRY(Core::Stream::File::open(path, Core::Stream::OpenMode::Read))));
auto loader = make<FlacLoaderPlugin>(move(stream));
LOADER_TRY(loader->initialize());
return loader;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Remove `try_` prefix from fallible LoaderPlugin methods
2023-01-28 20:12:17 +00:00
Result<NonnullOwnPtr<FlacLoaderPlugin>, LoaderError> FlacLoaderPlugin::create(Bytes buffer)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
LibCore: Rename `MemoryStream` to `FixedMemoryStream` This is to differentiate between the upcoming `AllocatingMemoryStream`, which automatically allocates memory as needed instead of operating on a static memory area.
2022-12-07 15:47:44 +01:00
auto stream = LOADER_TRY(Core::Stream::FixedMemoryStream::construct(buffer));
LibAudio: Switch LoaderPlugin to a more traditional constructor pattern This now prepares all the needed (fallible) components before actually constructing a LoaderPlugin object, so we are no longer filling them in at an arbitrary later point in time.
2022-12-05 00:41:23 +01:00
auto loader = make<FlacLoaderPlugin>(move(stream));
LOADER_TRY(loader->initialize());
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
LibAudio: Switch LoaderPlugin to a more traditional constructor pattern This now prepares all the needed (fallible) components before actually constructing a LoaderPlugin object, so we are no longer filling them in at an arbitrary later point in time.
2022-12-05 00:41:23 +01:00
return loader;
}
MaybeLoaderError FlacLoaderPlugin::initialize()
{
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
TRY(parse_header());
TRY(reset());
return {};
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.5 STREAM
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
MaybeLoaderError FlacLoaderPlugin::parse_header()
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
AK: Move `Stream` and `SeekableStream` from `LibCore` `Stream` will be qualified as `AK::Stream` until we remove the `Core::Stream` namespace. `IODevice` now reuses the `SeekMode` that is defined by `SeekableStream`, since defining its own would require us to qualify it with `AK::SeekMode` everywhere.
2023-01-22 05:09:11 +01:00
auto bit_input = LOADER_TRY(BigEndianInputBitStream::construct(MaybeOwned<AK::Stream>(*m_stream)));
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
// A mixture of VERIFY and the non-crashing TRY().
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
#define FLAC_VERIFY(check, category, msg) \
do { \
if (!(check)) { \
return LoaderError { category, static_cast<size_t>(m_data_start_location), DeprecatedString::formatted("FLAC header: {}", msg) }; \
} \
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
} while (0)
// Magic number
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u32 flac = LOADER_TRY(bit_input->read_bits<u32>(32));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
m_data_start_location += 4;
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
FLAC_VERIFY(flac == 0x664C6143, LoaderError::Category::Format, "Magic number must be 'flaC'"); // "flaC"
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// Receive the streaminfo block
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
auto streaminfo = TRY(next_meta_block(*bit_input));
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
FLAC_VERIFY(streaminfo.type == FlacMetadataBlockType::STREAMINFO, LoaderError::Category::Format, "First block must be STREAMINFO");
LibCore: Rename `MemoryStream` to `FixedMemoryStream` This is to differentiate between the upcoming `AllocatingMemoryStream`, which automatically allocates memory as needed instead of operating on a static memory area.
2022-12-07 15:47:44 +01:00
auto streaminfo_data_memory = LOADER_TRY(Core::Stream::FixedMemoryStream::construct(streaminfo.data.bytes()));
AK: Move `Stream` and `SeekableStream` from `LibCore` `Stream` will be qualified as `AK::Stream` until we remove the `Core::Stream` namespace. `IODevice` now reuses the `SeekMode` that is defined by `SeekableStream`, since defining its own would require us to qualify it with `AK::SeekMode` everywhere.
2023-01-22 05:09:11 +01:00
auto streaminfo_data = LOADER_TRY(BigEndianInputBitStream::construct(MaybeOwned<AK::Stream>(*streaminfo_data_memory)));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.10 METADATA_BLOCK_STREAMINFO
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
m_min_block_size = LOADER_TRY(streaminfo_data->read_bits<u16>(16));
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
FLAC_VERIFY(m_min_block_size >= 16, LoaderError::Category::Format, "Minimum block size must be 16");
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
m_max_block_size = LOADER_TRY(streaminfo_data->read_bits<u16>(16));
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
FLAC_VERIFY(m_max_block_size >= 16, LoaderError::Category::Format, "Maximum block size");
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
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));
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
FLAC_VERIFY(m_sample_rate <= 655350, LoaderError::Category::Format, "Sample rate");
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
m_num_channels = LOADER_TRY(streaminfo_data->read_bits<u8>(3)) + 1; // 0 = one channel
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u8 bits_per_sample = LOADER_TRY(streaminfo_data->read_bits<u8>(5)) + 1;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
if (bits_per_sample == 8) {
// FIXME: Signed/Unsigned issues?
m_sample_format = PcmSampleFormat::Uint8;
} else if (bits_per_sample == 16) {
m_sample_format = PcmSampleFormat::Int16;
} else if (bits_per_sample == 24) {
m_sample_format = PcmSampleFormat::Int24;
} else if (bits_per_sample == 32) {
m_sample_format = PcmSampleFormat::Int32;
} else {
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
FLAC_VERIFY(false, LoaderError::Category::Format, "Sample bit depth invalid");
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
m_total_samples = LOADER_TRY(streaminfo_data->read_bits<u64>(36));
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
FLAC_VERIFY(m_total_samples > 0, LoaderError::Category::Format, "Number of samples is zero");
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// Parse checksum into a buffer first
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
[[maybe_unused]] u128 md5_checksum;
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
VERIFY(streaminfo_data->is_aligned_to_byte_boundary());
auto md5_bytes_read = LOADER_TRY(streaminfo_data->read(md5_checksum.bytes()));
LibCore+Everywhere: Make Core::Stream::read() return Bytes A mistake I've repeatedly made is along these lines: ```c++ auto nread = TRY(source_file->read(buffer)); TRY(destination_file->write(buffer)); ``` It's a little clunky to have to create a Bytes or StringView from the buffer's data pointer and the nread, and easy to forget and just use the buffer. So, this patch changes the read() function to return a Bytes of the data that were just read. The other read_foo() methods will be modified in the same way in subsequent commits. Fixes #13687
2022-04-15 13:33:02 +01:00
FLAC_VERIFY(md5_bytes_read.size() == md5_checksum.my_size(), LoaderError::Category::IO, "MD5 Checksum size");
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
md5_checksum.bytes().copy_to({ m_md5_checksum, sizeof(m_md5_checksum) });
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// Parse other blocks
[[maybe_unused]] u16 meta_blocks_parsed = 1;
[[maybe_unused]] u16 total_meta_blocks = meta_blocks_parsed;
FlacRawMetadataBlock block = streaminfo;
while (!block.is_last_block) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
block = TRY(next_meta_block(*bit_input));
FlacLoader: Parse SEEKTABLE header Populates m_seektable attribute with FlacSeekPoints. For more information see: https://datatracker.ietf.org/doc/html/draft-ietf-cellar-flac#section-11.13 Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:07:49 -08:00
switch (block.type) {
case (FlacMetadataBlockType::SEEKTABLE):
TRY(load_seektable(block));
break;
LibAudio: Parse the picture metadata block
2022-10-02 18:48:38 +02:00
case FlacMetadataBlockType::PICTURE:
TRY(load_picture(block));
break;
LibAudio: Explicitly support Application metadata block type
2022-10-02 16:41:12 +02:00
case FlacMetadataBlockType::APPLICATION:
// Note: Third-party library can encode specific data in this.
dbgln("Unknown 'Application' metadata block encountered.");
[[fallthrough]];
LibAudio: Explicitly support Padding metadata block type
2022-10-02 16:27:18 +02:00
case FlacMetadataBlockType::PADDING:
// Note: A padding block is empty and does not need any treatment.
FlacLoader: Parse SEEKTABLE header Populates m_seektable attribute with FlacSeekPoints. For more information see: https://datatracker.ietf.org/doc/html/draft-ietf-cellar-flac#section-11.13 Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:07:49 -08:00
default:
// TODO: Parse the remaining metadata block types.
break;
}
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
++total_meta_blocks;
}
LibAudio+LibDSP: Switch samples to 32-bit float instead of 64-bit float This has been overkill from the start, and it has been bugging me for a long time. With this change, we're probably a bit slower on most platforms but save huge amounts of space with all in-memory sample datastructures.
2022-05-06 22:14:16 +02:00
dbgln_if(AFLACLOADER_DEBUG, "Parsed FLAC header: blocksize {}-{}{}, framesize {}-{}, {}Hz, {}bit, {} channels, {} samples total ({:.2f}s), MD5 {}, data start at {:x} bytes, {} headers total (skipped {})", m_min_block_size, m_max_block_size, is_fixed_blocksize_stream() ? " (constant)" : "", m_min_frame_size, m_max_frame_size, m_sample_rate, pcm_bits_per_sample(m_sample_format), m_num_channels, m_total_samples, static_cast<float>(m_total_samples) / static_cast<float>(m_sample_rate), md5_checksum, m_data_start_location, total_meta_blocks, total_meta_blocks - meta_blocks_parsed);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
return {};
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Parse the picture metadata block
2022-10-02 18:48:38 +02:00
// 11.19. METADATA_BLOCK_PICTURE
MaybeLoaderError FlacLoaderPlugin::load_picture(FlacRawMetadataBlock& block)
{
LibCore: Rename `MemoryStream` to `FixedMemoryStream` This is to differentiate between the upcoming `AllocatingMemoryStream`, which automatically allocates memory as needed instead of operating on a static memory area.
2022-12-07 15:47:44 +01:00
auto memory_stream = LOADER_TRY(Core::Stream::FixedMemoryStream::construct(block.data.bytes()));
AK: Move `Stream` and `SeekableStream` from `LibCore` `Stream` will be qualified as `AK::Stream` until we remove the `Core::Stream` namespace. `IODevice` now reuses the `SeekMode` that is defined by `SeekableStream`, since defining its own would require us to qualify it with `AK::SeekMode` everywhere.
2023-01-22 05:09:11 +01:00
auto picture_block_bytes = LOADER_TRY(BigEndianInputBitStream::construct(MaybeOwned<AK::Stream>(*memory_stream)));
LibAudio: Parse the picture metadata block
2022-10-02 18:48:38 +02:00
PictureData picture {};
picture.type = static_cast<ID3PictureType>(LOADER_TRY(picture_block_bytes->read_bits(32)));
auto const mime_string_length = LOADER_TRY(picture_block_bytes->read_bits(32));
// Note: We are seeking before reading the value to ensure that we stayed inside buffer's size.
auto offset_before_seeking = memory_stream->offset();
AK: Move `Stream` and `SeekableStream` from `LibCore` `Stream` will be qualified as `AK::Stream` until we remove the `Core::Stream` namespace. `IODevice` now reuses the `SeekMode` that is defined by `SeekableStream`, since defining its own would require us to qualify it with `AK::SeekMode` everywhere.
2023-01-22 05:09:11 +01:00
LOADER_TRY(memory_stream->seek(mime_string_length, SeekMode::FromCurrentPosition));
LibAudio: Parse the picture metadata block
2022-10-02 18:48:38 +02:00
picture.mime_string = { block.data.bytes().data() + offset_before_seeking, (size_t)mime_string_length };
auto const description_string_length = LOADER_TRY(picture_block_bytes->read_bits(32));
offset_before_seeking = memory_stream->offset();
AK: Move `Stream` and `SeekableStream` from `LibCore` `Stream` will be qualified as `AK::Stream` until we remove the `Core::Stream` namespace. `IODevice` now reuses the `SeekMode` that is defined by `SeekableStream`, since defining its own would require us to qualify it with `AK::SeekMode` everywhere.
2023-01-22 05:09:11 +01:00
LOADER_TRY(memory_stream->seek(description_string_length, SeekMode::FromCurrentPosition));
LibAudio: Parse the picture metadata block
2022-10-02 18:48:38 +02:00
picture.description_string = Vector<u32> { Span<u32> { reinterpret_cast<u32*>(block.data.bytes().data() + offset_before_seeking), (size_t)description_string_length } };
picture.width = LOADER_TRY(picture_block_bytes->read_bits(32));
picture.height = LOADER_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));
auto const picture_size = LOADER_TRY(picture_block_bytes->read_bits(32));
offset_before_seeking = memory_stream->offset();
AK: Move `Stream` and `SeekableStream` from `LibCore` `Stream` will be qualified as `AK::Stream` until we remove the `Core::Stream` namespace. `IODevice` now reuses the `SeekMode` that is defined by `SeekableStream`, since defining its own would require us to qualify it with `AK::SeekMode` everywhere.
2023-01-22 05:09:11 +01:00
LOADER_TRY(memory_stream->seek(picture_size, SeekMode::FromCurrentPosition));
LibAudio: Parse the picture metadata block
2022-10-02 18:48:38 +02:00
picture.data = Vector<u8> { Span<u8> { block.data.bytes().data() + offset_before_seeking, (size_t)picture_size } };
m_pictures.append(move(picture));
return {};
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.13. METADATA_BLOCK_SEEKTABLE
FlacLoader: Parse SEEKTABLE header Populates m_seektable attribute with FlacSeekPoints. For more information see: https://datatracker.ietf.org/doc/html/draft-ietf-cellar-flac#section-11.13 Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:07:49 -08:00
MaybeLoaderError FlacLoaderPlugin::load_seektable(FlacRawMetadataBlock& block)
{
LibCore: Rename `MemoryStream` to `FixedMemoryStream` This is to differentiate between the upcoming `AllocatingMemoryStream`, which automatically allocates memory as needed instead of operating on a static memory area.
2022-12-07 15:47:44 +01:00
auto memory_stream = LOADER_TRY(Core::Stream::FixedMemoryStream::construct(block.data.bytes()));
AK: Move `Stream` and `SeekableStream` from `LibCore` `Stream` will be qualified as `AK::Stream` until we remove the `Core::Stream` namespace. `IODevice` now reuses the `SeekMode` that is defined by `SeekableStream`, since defining its own would require us to qualify it with `AK::SeekMode` everywhere.
2023-01-22 05:09:11 +01:00
auto seektable_bytes = LOADER_TRY(BigEndianInputBitStream::construct(MaybeOwned<AK::Stream>(*memory_stream)));
FlacLoader: Parse SEEKTABLE header Populates m_seektable attribute with FlacSeekPoints. For more information see: https://datatracker.ietf.org/doc/html/draft-ietf-cellar-flac#section-11.13 Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:07:49 -08:00
for (size_t i = 0; i < block.length / 18; ++i) {
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.14. SEEKPOINT
FlacLoader: Parse SEEKTABLE header Populates m_seektable attribute with FlacSeekPoints. For more information see: https://datatracker.ietf.org/doc/html/draft-ietf-cellar-flac#section-11.13 Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:07:49 -08:00
FlacSeekPoint seekpoint {
.sample_index = LOADER_TRY(seektable_bytes->read_bits<u64>(64)),
.byte_offset = LOADER_TRY(seektable_bytes->read_bits<u64>(64)),
.num_samples = LOADER_TRY(seektable_bytes->read_bits<u16>(16))
};
m_seektable.append(seekpoint);
}
FlacLoader: Use seektable for performing seek operations As a fallback, we perform primitive seek if there's no seektable. Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:43:18 -08:00
dbgln_if(AFLACLOADER_DEBUG, "Loaded seektable of size {}", m_seektable.size());
FlacLoader: Parse SEEKTABLE header Populates m_seektable attribute with FlacSeekPoints. For more information see: https://datatracker.ietf.org/doc/html/draft-ietf-cellar-flac#section-11.13 Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:07:49 -08:00
return {};
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.6 METADATA_BLOCK
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
ErrorOr<FlacRawMetadataBlock, LoaderError> FlacLoaderPlugin::next_meta_block(BigEndianInputBitStream& bit_input)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.7 METADATA_BLOCK_HEADER
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
bool is_last_block = LOADER_TRY(bit_input.read_bit());
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// The block type enum constants agree with the specification
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
FlacMetadataBlockType type = (FlacMetadataBlockType)LOADER_TRY(bit_input.read_bits<u8>(7));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
m_data_start_location += 1;
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
FLAC_VERIFY(type != FlacMetadataBlockType::INVALID, LoaderError::Category::Format, "Invalid metadata block");
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u32 block_length = LOADER_TRY(bit_input.read_bits<u32>(24));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
m_data_start_location += 3;
FlacLoader: Use seektable for performing seek operations As a fallback, we perform primitive seek if there's no seektable. Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:43:18 -08:00
// Blocks can be zero-sized, which would trip up the raw data reader below.
if (block_length == 0)
return FlacRawMetadataBlock {
.is_last_block = is_last_block,
.type = type,
.length = 0,
.data = LOADER_TRY(ByteBuffer::create_uninitialized(0))
};
Everywhere: Make ByteBuffer::{create_*,copy}() OOM-safe
2021-09-06 03:29:52 +04:30
auto block_data_result = ByteBuffer::create_uninitialized(block_length);
Everywhere: Convert ByteBuffer factory methods from Optional -> ErrorOr Apologies for the enormous commit, but I don't see a way to split this up nicely. In the vast majority of cases it's a simple change. A few extra places can use TRY instead of manual error checking though. :^)
2022-01-20 17:47:39 +00:00
FLAC_VERIFY(!block_data_result.is_error(), LoaderError::Category::IO, "Out of memory");
Everywhere: Make ByteBuffer::{create_*,copy}() OOM-safe
2021-09-06 03:29:52 +04:30
auto block_data = block_data_result.release_value();
LibAudio: Read FLAC Metadata blocks larger than the buffer size Out of 40/63 failed tests, this change reduces the number down to four. :^) See: #14683
2022-07-26 20:27:20 +02:00
// Blocks might exceed our buffer size.
auto bytes_left_to_read = block_data.bytes();
while (bytes_left_to_read.size()) {
auto read_bytes = LOADER_TRY(bit_input.read(bytes_left_to_read));
bytes_left_to_read = bytes_left_to_read.slice(read_bytes.size());
}
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
m_data_start_location += block_length;
return FlacRawMetadataBlock {
is_last_block,
type,
block_length,
block_data,
};
}
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
#undef FLAC_VERIFY
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
MaybeLoaderError FlacLoaderPlugin::reset()
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
LibAudio: Seek to the first frame on reset in FLAC The files weren't starting exactly from the beginning before. This happened because the parameter now takes the sample index, instead of a seekpoint.
2022-07-26 20:54:39 +02:00
TRY(seek(0));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
m_current_frame.clear();
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
return {};
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
FlacLoader: Use seektable for performing seek operations As a fallback, we perform primitive seek if there's no seektable. Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:43:18 -08:00
MaybeLoaderError FlacLoaderPlugin::seek(int int_sample_index)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
FlacLoader: Use seektable for performing seek operations As a fallback, we perform primitive seek if there's no seektable. Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:43:18 -08:00
auto sample_index = static_cast<size_t>(int_sample_index);
if (sample_index == m_loaded_samples)
return {};
auto maybe_target_seekpoint = m_seektable.last_matching([sample_index](auto& seekpoint) { return seekpoint.sample_index <= sample_index; });
// No seektable or no fitting entry: Perform normal forward read
if (!maybe_target_seekpoint.has_value()) {
if (sample_index < m_loaded_samples) {
AK: Move `Stream` and `SeekableStream` from `LibCore` `Stream` will be qualified as `AK::Stream` until we remove the `Core::Stream` namespace. `IODevice` now reuses the `SeekMode` that is defined by `SeekableStream`, since defining its own would require us to qualify it with `AK::SeekMode` everywhere.
2023-01-22 05:09:11 +01:00
LOADER_TRY(m_stream->seek(m_data_start_location, SeekMode::SetPosition));
FlacLoader: Use seektable for performing seek operations As a fallback, we perform primitive seek if there's no seektable. Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:43:18 -08:00
m_loaded_samples = 0;
}
auto to_read = sample_index - m_loaded_samples;
if (to_read == 0)
return {};
dbgln_if(AFLACLOADER_DEBUG, "Seeking {} samples manually", to_read);
(void)TRY(get_more_samples(to_read));
} else {
auto target_seekpoint = maybe_target_seekpoint.release_value();
// When a small seek happens, we may already be closer to the target than the seekpoint.
if (sample_index - target_seekpoint.sample_index > sample_index - m_loaded_samples) {
dbgln_if(AFLACLOADER_DEBUG, "Close enough to target: seeking {} samples manually", sample_index - m_loaded_samples);
(void)TRY(get_more_samples(sample_index - m_loaded_samples));
return {};
}
dbgln_if(AFLACLOADER_DEBUG, "Seeking to seektable: sample index {}, byte offset {}, sample count {}", target_seekpoint.sample_index, target_seekpoint.byte_offset, target_seekpoint.num_samples);
auto position = target_seekpoint.byte_offset + m_data_start_location;
AK: Move `Stream` and `SeekableStream` from `LibCore` `Stream` will be qualified as `AK::Stream` until we remove the `Core::Stream` namespace. `IODevice` now reuses the `SeekMode` that is defined by `SeekableStream`, since defining its own would require us to qualify it with `AK::SeekMode` everywhere.
2023-01-22 05:09:11 +01:00
if (m_stream->seek(static_cast<i64>(position), SeekMode::SetPosition).is_error())
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
return LoaderError { LoaderError::Category::IO, m_loaded_samples, DeprecatedString::formatted("Invalid seek position {}", position) };
FlacLoader: Use seektable for performing seek operations As a fallback, we perform primitive seek if there's no seektable. Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:43:18 -08:00
auto remaining_samples_after_seekpoint = sample_index - m_data_start_location;
if (remaining_samples_after_seekpoint > 0)
(void)TRY(get_more_samples(remaining_samples_after_seekpoint));
m_loaded_samples = target_seekpoint.sample_index;
}
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
return {};
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
LoaderSamples FlacLoaderPlugin::get_more_samples(size_t max_bytes_to_read_from_input)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
ssize_t remaining_samples = static_cast<ssize_t>(m_total_samples - m_loaded_samples);
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
if (remaining_samples <= 0)
LibAudio+Userland: Use new audio queue in client-server communication Previously, we were sending Buffers to the server whenever we had new audio data for it. This meant that for every audio enqueue action, we needed to create a new shared memory anonymous buffer, send that buffer's file descriptor over IPC (+recfd on the other side) and then map the buffer into the audio server's memory to be able to play it. This was fine for sending large chunks of audio data, like when playing existing audio files. However, in the future we want to move to real-time audio in some applications like Piano. This means that the size of buffers that are sent need to be very small, as just the size of a buffer itself is part of the audio latency. If we were to try real-time audio with the existing system, we would run into problems really quickly. Dealing with a continuous stream of new anonymous files like the current audio system is rather expensive, as we need Kernel help in multiple places. Additionally, every enqueue incurs an IPC call, which are not optimized for >1000 calls/second (which would be needed for real-time audio with buffer sizes of ~40 samples). So a fundamental change in how we handle audio sending in userspace is necessary. This commit moves the audio sending system onto a shared single producer circular queue (SSPCQ) (introduced with one of the previous commits). This queue is intended to live in shared memory and be accessed by multiple processes at the same time. It was specifically written to support the audio sending case, so e.g. it only supports a single producer (the audio client). Now, audio sending follows these general steps: - The audio client connects to the audio server. - The audio client creates a SSPCQ in shared memory. - The audio client sends the SSPCQ's file descriptor to the audio server with the set_buffer() IPC call. - The audio server receives the SSPCQ and maps it. - The audio client signals start of playback with start_playback(). - At the same time: - The audio client writes its audio data into the shared-memory queue. - The audio server reads audio data from the shared-memory queue(s). Both sides have additional before-queue/after-queue buffers, depending on the exact application. - Pausing playback is just an IPC call, nothing happens to the buffer except that the server stops reading from it until playback is resumed. - Muting has nothing to do with whether audio data is read or not. - When the connection closes, the queues are unmapped on both sides. This should already improve audio playback performance in a bunch of places. Implementation & commit notes: - Audio loaders don't create LegacyBuffers anymore. LegacyBuffer is kept for WavLoader, see previous commit message. - Most intra-process audio data passing is done with FixedArray<Sample> or Vector<Sample>. - Improvements to most audio-enqueuing applications. (If necessary I can try to extract some of the aplay improvements.) - New APIs on LibAudio/ClientConnection which allows non-realtime applications to enqueue audio in big chunks like before. - Removal of status APIs from the audio server connection for information that can be directly obtained from the shared queue. - Split the pause playback API into two APIs with more intuitive names. I know this is a large commit, and you can kinda tell from the commit message. It's basically impossible to break this up without hacks, so please forgive me. These are some of the best changes to the audio subsystem and I hope that that makes up for this :yaktangle: commit. :yakring:
2022-02-20 13:01:22 +01:00
return FixedArray<Sample> {};
LibAudio: Don't read too much bytes in FLAC This fixes crash when reading the end of the file. The logic is mostly borrowed from WavLoader.
2021-07-22 16:56:05 +02:00
FlacLoader: Use seektable for performing seek operations As a fallback, we perform primitive seek if there's no seektable. Co-authored-by: kleines Filmröllchen <filmroellchen@serenityos.org>
2021-12-21 15:43:18 -08:00
// FIXME: samples_to_read is calculated wrong, because when seeking not all samples are loaded.
LibAudio: Don't read too much bytes in FLAC This fixes crash when reading the end of the file. The logic is mostly borrowed from WavLoader.
2021-07-22 16:56:05 +02:00
size_t samples_to_read = min(max_bytes_to_read_from_input, remaining_samples);
AK+Everywhere: Make FixedArray OOM-safe FixedArray now doesn't expose any infallible constructors anymore. Rather, it exposes fallible methods. Therefore, it can be used for OOM-safe code. This commit also converts the rest of the system to use the new API. However, as an example, VMObject can't take advantage of this yet, as we would have to endow VMObject with a fallible static construction method, which would require a very fundamental change to VMObject's whole inheritance hierarchy.
2022-01-08 20:06:03 +01:00
auto samples = FixedArray<Sample>::must_create_but_fixme_should_propagate_errors(samples_to_read);
LibAudio: Remove frame-wise copys from FlacLoader Previously, FlacLoader would read the data for each frame into a separate vector, which are then combined via extend() in the end. This incurs an avoidable copy per frame. By having the next_frame() function write into a given Span, there's only one vector allocated per call to get_more_samples(). This increases performance by at least 100% realtime, as measured by abench, from about 1200%-1300% to (usually) 1400% on complex test files.
2021-12-17 18:42:36 +01:00
size_t sample_index = 0;
if (m_unread_data.size() > 0) {
size_t to_transfer = min(m_unread_data.size(), samples_to_read);
dbgln_if(AFLACLOADER_DEBUG, "Reading {} samples from unread sample buffer (size {})", to_transfer, m_unread_data.size());
AK::TypedTransfer<Sample>::move(samples.data(), m_unread_data.data(), to_transfer);
if (to_transfer < m_unread_data.size())
m_unread_data.remove(0, to_transfer);
else
m_unread_data.clear_with_capacity();
sample_index += to_transfer;
}
while (sample_index < samples_to_read) {
TRY(next_frame(samples.span().slice(sample_index)));
sample_index += m_current_frame->sample_count;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Remove frame-wise copys from FlacLoader Previously, FlacLoader would read the data for each frame into a separate vector, which are then combined via extend() in the end. This incurs an avoidable copy per frame. By having the next_frame() function write into a given Span, there's only one vector allocated per call to get_more_samples(). This increases performance by at least 100% realtime, as measured by abench, from about 1200%-1300% to (usually) 1400% on complex test files.
2021-12-17 18:42:36 +01:00
m_loaded_samples += sample_index;
LibAudio+Userland: Use new audio queue in client-server communication Previously, we were sending Buffers to the server whenever we had new audio data for it. This meant that for every audio enqueue action, we needed to create a new shared memory anonymous buffer, send that buffer's file descriptor over IPC (+recfd on the other side) and then map the buffer into the audio server's memory to be able to play it. This was fine for sending large chunks of audio data, like when playing existing audio files. However, in the future we want to move to real-time audio in some applications like Piano. This means that the size of buffers that are sent need to be very small, as just the size of a buffer itself is part of the audio latency. If we were to try real-time audio with the existing system, we would run into problems really quickly. Dealing with a continuous stream of new anonymous files like the current audio system is rather expensive, as we need Kernel help in multiple places. Additionally, every enqueue incurs an IPC call, which are not optimized for >1000 calls/second (which would be needed for real-time audio with buffer sizes of ~40 samples). So a fundamental change in how we handle audio sending in userspace is necessary. This commit moves the audio sending system onto a shared single producer circular queue (SSPCQ) (introduced with one of the previous commits). This queue is intended to live in shared memory and be accessed by multiple processes at the same time. It was specifically written to support the audio sending case, so e.g. it only supports a single producer (the audio client). Now, audio sending follows these general steps: - The audio client connects to the audio server. - The audio client creates a SSPCQ in shared memory. - The audio client sends the SSPCQ's file descriptor to the audio server with the set_buffer() IPC call. - The audio server receives the SSPCQ and maps it. - The audio client signals start of playback with start_playback(). - At the same time: - The audio client writes its audio data into the shared-memory queue. - The audio server reads audio data from the shared-memory queue(s). Both sides have additional before-queue/after-queue buffers, depending on the exact application. - Pausing playback is just an IPC call, nothing happens to the buffer except that the server stops reading from it until playback is resumed. - Muting has nothing to do with whether audio data is read or not. - When the connection closes, the queues are unmapped on both sides. This should already improve audio playback performance in a bunch of places. Implementation & commit notes: - Audio loaders don't create LegacyBuffers anymore. LegacyBuffer is kept for WavLoader, see previous commit message. - Most intra-process audio data passing is done with FixedArray<Sample> or Vector<Sample>. - Improvements to most audio-enqueuing applications. (If necessary I can try to extract some of the aplay improvements.) - New APIs on LibAudio/ClientConnection which allows non-realtime applications to enqueue audio in big chunks like before. - Removal of status APIs from the audio server connection for information that can be directly obtained from the shared queue. - Split the pause playback API into two APIs with more intuitive names. I know this is a large commit, and you can kinda tell from the commit message. It's basically impossible to break this up without hacks, so please forgive me. These are some of the best changes to the audio subsystem and I hope that that makes up for this :yaktangle: commit. :yakring:
2022-02-20 13:01:22 +01:00
return samples;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.21. FRAME
LibAudio: Remove frame-wise copys from FlacLoader Previously, FlacLoader would read the data for each frame into a separate vector, which are then combined via extend() in the end. This incurs an avoidable copy per frame. By having the next_frame() function write into a given Span, there's only one vector allocated per call to get_more_samples(). This increases performance by at least 100% realtime, as measured by abench, from about 1200%-1300% to (usually) 1400% on complex test files.
2021-12-17 18:42:36 +01:00
MaybeLoaderError FlacLoaderPlugin::next_frame(Span<Sample> target_vector)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
#define FLAC_VERIFY(check, category, msg) \
do { \
if (!(check)) { \
return LoaderError { category, static_cast<size_t>(m_current_sample_or_frame), DeprecatedString::formatted("FLAC header: {}", msg) }; \
} \
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
} while (0)
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
AK: Move `Stream` and `SeekableStream` from `LibCore` `Stream` will be qualified as `AK::Stream` until we remove the `Core::Stream` namespace. `IODevice` now reuses the `SeekMode` that is defined by `SeekableStream`, since defining its own would require us to qualify it with `AK::SeekMode` everywhere.
2023-01-22 05:09:11 +01:00
auto bit_stream = LOADER_TRY(BigEndianInputBitStream::construct(MaybeOwned<AK::Stream>(*m_stream)));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// TODO: Check the CRC-16 checksum (and others) by keeping track of read data
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.22. FRAME_HEADER
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u16 sync_code = LOADER_TRY(bit_stream->read_bits<u16>(14));
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
FLAC_VERIFY(sync_code == 0b11111111111110, LoaderError::Category::Format, "Sync code");
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
bool reserved_bit = LOADER_TRY(bit_stream->read_bit());
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
FLAC_VERIFY(reserved_bit == 0, LoaderError::Category::Format, "Reserved frame header bit");
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.22.2. BLOCKING STRATEGY
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
[[maybe_unused]] bool blocking_strategy = LOADER_TRY(bit_stream->read_bit());
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u32 sample_count = TRY(convert_sample_count_code(LOADER_TRY(bit_stream->read_bits<u8>(4))));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u32 frame_sample_rate = TRY(convert_sample_rate_code(LOADER_TRY(bit_stream->read_bits<u8>(4))));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u8 channel_type_num = LOADER_TRY(bit_stream->read_bits<u8>(4));
Libraries: Change enums to enum classes in LibAudio
2022-03-17 14:38:24 -06:00
FLAC_VERIFY(channel_type_num < 0b1011, LoaderError::Category::Format, "Channel assignment");
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
FlacFrameChannelType channel_type = (FlacFrameChannelType)channel_type_num;
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
PcmSampleFormat bit_depth = TRY(convert_bit_depth_code(LOADER_TRY(bit_stream->read_bits<u8>(3))));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
reserved_bit = LOADER_TRY(bit_stream->read_bit());
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
FLAC_VERIFY(reserved_bit == 0, LoaderError::Category::Format, "Reserved frame header end bit");
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.22.8. CODED NUMBER
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// FIXME: sample number can be 8-56 bits, frame number can be 8-48 bits
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
m_current_sample_or_frame = LOADER_TRY(read_utf8_char(*bit_stream));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// Conditional header variables
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.22.9. BLOCK SIZE INT
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
if (sample_count == FLAC_BLOCKSIZE_AT_END_OF_HEADER_8) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
sample_count = LOADER_TRY(bit_stream->read_bits<u32>(8)) + 1;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
} else if (sample_count == FLAC_BLOCKSIZE_AT_END_OF_HEADER_16) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
sample_count = LOADER_TRY(bit_stream->read_bits<u32>(16)) + 1;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.22.10. SAMPLE RATE INT
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
if (frame_sample_rate == FLAC_SAMPLERATE_AT_END_OF_HEADER_8) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
frame_sample_rate = LOADER_TRY(bit_stream->read_bits<u32>(8)) * 1000;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
} else if (frame_sample_rate == FLAC_SAMPLERATE_AT_END_OF_HEADER_16) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
frame_sample_rate = LOADER_TRY(bit_stream->read_bits<u32>(16));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
} else if (frame_sample_rate == FLAC_SAMPLERATE_AT_END_OF_HEADER_16X10) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
frame_sample_rate = LOADER_TRY(bit_stream->read_bits<u32>(16)) * 10;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.22.11. FRAME CRC
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// TODO: check header checksum, see above
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
[[maybe_unused]] u8 checksum = LOADER_TRY(bit_stream->read_bits<u8>(8));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
dbgln_if(AFLACLOADER_DEBUG, "Frame: {} samples, {}bit {}Hz, channeltype {:x}, {} number {}, header checksum {}", sample_count, pcm_bits_per_sample(bit_depth), frame_sample_rate, channel_type_num, blocking_strategy ? "sample" : "frame", m_current_sample_or_frame, checksum);
m_current_frame = FlacFrameHeader {
sample_count,
frame_sample_rate,
channel_type,
bit_depth,
};
u8 subframe_count = frame_channel_type_to_channel_count(channel_type);
Vector<Vector<i32>> current_subframes;
current_subframes.ensure_capacity(subframe_count);
for (u8 i = 0; i < subframe_count; ++i) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
FlacSubframeHeader new_subframe = TRY(next_subframe_header(*bit_stream, i));
Vector<i32> subframe_samples = TRY(parse_subframe(new_subframe, *bit_stream));
LibAudio: Remove frame-wise copys from FlacLoader Previously, FlacLoader would read the data for each frame into a separate vector, which are then combined via extend() in the end. This incurs an avoidable copy per frame. By having the next_frame() function write into a given Span, there's only one vector allocated per call to get_more_samples(). This increases performance by at least 100% realtime, as measured by abench, from about 1200%-1300% to (usually) 1400% on complex test files.
2021-12-17 18:42:36 +01:00
current_subframes.unchecked_append(move(subframe_samples));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.2. Overview ("The audio data is composed of...")
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
bit_stream->align_to_byte_boundary();
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.23. FRAME_FOOTER
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// TODO: check checksum, see above
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
[[maybe_unused]] u16 footer_checksum = LOADER_TRY(bit_stream->read_bits<u16>(16));
LibAudio: Remove frame-wise copys from FlacLoader Previously, FlacLoader would read the data for each frame into a separate vector, which are then combined via extend() in the end. This incurs an avoidable copy per frame. By having the next_frame() function write into a given Span, there's only one vector allocated per call to get_more_samples(). This increases performance by at least 100% realtime, as measured by abench, from about 1200%-1300% to (usually) 1400% on complex test files.
2021-12-17 18:42:36 +01:00
dbgln_if(AFLACLOADER_DEBUG, "Subframe footer checksum: {}", footer_checksum);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
Vector<i32> left;
Vector<i32> right;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
switch (channel_type) {
case FlacFrameChannelType::Mono:
left = right = current_subframes[0];
break;
case FlacFrameChannelType::Stereo:
// TODO mix together surround channels on each side?
case FlacFrameChannelType::StereoCenter:
case FlacFrameChannelType::Surround4p0:
case FlacFrameChannelType::Surround5p0:
case FlacFrameChannelType::Surround5p1:
case FlacFrameChannelType::Surround6p1:
case FlacFrameChannelType::Surround7p1:
left = current_subframes[0];
right = current_subframes[1];
break;
case FlacFrameChannelType::LeftSideStereo:
// channels are left (0) and side (1)
left = current_subframes[0];
right.ensure_capacity(left.size());
for (size_t i = 0; i < left.size(); ++i) {
// right = left - side
right.unchecked_append(left[i] - current_subframes[1][i]);
}
break;
case FlacFrameChannelType::RightSideStereo:
// channels are side (0) and right (1)
right = current_subframes[1];
left.ensure_capacity(right.size());
for (size_t i = 0; i < right.size(); ++i) {
// left = right + side
left.unchecked_append(right[i] + current_subframes[0][i]);
}
break;
case FlacFrameChannelType::MidSideStereo:
// channels are mid (0) and side (1)
left.ensure_capacity(current_subframes[0].size());
right.ensure_capacity(current_subframes[0].size());
for (size_t i = 0; i < current_subframes[0].size(); ++i) {
i64 mid = current_subframes[0][i];
i64 side = current_subframes[1][i];
mid *= 2;
// prevent integer division errors
left.unchecked_append(static_cast<i32>((mid + side) / 2));
right.unchecked_append(static_cast<i32>((mid - side) / 2));
}
break;
}
LibAudio: Remove frame-wise copys from FlacLoader Previously, FlacLoader would read the data for each frame into a separate vector, which are then combined via extend() in the end. This incurs an avoidable copy per frame. By having the next_frame() function write into a given Span, there's only one vector allocated per call to get_more_samples(). This increases performance by at least 100% realtime, as measured by abench, from about 1200%-1300% to (usually) 1400% on complex test files.
2021-12-17 18:42:36 +01:00
VERIFY(left.size() == right.size() && left.size() == m_current_frame->sample_count);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio+LibDSP: Switch samples to 32-bit float instead of 64-bit float This has been overkill from the start, and it has been bugging me for a long time. With this change, we're probably a bit slower on most platforms but save huge amounts of space with all in-memory sample datastructures.
2022-05-06 22:14:16 +02:00
float sample_rescale = static_cast<float>(1 << (pcm_bits_per_sample(m_current_frame->bit_depth) - 1));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
dbgln_if(AFLACLOADER_DEBUG, "Sample rescaled from {} bits: factor {:.1f}", pcm_bits_per_sample(m_current_frame->bit_depth), sample_rescale);
// zip together channels
LibAudio: Remove frame-wise copys from FlacLoader Previously, FlacLoader would read the data for each frame into a separate vector, which are then combined via extend() in the end. This incurs an avoidable copy per frame. By having the next_frame() function write into a given Span, there's only one vector allocated per call to get_more_samples(). This increases performance by at least 100% realtime, as measured by abench, from about 1200%-1300% to (usually) 1400% on complex test files.
2021-12-17 18:42:36 +01:00
auto samples_to_directly_copy = min(target_vector.size(), m_current_frame->sample_count);
for (size_t i = 0; i < samples_to_directly_copy; ++i) {
Sample frame = { left[i] / sample_rescale, right[i] / sample_rescale };
target_vector[i] = frame;
}
Everywhere: Fix many spelling errors
2022-01-06 07:07:15 -07:00
// move superfluous data into the class buffer instead
LibAudio: Remove frame-wise copys from FlacLoader Previously, FlacLoader would read the data for each frame into a separate vector, which are then combined via extend() in the end. This incurs an avoidable copy per frame. By having the next_frame() function write into a given Span, there's only one vector allocated per call to get_more_samples(). This increases performance by at least 100% realtime, as measured by abench, from about 1200%-1300% to (usually) 1400% on complex test files.
2021-12-17 18:42:36 +01:00
auto result = m_unread_data.try_grow_capacity(m_current_frame->sample_count - samples_to_directly_copy);
if (result.is_error())
Everywhere: Fix many spelling errors
2022-01-06 07:07:15 -07:00
return LoaderError { LoaderError::Category::Internal, static_cast<size_t>(samples_to_directly_copy + m_current_sample_or_frame), "Couldn't allocate sample buffer for superfluous data" };
LibAudio: Remove frame-wise copys from FlacLoader Previously, FlacLoader would read the data for each frame into a separate vector, which are then combined via extend() in the end. This incurs an avoidable copy per frame. By having the next_frame() function write into a given Span, there's only one vector allocated per call to get_more_samples(). This increases performance by at least 100% realtime, as measured by abench, from about 1200%-1300% to (usually) 1400% on complex test files.
2021-12-17 18:42:36 +01:00
for (size_t i = samples_to_directly_copy; i < m_current_frame->sample_count; ++i) {
LibAudio: Rename Audio::Frame -> Audio::Sample "Frame" is an MPEG term, which is not only unintuitive but also overloaded with different meaning by other codecs (e.g. FLAC). Therefore, use the standard term Sample for the central audio structure. The class is also extracted to its own file, because it's becoming quite large. Bundling these two changes means not distributing similar modifications (changing names and paths) across commits. Co-authored-by: kleines Filmröllchen <malu.bertsch@gmail.com>
2021-09-23 21:16:03 +02:00
Sample frame = { left[i] / sample_rescale, right[i] / sample_rescale };
LibAudio: Remove frame-wise copys from FlacLoader Previously, FlacLoader would read the data for each frame into a separate vector, which are then combined via extend() in the end. This incurs an avoidable copy per frame. By having the next_frame() function write into a given Span, there's only one vector allocated per call to get_more_samples(). This increases performance by at least 100% realtime, as measured by abench, from about 1200%-1300% to (usually) 1400% on complex test files.
2021-12-17 18:42:36 +01:00
m_unread_data.unchecked_append(frame);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
return {};
#undef FLAC_VERIFY
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.22.3. INTERCHANNEL SAMPLE BLOCK SIZE
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
ErrorOr<u32, LoaderError> FlacLoaderPlugin::convert_sample_count_code(u8 sample_count_code)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
// single codes
switch (sample_count_code) {
case 0:
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Reserved block size" };
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
case 1:
return 192;
case 6:
return FLAC_BLOCKSIZE_AT_END_OF_HEADER_8;
case 7:
return FLAC_BLOCKSIZE_AT_END_OF_HEADER_16;
}
if (sample_count_code >= 2 && sample_count_code <= 5) {
Everywhere: Use AK/Math.h if applicable AK's version should see better inlining behaviors, than the LibM one. We avoid mixed usage for now though. Also clean up some stale math includes and improper floatingpoint usage.
2021-07-17 18:29:28 +02:00
return 576 * AK::exp2(sample_count_code - 2);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
Everywhere: Use AK/Math.h if applicable AK's version should see better inlining behaviors, than the LibM one. We avoid mixed usage for now though. Also clean up some stale math includes and improper floatingpoint usage.
2021-07-17 18:29:28 +02:00
return 256 * AK::exp2(sample_count_code - 8);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.22.4. SAMPLE RATE
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
ErrorOr<u32, LoaderError> FlacLoaderPlugin::convert_sample_rate_code(u8 sample_rate_code)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
switch (sample_rate_code) {
case 0:
return m_sample_rate;
case 1:
return 88200;
case 2:
return 176400;
case 3:
return 192000;
case 4:
return 8000;
case 5:
return 16000;
case 6:
return 22050;
case 7:
return 24000;
case 8:
return 32000;
case 9:
return 44100;
case 10:
return 48000;
case 11:
return 96000;
case 12:
return FLAC_SAMPLERATE_AT_END_OF_HEADER_8;
case 13:
return FLAC_SAMPLERATE_AT_END_OF_HEADER_16;
case 14:
return FLAC_SAMPLERATE_AT_END_OF_HEADER_16X10;
default:
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Invalid sample rate code" };
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.22.6. SAMPLE SIZE
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
ErrorOr<PcmSampleFormat, LoaderError> FlacLoaderPlugin::convert_bit_depth_code(u8 bit_depth_code)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
switch (bit_depth_code) {
case 0:
return m_sample_format;
case 1:
return PcmSampleFormat::Uint8;
case 4:
return PcmSampleFormat::Int16;
case 6:
return PcmSampleFormat::Int24;
case 3:
case 7:
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Reserved sample size" };
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
default:
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), DeprecatedString::formatted("Unsupported sample size {}", bit_depth_code) };
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.22.5. CHANNEL ASSIGNMENT
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
u8 frame_channel_type_to_channel_count(FlacFrameChannelType channel_type)
{
Libraries: Change enums to enum classes in LibAudio
2022-03-17 14:38:24 -06:00
if (channel_type <= FlacFrameChannelType::Surround7p1)
return to_underlying(channel_type) + 1;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
return 2;
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.25. SUBFRAME_HEADER
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
ErrorOr<FlacSubframeHeader, LoaderError> FlacLoaderPlugin::next_subframe_header(BigEndianInputBitStream& bit_stream, u8 channel_index)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
u8 bits_per_sample = static_cast<u16>(pcm_bits_per_sample(m_current_frame->bit_depth));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// For inter-channel correlation, the side channel needs an extra bit for its samples
switch (m_current_frame->channels) {
Libraries: Change enums to enum classes in LibAudio
2022-03-17 14:38:24 -06:00
case FlacFrameChannelType::LeftSideStereo:
case FlacFrameChannelType::MidSideStereo:
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
if (channel_index == 1) {
++bits_per_sample;
}
break;
Libraries: Change enums to enum classes in LibAudio
2022-03-17 14:38:24 -06:00
case FlacFrameChannelType::RightSideStereo:
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
if (channel_index == 0) {
++bits_per_sample;
}
break;
// "normal" channel types
default:
break;
}
// zero-bit padding
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
if (LOADER_TRY(bit_stream.read_bit()) != 0)
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Zero bit padding" };
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.25.1. SUBFRAME TYPE
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u8 subframe_code = LOADER_TRY(bit_stream.read_bits<u8>(6));
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
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" };
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
FlacSubframeType subframe_type;
u8 order = 0;
Everywhere: Make ByteBuffer::{create_*,copy}() OOM-safe
2021-09-06 03:29:52 +04:30
// LPC has the highest bit set
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
if ((subframe_code & 0b100000) > 0) {
subframe_type = FlacSubframeType::LPC;
order = (subframe_code & 0b011111) + 1;
} else if ((subframe_code & 0b001000) > 0) {
// Fixed has the third-highest bit set
subframe_type = FlacSubframeType::Fixed;
order = (subframe_code & 0b000111);
} else {
subframe_type = (FlacSubframeType)subframe_code;
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.25.2. WASTED BITS PER SAMPLE FLAG
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
bool has_wasted_bits = LOADER_TRY(bit_stream.read_bit());
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
u8 k = 0;
if (has_wasted_bits) {
bool current_k_bit = 0;
do {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
current_k_bit = LOADER_TRY(bit_stream.read_bit());
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
++k;
} while (current_k_bit != 1);
}
return FlacSubframeHeader {
subframe_type,
order,
k,
bits_per_sample
};
}
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
ErrorOr<Vector<i32>, LoaderError> FlacLoaderPlugin::parse_subframe(FlacSubframeHeader& subframe_header, BigEndianInputBitStream& bit_input)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
Vector<i32> samples;
switch (subframe_header.type) {
case FlacSubframeType::Constant: {
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.26. SUBFRAME_CONSTANT
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u64 constant_value = LOADER_TRY(bit_input.read_bits<u64>(subframe_header.bits_per_sample - subframe_header.wasted_bits_per_sample));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
dbgln_if(AFLACLOADER_DEBUG, "Constant subframe: {}", constant_value);
samples.ensure_capacity(m_current_frame->sample_count);
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
VERIFY(subframe_header.bits_per_sample - subframe_header.wasted_bits_per_sample != 0);
i32 constant = sign_extend(static_cast<u32>(constant_value), subframe_header.bits_per_sample - subframe_header.wasted_bits_per_sample);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
for (u32 i = 0; i < m_current_frame->sample_count; ++i) {
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
samples.unchecked_append(constant);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
break;
}
case FlacSubframeType::Fixed: {
dbgln_if(AFLACLOADER_DEBUG, "Fixed LPC subframe order {}", subframe_header.order);
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
samples = TRY(decode_fixed_lpc(subframe_header, bit_input));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
break;
}
case FlacSubframeType::Verbatim: {
dbgln_if(AFLACLOADER_DEBUG, "Verbatim subframe");
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
samples = TRY(decode_verbatim(subframe_header, bit_input));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
break;
}
case FlacSubframeType::LPC: {
dbgln_if(AFLACLOADER_DEBUG, "Custom LPC subframe order {}", subframe_header.order);
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
samples = TRY(decode_custom_lpc(subframe_header, bit_input));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
break;
}
default:
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
return LoaderError { LoaderError::Category::Unimplemented, static_cast<size_t>(m_current_sample_or_frame), "Unhandled FLAC subframe type" };
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
for (size_t i = 0; i < samples.size(); ++i) {
samples[i] <<= subframe_header.wasted_bits_per_sample;
}
ResampleHelper<i32> resampler(m_current_frame->sample_rate, m_sample_rate);
return resampler.resample(samples);
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.29. SUBFRAME_VERBATIM
LibAudio: Implement decoding verbatim blocks in FLAC They're mostly used in literal random data, so it isn't like there is a high demand for it, but it's cool to have more complete implementation anyway. :^)
2021-08-03 18:01:22 +02:00
// Decode a subframe that isn't actually encoded, usually seen in random data
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
ErrorOr<Vector<i32>, LoaderError> FlacLoaderPlugin::decode_verbatim(FlacSubframeHeader& subframe, BigEndianInputBitStream& bit_input)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
LibAudio: Implement decoding verbatim blocks in FLAC They're mostly used in literal random data, so it isn't like there is a high demand for it, but it's cool to have more complete implementation anyway. :^)
2021-08-03 18:01:22 +02:00
Vector<i32> decoded;
decoded.ensure_capacity(m_current_frame->sample_count);
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
VERIFY(subframe.bits_per_sample - subframe.wasted_bits_per_sample != 0);
LibAudio: Implement decoding verbatim blocks in FLAC They're mostly used in literal random data, so it isn't like there is a high demand for it, but it's cool to have more complete implementation anyway. :^)
2021-08-03 18:01:22 +02:00
for (size_t i = 0; i < m_current_frame->sample_count; ++i) {
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
decoded.unchecked_append(sign_extend(
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
LOADER_TRY(bit_input.read_bits<u32>(subframe.bits_per_sample - subframe.wasted_bits_per_sample)),
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
subframe.bits_per_sample - subframe.wasted_bits_per_sample));
LibAudio: Implement decoding verbatim blocks in FLAC They're mostly used in literal random data, so it isn't like there is a high demand for it, but it's cool to have more complete implementation anyway. :^)
2021-08-03 18:01:22 +02:00
}
return decoded;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.28. SUBFRAME_LPC
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// Decode a subframe encoded with a custom linear predictor coding, i.e. the subframe provides the polynomial order and coefficients
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
ErrorOr<Vector<i32>, LoaderError> FlacLoaderPlugin::decode_custom_lpc(FlacSubframeHeader& subframe, BigEndianInputBitStream& bit_input)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
Vector<i32> decoded;
decoded.ensure_capacity(m_current_frame->sample_count);
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
VERIFY(subframe.bits_per_sample - subframe.wasted_bits_per_sample != 0);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// warm-up samples
for (auto i = 0; i < subframe.order; ++i) {
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
decoded.unchecked_append(sign_extend(
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
LOADER_TRY(bit_input.read_bits<u32>(subframe.bits_per_sample - subframe.wasted_bits_per_sample)),
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
subframe.bits_per_sample - subframe.wasted_bits_per_sample));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
// precision of the coefficients
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u8 lpc_precision = LOADER_TRY(bit_input.read_bits<u8>(4));
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
if (lpc_precision == 0b1111)
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Invalid linear predictor coefficient precision" };
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
lpc_precision += 1;
// shift needed on the data (signed!)
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
i8 lpc_shift = sign_extend(LOADER_TRY(bit_input.read_bits<u8>(5)), 5);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
Vector<i32> coefficients;
coefficients.ensure_capacity(subframe.order);
// read coefficients
for (auto i = 0; i < subframe.order; ++i) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u32 raw_coefficient = LOADER_TRY(bit_input.read_bits<u32>(lpc_precision));
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
i32 coefficient = static_cast<i32>(sign_extend(raw_coefficient, lpc_precision));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
coefficients.unchecked_append(coefficient);
}
LibAudio: Use new Vector formatter
2021-07-13 11:03:10 +02:00
dbgln_if(AFLACLOADER_DEBUG, "{}-bit {} shift coefficients: {}", lpc_precision, lpc_shift, coefficients);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: Don't unnecessarily copy the passed decode buffer
2021-12-17 00:00:03 +01:00
TRY(decode_residual(decoded, subframe, bit_input));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// approximate the waveform with the predictor
for (size_t i = subframe.order; i < m_current_frame->sample_count; ++i) {
LibAudio: Add explanatory comments to the FlacLoader Some nuances in the FLAC loading code can do well with an explanation, as these non-obvious insights are often the result of long and painful debugging and nobody should touch the affected code without careful deliberation. (Of course, secretly I just want people to maintain my loader code.) :^)
2021-11-15 23:00:09 +01:00
// (see below)
LibAudio: Fix overflow on 24-bit FLAC LPC data When computing sample values from a linear predictor, the repeated multiplication and addition can lead to very large values that may overflow a 32-bit integer. This was never discovered with 16-bit FLAC test files used to create and validate the first version of the FLAC loader. However, 24-bit audio, especially with large LPC shifts, will regularly exceed and overflow i32. Therefore, we now use 64 bits temporarily. If the resulting value is too large for 32 bits, something else has gone wrong :^) This fixes playback noise on 24-bit FLACs.
2021-08-16 22:04:34 +02:00
i64 sample = 0;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
for (size_t t = 0; t < subframe.order; ++t) {
LibAudio: Add explanatory comments to the FlacLoader Some nuances in the FLAC loading code can do well with an explanation, as these non-obvious insights are often the result of long and painful debugging and nobody should touch the affected code without careful deliberation. (Of course, secretly I just want people to maintain my loader code.) :^)
2021-11-15 23:00:09 +01:00
// It's really important that we compute in 64-bit land here.
// Even though FLAC operates at a maximum bit depth of 32 bits, modern encoders use super-large coefficients for maximum compression.
Everywhere: Fix many spelling errors
2022-01-06 07:07:15 -07:00
// These will easily overflow 32 bits and cause strange white noise that abruptly stops intermittently (at the end of a frame).
LibAudio: Add explanatory comments to the FlacLoader Some nuances in the FLAC loading code can do well with an explanation, as these non-obvious insights are often the result of long and painful debugging and nobody should touch the affected code without careful deliberation. (Of course, secretly I just want people to maintain my loader code.) :^)
2021-11-15 23:00:09 +01:00
// The simple fix of course is to do intermediate computations in 64 bits.
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// These considerations are not in the original FLAC spec, but have been added to the IETF standard: https://datatracker.ietf.org/doc/html/draft-ietf-cellar-flac-03#appendix-A.3
LibAudio: Fix overflow on 24-bit FLAC LPC data When computing sample values from a linear predictor, the repeated multiplication and addition can lead to very large values that may overflow a 32-bit integer. This was never discovered with 16-bit FLAC test files used to create and validate the first version of the FLAC loader. However, 24-bit audio, especially with large LPC shifts, will regularly exceed and overflow i32. Therefore, we now use 64 bits temporarily. If the resulting value is too large for 32 bits, something else has gone wrong :^) This fixes playback noise on 24-bit FLACs.
2021-08-16 22:04:34 +02:00
sample += static_cast<i64>(coefficients[t]) * static_cast<i64>(decoded[i - t - 1]);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
decoded[i] += sample >> lpc_shift;
}
return decoded;
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.27. SUBFRAME_FIXED
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// Decode a subframe encoded with one of the fixed linear predictor codings
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
ErrorOr<Vector<i32>, LoaderError> FlacLoaderPlugin::decode_fixed_lpc(FlacSubframeHeader& subframe, BigEndianInputBitStream& bit_input)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
Vector<i32> decoded;
decoded.ensure_capacity(m_current_frame->sample_count);
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
VERIFY(subframe.bits_per_sample - subframe.wasted_bits_per_sample != 0);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// warm-up samples
for (auto i = 0; i < subframe.order; ++i) {
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
decoded.unchecked_append(sign_extend(
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
LOADER_TRY(bit_input.read_bits<u32>(subframe.bits_per_sample - subframe.wasted_bits_per_sample)),
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
subframe.bits_per_sample - subframe.wasted_bits_per_sample));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
TRY(decode_residual(decoded, subframe, bit_input));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
dbgln_if(AFLACLOADER_DEBUG, "decoded length {}, {} order predictor", decoded.size(), subframe.order);
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// Skip these comments if you don't care about the neat math behind fixed LPC :^)
// These coefficients for the recursive prediction formula are the only ones that can be resolved to polynomial predictor functions.
// The order equals the degree of the polynomial - 1, so the second-order predictor has an underlying polynomial of degree 1, a straight line.
// More specifically, the closest approximation to a polynomial is used, and the degree depends on how many previous values are available.
// This makes use of a very neat property of polynomials, which is that they are entirely characterized by their finitely many derivatives.
// (Mathematically speaking, the infinite Taylor series of any polynomial equals the polynomial itself.)
// Now remember that derivation is just the slope of the function, which is the same as the difference of two close-by values.
// Therefore, with two samples we can calculate the first derivative at a sample via the difference, which gives us a polynomial of degree 1.
// With three samples, we can do the same but also calculate the second derivative via the difference in the first derivatives.
// This gives us a polynomial of degree 2, as it has two "proper" (non-constant) derivatives.
// This can be continued for higher-order derivatives when we have more coefficients, giving us higher-order polynomials.
// In essence, it's akin to a Lagrangian polynomial interpolation for every sample (but already pre-solved).
// The coefficients for orders 0-3 originate from the SHORTEN codec:
// http://mi.eng.cam.ac.uk/reports/svr-ftp/auto-pdf/robinson_tr156.pdf page 4
// The coefficients for order 4 are undocumented in the original FLAC specification(s), but can now be found in
// https://datatracker.ietf.org/doc/html/draft-ietf-cellar-flac-03#section-10.2.5
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
switch (subframe.order) {
case 0:
// s_0(t) = 0
LibAudio: Set variable type for decoding fixed subframes in FLAC This fixes an crash caused by using the type from FlacSubframeHeader::order (unsigned 8-bit), which after overflowing the integer, converting it back to u32, and decrementing by one resulted in accessing an array waaay out of bounds.
2021-07-11 14:47:09 +02:00
for (u32 i = subframe.order; i < m_current_frame->sample_count; ++i)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
decoded[i] += 0;
break;
case 1:
// s_1(t) = s(t-1)
LibAudio: Set variable type for decoding fixed subframes in FLAC This fixes an crash caused by using the type from FlacSubframeHeader::order (unsigned 8-bit), which after overflowing the integer, converting it back to u32, and decrementing by one resulted in accessing an array waaay out of bounds.
2021-07-11 14:47:09 +02:00
for (u32 i = subframe.order; i < m_current_frame->sample_count; ++i)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
decoded[i] += decoded[i - 1];
break;
case 2:
// s_2(t) = 2s(t-1) - s(t-2)
LibAudio: Set variable type for decoding fixed subframes in FLAC This fixes an crash caused by using the type from FlacSubframeHeader::order (unsigned 8-bit), which after overflowing the integer, converting it back to u32, and decrementing by one resulted in accessing an array waaay out of bounds.
2021-07-11 14:47:09 +02:00
for (u32 i = subframe.order; i < m_current_frame->sample_count; ++i)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
decoded[i] += 2 * decoded[i - 1] - decoded[i - 2];
break;
case 3:
// s_3(t) = 3s(t-1) - 3s(t-2) + s(t-3)
LibAudio: Set variable type for decoding fixed subframes in FLAC This fixes an crash caused by using the type from FlacSubframeHeader::order (unsigned 8-bit), which after overflowing the integer, converting it back to u32, and decrementing by one resulted in accessing an array waaay out of bounds.
2021-07-11 14:47:09 +02:00
for (u32 i = subframe.order; i < m_current_frame->sample_count; ++i)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
decoded[i] += 3 * decoded[i - 1] - 3 * decoded[i - 2] + decoded[i - 3];
break;
case 4:
// s_4(t) = 4s(t-1) - 6s(t-2) + 4s(t-3) - s(t-4)
LibAudio: Set variable type for decoding fixed subframes in FLAC This fixes an crash caused by using the type from FlacSubframeHeader::order (unsigned 8-bit), which after overflowing the integer, converting it back to u32, and decrementing by one resulted in accessing an array waaay out of bounds.
2021-07-11 14:47:09 +02:00
for (u32 i = subframe.order; i < m_current_frame->sample_count; ++i)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
decoded[i] += 4 * decoded[i - 1] - 6 * decoded[i - 2] + 4 * decoded[i - 3] - decoded[i - 4];
break;
default:
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), DeprecatedString::formatted("Unrecognized predictor order {}", subframe.order) };
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
return decoded;
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.30. RESIDUAL
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// Decode the residual, the "error" between the function approximation and the actual audio data
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
MaybeLoaderError FlacLoaderPlugin::decode_residual(Vector<i32>& decoded, FlacSubframeHeader& subframe, BigEndianInputBitStream& bit_input)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.30.1. RESIDUAL_CODING_METHOD
Libraries: Change enums to enum classes in LibAudio
2022-03-17 14:38:24 -06:00
auto residual_mode = static_cast<FlacResidualMode>(LOADER_TRY(bit_input.read_bits<u8>(2)));
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u8 partition_order = LOADER_TRY(bit_input.read_bits<u8>(4));
LibAudio: Use size_t in loops This is more idiomatic :^)
2021-08-16 21:59:53 +02:00
size_t partitions = 1 << partition_order;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
if (residual_mode == FlacResidualMode::Rice4Bit) {
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.30.2. RESIDUAL_CODING_METHOD_PARTITIONED_EXP_GOLOMB
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// decode a single Rice partition with four bits for the order k
LibAudio: Use size_t in loops This is more idiomatic :^)
2021-08-16 21:59:53 +02:00
for (size_t i = 0; i < partitions; ++i) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
auto rice_partition = TRY(decode_rice_partition(4, partitions, i, subframe, bit_input));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
decoded.extend(move(rice_partition));
}
} else if (residual_mode == FlacResidualMode::Rice5Bit) {
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.30.3. RESIDUAL_CODING_METHOD_PARTITIONED_EXP_GOLOMB2
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// five bits equivalent
LibAudio: Use size_t in loops This is more idiomatic :^)
2021-08-16 21:59:53 +02:00
for (size_t i = 0; i < partitions; ++i) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
auto rice_partition = TRY(decode_rice_partition(5, partitions, i, subframe, bit_input));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
decoded.extend(move(rice_partition));
}
LibAudio: New error propagation API in Loader and Buffer 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.
2021-11-27 17:00:19 +01:00
} else
return LoaderError { LoaderError::Category::Format, static_cast<size_t>(m_current_sample_or_frame), "Reserved residual coding method" };
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
LibAudio: Don't unnecessarily copy the passed decode buffer
2021-12-17 00:00:03 +01:00
return {};
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.30.2.1. EXP_GOLOMB_PARTITION and 11.30.3.1. EXP_GOLOMB2_PARTITION
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// Decode a single Rice partition as part of the residual, every partition can have its own Rice parameter k
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
ALWAYS_INLINE ErrorOr<Vector<i32>, LoaderError> FlacLoaderPlugin::decode_rice_partition(u8 partition_type, u32 partitions, u32 partition_index, FlacSubframeHeader& subframe, BigEndianInputBitStream& bit_input)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
LibAudio: Add spec comments to the FlacLoader This way the FlacLoader can be more easily understood by someone that doesn't already know the format inside out.
2022-06-16 21:23:31 +02:00
// 11.30.2.2. EXP GOLOMB PARTITION ENCODING PARAMETER and 11.30.3.2. EXP-GOLOMB2 PARTITION ENCODING PARAMETER
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u8 k = LOADER_TRY(bit_input.read_bits<u8>(partition_type));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
u32 residual_sample_count;
if (partitions == 0)
residual_sample_count = m_current_frame->sample_count - subframe.order;
else
residual_sample_count = m_current_frame->sample_count / partitions;
if (partition_index == 0)
residual_sample_count -= subframe.order;
Vector<i32> rice_partition;
rice_partition.resize(residual_sample_count);
// escape code for unencoded binary partition
if (k == (1 << partition_type) - 1) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u8 unencoded_bps = LOADER_TRY(bit_input.read_bits<u8>(5));
LibAudio: Use size_t in loops This is more idiomatic :^)
2021-08-16 21:59:53 +02:00
for (size_t r = 0; r < residual_sample_count; ++r) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
rice_partition[r] = LOADER_TRY(bit_input.read_bits<u8>(unencoded_bps));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
} else {
LibAudio: Use size_t in loops This is more idiomatic :^)
2021-08-16 21:59:53 +02:00
for (size_t r = 0; r < residual_sample_count; ++r) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
rice_partition[r] = LOADER_TRY(decode_unsigned_exp_golomb(k, bit_input));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
}
return rice_partition;
}
// Decode a single number encoded with Rice/Exponential-Golomb encoding (the unsigned variant)
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
ALWAYS_INLINE ErrorOr<i32> decode_unsigned_exp_golomb(u8 k, BigEndianInputBitStream& bit_input)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
u8 q = 0;
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
while (TRY(bit_input.read_bit()) == 0)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
++q;
// least significant bits (remainder)
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
u32 rem = TRY(bit_input.read_bits<u32>(k));
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
u32 value = q << k | rem;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
return rice_to_signed(value);
}
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
ErrorOr<u64> read_utf8_char(BigEndianInputBitStream& input)
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
{
u64 character;
Everywhere: Make ByteBuffer::{create_*,copy}() OOM-safe
2021-09-06 03:29:52 +04:30
u8 buffer = 0;
Bytes buffer_bytes { &buffer, 1 };
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
TRY(input.read(buffer_bytes));
Everywhere: Make ByteBuffer::{create_*,copy}() OOM-safe
2021-09-06 03:29:52 +04:30
u8 start_byte = buffer_bytes[0];
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// Signal byte is zero: ASCII character
if ((start_byte & 0b10000000) == 0) {
return start_byte;
} else if ((start_byte & 0b11000000) == 0b10000000) {
Everywhere: Split Error::from_string_literal and Error::from_string_view Error::from_string_literal now takes direct char const*s, while Error::from_string_view does what Error::from_string_literal used to do: taking StringViews. This change will remove the need to insert `sv` after error strings when returning string literal errors once StringView(char const*) is removed. No functional changes.
2022-07-11 17:57:32 +00:00
return Error::from_string_literal("Illegal continuation byte");
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
// This algorithm is too good and supports the theoretical max 0xFF start byte
u8 length = 1;
while (((start_byte << length) & 0b10000000) == 0b10000000)
++length;
u8 bits_from_start_byte = 8 - (length + 1);
Everywhere: Use AK/Math.h if applicable AK's version should see better inlining behaviors, than the LibM one. We avoid mixed usage for now though. Also clean up some stale math includes and improper floatingpoint usage.
2021-07-17 18:29:28 +02:00
u8 start_byte_bitmask = AK::exp2(bits_from_start_byte) - 1;
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
character = start_byte_bitmask & start_byte;
LibAudio: Fix UTF-8 decoding logic in FLAC decoding :^) The problem here was that the multi-byte UTF-8 encoded characters were taking one byte too much, misaligning the data completely and eventually crashing the program on the 128th frame. This change reduces the for loop by one, as it has been already calculated from the start_byte variable.
2021-07-21 15:58:57 +02:00
for (u8 i = length - 1; i > 0; --i) {
LibAudio: Convert FlacLoader to use new Core::Stream APIs :^) For this change to work "easily", Loader can't take const ByteBuffer's anymore, which is fine for now.
2022-01-14 01:14:24 +01:00
TRY(input.read(buffer_bytes));
Everywhere: Make ByteBuffer::{create_*,copy}() OOM-safe
2021-09-06 03:29:52 +04:30
u8 current_byte = buffer_bytes[0];
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
character = (character << 6) | (current_byte & 0b00111111);
}
return character;
}
i64 sign_extend(u32 n, u8 size)
{
// negative
if ((n & (1 << (size - 1))) > 0) {
return static_cast<i64>(n | (0xffffffff << size));
}
// positive
return n;
}
i32 rice_to_signed(u32 x)
{
// positive numbers are even, negative numbers are odd
// bitmask for conditionally inverting the entire number, thereby "negating" it
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
i32 sign = -static_cast<i32>(x & 1);
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
// copies the sign's sign onto the actual magnitude of x
Audio: Fix code smells and issues found by static analysis This fixes all current code smells, bugs and issues reported by SonarCloud static analysis. Other issues are almost exclusively false positives. This makes much code clearer, and some minor benefits in performance or bug evasion may be gained.
2021-11-15 22:27:28 +01:00
return static_cast<i32>(sign ^ (x >> 1));
LibAudio: Implement a basic FLAC loader This commit adds a loader for the FLAC audio codec, the Free Lossless Audio codec by the Xiph.Org foundation. LibAudio will automatically read and parse FLAC files, so users do not need to adjust. This implementation is bare-bones and needs to be improved upon. There are many bugs, verbatim subframes and any kind of seeking is not supported. However, stereo files exported by libavcodec on highest compression setting seem to work well.
2021-06-25 13:54:14 +02:00
}
}
Reference in a new issue Copy permalink