Top Related Projects
Quick Overview
FLAC (Free Lossless Audio Codec) is an open-source audio compression codec that offers lossless compression of digital audio. Developed by the Xiph.Org Foundation, FLAC provides a free, royalty-free alternative to other lossless formats, maintaining audio quality while reducing file size.
Pros
- Lossless compression, preserving original audio quality
- Open-source and royalty-free, allowing widespread adoption
- Supports metadata tagging and fast seeking within audio files
- Cross-platform compatibility and hardware support
Cons
- Larger file sizes compared to lossy formats like MP3
- Less widespread support in consumer devices compared to some proprietary formats
- Slower encoding speed compared to some lossy formats
- Limited compression ratio compared to some newer lossless codecs
Code Examples
- Decoding a FLAC file:
#include <FLAC/stream_decoder.h>
FLAC__StreamDecoder *decoder = FLAC__stream_decoder_new();
FLAC__stream_decoder_init_file(decoder, "input.flac", write_callback, metadata_callback, error_callback, NULL);
FLAC__stream_decoder_process_until_end_of_stream(decoder);
FLAC__stream_decoder_delete(decoder);
- Encoding a FLAC file:
#include <FLAC/stream_encoder.h>
FLAC__StreamEncoder *encoder = FLAC__stream_encoder_new();
FLAC__stream_encoder_set_verify(encoder, true);
FLAC__stream_encoder_set_compression_level(encoder, 5);
FLAC__stream_encoder_init_file(encoder, "output.flac", progress_callback, NULL);
FLAC__stream_encoder_process_interleaved(encoder, buffer, samples);
FLAC__stream_encoder_finish(encoder);
FLAC__stream_encoder_delete(encoder);
- Reading metadata from a FLAC file:
#include <FLAC/metadata.h>
FLAC__Metadata_Chain *chain = FLAC__metadata_chain_new();
if(FLAC__metadata_chain_read(chain, "input.flac")) {
FLAC__Metadata_Iterator *iterator = FLAC__metadata_iterator_new();
FLAC__metadata_iterator_init(iterator, chain);
do {
FLAC__StreamMetadata *metadata = FLAC__metadata_iterator_get_block(iterator);
// Process metadata
} while(FLAC__metadata_iterator_next(iterator));
FLAC__metadata_iterator_delete(iterator);
}
FLAC__metadata_chain_delete(chain);
Getting Started
To use FLAC in your project:
-
Install FLAC development libraries:
sudo apt-get install libflac-dev -
Include FLAC headers in your C/C++ code:
#include <FLAC/stream_decoder.h> #include <FLAC/stream_encoder.h> -
Compile your program with FLAC libraries:
gcc -o your_program your_program.c -lFLAC -
Run your program:
./your_program
Competitor Comparisons
Extremely Fast Compression algorithm
Pros of LZ4
- Extremely fast compression and decompression speeds
- Suitable for real-time data compression scenarios
- Widely used in various applications and systems
Cons of LZ4
- Lower compression ratio compared to FLAC
- Not specifically designed for audio compression
- Less effective for long-term storage of large audio files
Code Comparison
FLAC (encoding):
FLAC__bool FLAC__stream_encoder_process_interleaved(
FLAC__StreamEncoder *encoder,
const FLAC__int32 buffer[],
unsigned samples
)
LZ4 (compression):
int LZ4_compress_default(
const char* src,
char* dst,
int srcSize,
int dstCapacity
)
Key Differences
- FLAC is specifically designed for lossless audio compression, while LZ4 is a general-purpose compression algorithm.
- FLAC offers better compression ratios for audio files, whereas LZ4 prioritizes speed over compression efficiency.
- FLAC includes metadata support for audio files, which is not present in LZ4.
- LZ4 is more versatile and can be used for various data types, while FLAC is optimized for audio.
Use Cases
- FLAC: Ideal for archiving high-quality audio files and professional audio applications.
- LZ4: Suitable for scenarios requiring fast compression/decompression, such as real-time data transfer or in-memory compression.
A massively spiffy yet delicately unobtrusive compression library.
Pros of zlib
- Wider application range: Used for general-purpose data compression
- Smaller codebase: Easier to integrate and maintain
- Faster compression and decompression speeds for most use cases
Cons of zlib
- Lower compression ratio compared to FLAC for audio files
- Lacks specific audio-related features and optimizations
- Not designed for lossless audio compression
Code Comparison
FLAC (encoding):
FLAC__StreamEncoder *encoder = FLAC__stream_encoder_new();
FLAC__stream_encoder_set_verify(encoder, true);
FLAC__stream_encoder_set_compression_level(encoder, 5);
FLAC__stream_encoder_init_file(encoder, output_file, NULL, NULL);
FLAC__stream_encoder_process_interleaved(encoder, buffer, samples);
zlib (compression):
z_stream strm;
deflateInit(&strm, Z_DEFAULT_COMPRESSION);
strm.avail_in = input_size;
strm.next_in = input_data;
deflate(&strm, Z_FINISH);
deflateEnd(&strm);
Both FLAC and zlib are popular compression libraries, but they serve different purposes. FLAC is specifically designed for lossless audio compression, while zlib is a general-purpose compression library. zlib offers faster compression and decompression speeds for most use cases, but FLAC provides better compression ratios for audio files. The code examples demonstrate the different approaches to encoding/compressing data in each library.
Extremely fast non-cryptographic hash algorithm
Pros of xxHash
- Extremely fast non-cryptographic hash function
- Designed for speed and efficiency in hash table lookups
- Lightweight and easy to integrate into existing projects
Cons of xxHash
- Limited to hashing functionality, not a full audio codec like FLAC
- Not suitable for cryptographic purposes or data compression
- Less widely adopted in multimedia applications
Code Comparison
xxHash (simple usage):
#include "xxhash.h"
XXH64_hash_t hash = XXH64(data, length, seed);
FLAC (basic encoding):
#include "FLAC/stream_encoder.h"
FLAC__StreamEncoder* encoder = FLAC__stream_encoder_new();
FLAC__stream_encoder_init_file(encoder, output_filename, NULL, NULL);
FLAC__stream_encoder_process_interleaved(encoder, buffer, samples);
FLAC__stream_encoder_finish(encoder);
Summary
xxHash is a fast, lightweight hashing algorithm focused on speed and efficiency, while FLAC is a comprehensive lossless audio codec. xxHash is ideal for quick hash table lookups and checksums, whereas FLAC is specifically designed for high-quality audio compression and playback. The choice between the two depends on the specific use case: xxHash for general-purpose hashing needs, and FLAC for audio-related applications requiring lossless compression.
Zstandard - Fast real-time compression algorithm
Pros of Zstd
- Higher compression ratios and faster compression/decompression speeds
- More versatile, supporting a wide range of file types beyond audio
- Active development with frequent updates and improvements
Cons of Zstd
- Not specifically optimized for lossless audio compression like FLAC
- Larger file sizes for audio files compared to FLAC
- Less widespread support in audio playback devices and software
Code Comparison
FLAC encoding example:
FLAC__StreamEncoder *encoder = FLAC__stream_encoder_new();
FLAC__stream_encoder_set_verify(encoder, true);
FLAC__stream_encoder_set_compression_level(encoder, 5);
FLAC__stream_encoder_init_file(encoder, output_filename, NULL, NULL);
Zstd compression example:
size_t const cBuffSize = ZSTD_compressBound(srcSize);
void* const cBuff = malloc(cBuffSize);
size_t const cSize = ZSTD_compress(cBuff, cBuffSize, src, srcSize, 1);
Both FLAC and Zstd are open-source compression libraries, but they serve different purposes. FLAC is specifically designed for lossless audio compression, while Zstd is a general-purpose compression algorithm. Zstd offers better compression ratios and speeds for most file types, but FLAC remains the preferred choice for lossless audio due to its optimization for that specific use case.
A fast compressor/decompressor
Pros of Snappy
- Faster compression and decompression speeds
- Lower memory usage during compression
- Simpler API and easier integration into existing projects
Cons of Snappy
- Lower compression ratio compared to FLAC
- Not specifically designed for audio compression
- Less widespread adoption in audio-related applications
Code Comparison
FLAC encoding example:
FLAC__StreamEncoder *encoder = FLAC__stream_encoder_new();
FLAC__stream_encoder_set_verify(encoder, true);
FLAC__stream_encoder_set_compression_level(encoder, 5);
FLAC__stream_encoder_init_file(encoder, output_filename, NULL, NULL);
FLAC__stream_encoder_process_interleaved(encoder, buffer, samples);
Snappy compression example:
std::string output;
snappy::Compress(input_data, input_size, &output);
Summary
FLAC is specifically designed for lossless audio compression, offering high compression ratios and wide support in audio applications. Snappy, on the other hand, is a general-purpose compression library focused on speed and simplicity. While Snappy provides faster compression and decompression with lower memory usage, it doesn't achieve the same level of compression as FLAC for audio data. The choice between the two depends on the specific use case, with FLAC being more suitable for audio-centric applications and Snappy for scenarios where speed is crucial.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Free Lossless Audio Codec (FLAC)
FLAC is open source software that can reduce the amount of storage space needed to store digital audio signals without needing to remove information in doing so.
The files read and produced by this software are called FLAC files. As these files (which follow the FLAC format) can be read from and written to by other software as well, this software is often referred to as the FLAC reference implementation.
FLAC has been developed by volunteers. If you want to help out, see CONTRIBUTING.md for more information.
Components
FLAC is comprised of
- libFLAC, a library which implements reference encoders and decoders for native FLAC and Ogg FLAC, and a metadata interface
- libFLAC++, a C++ object wrapper library around libFLAC
flac, a command-line program for encoding and decoding filesmetaflac, a command-line program for viewing and editing FLAC metadata- user and API documentation
The libraries (libFLAC, libFLAC++) are licensed under Xiph.org's BSD-like license (see COPYING.Xiph). All other programs and plugins are licensed under the GNU General Public License (see COPYING.GPL). The documentation is licensed under the GNU Free Documentation License (see COPYING.FDL).
Documentation
For documentation of the flac and metaflac command line tools, see
the directory man, which contains the files flac.md and metaflac.md
The API documentation is in html and is generated by Doxygen. It can be found in the directory doc/html/api. It is included in a release tarball and must be build with Doxygen when the source is taken directly from git.
The directory examples contains example source code on using libFLAC and libFLAC++.
Documentation concerning the FLAC format itself (which can be used to create software reading and writing FLAC software independent from libFLAC) was included in previous releases, but can now be found on https://datatracker.ietf.org/doc/draft-ietf-cellar-flac/ Additionally a set of files for conformance testing called the FLAC decoder testbench can be found at https://github.com/ietf-wg-cellar/flac-test-files
If you have questions about FLAC that this document does not answer, please submit them at the following tracker so this document can be improved:
https://github.com/xiph/flac/issues
Building FLAC
All components of the FLAC project can be build with a variety of compilers (including GCC, Clang, Visual Studio, Intel C++ Compiler) on many architectures (inluding x86, x86_64, ARMv7, ARMv8 and PowerPC) for many different operating systems.
To do this, FLAC provides two build systems: one using GNU's autotools and one with CMake. Both differ slighly in configuration options, but should be considered equivalent for most use cases.
FLAC used to provide files specifically for building with Visual Studio, but these have been removed in favor of using CMake.
Building with CMake
CMake is a cross-platform build system. FLAC can be built on Windows, Linux, Mac OS X using CMake.
You can use either CMake's CLI or GUI. We recommend you to have a separate build folder outside the repository in order to not spoil it with generated files. It is possible however to do a so-called in-tree build, in that case /path/to/flac-build in the following examples is equal to /path/to/flac-source.
CMake CLI
Go to your build folder and run something like this:
/path/to/flac-build$ cmake /path/to/flac-source
or e.g. in Windows shell
C:\path\to\flac-build> cmake \path\to\flac-source
(provided that cmake is in your %PATH% variable)
That will generate build scripts for the default build system (e.g. Makefiles for UNIX). After that you start build with a command like this:
/path/to/flac-build$ make
And afterwards you can run tests or install the built libraries and headers
/path/to/flac-build$ make test
/path/to/flac-build$ make install
If you want use a build system other than default add -G flag to cmake, e.g.:
/path/to/flac-build$ cmake /path/to/flac-source -GNinja
/path/to/flac-build$ ninja
or:
/path/to/flac-build$ cmake /path/to/flac-source -GXcode
Use cmake --help to see the list of available generators.
By default CMake will search for OGG. If CMake fails to find it you can help CMake by specifying the exact path:
/path/to/flac-build$ cmake /path/to/flac-source -DOGG_ROOT=/path/to/ogg
If you would like CMake to build OGG alongside FLAC, you can place the ogg sources directly in the flac source directory as a subdirectory with the name ogg, for example:
/path/to/flac-source/ogg
If you don't want to build flac with OGG support you can tell CMake not to look for OGG:
/path/to/flac-build$ cmake /path/to/flac-source -DWITH_OGG=OFF
Other FLAC's options (e.g. building C++ lib or docs) can also be put to cmake through -D flag. If you want to know what options are available, use -LH:
/path/to/flac-build$ cmake /path/to/flac-source -LH
CMake GUI (for Visual Studio)
It is likely that you would prefer to use the CMake GUI if you use Visual Studio to build FLAC. It's in essence the same process as building using CLI.
Open cmake-gui. In the window select a source directory (the repository's root), a build directory (some other directory outside the repository). Then press button "Configure". CMake will ask you which build system you prefer. Choose that version of Visual Studio which you have on your system, choose whether you want to build for Win32 or x64. Press OK.
After CMake finishes you can change the configuration to your liking and if you change anything, run Configure again. With the "Generate" button, CMake creates Visual Studio files, which can be opened from Visual Studio. With the button "Open Project" CMake will launch Visual Studio and open the generated solution. You can use the project files as usual but remember that they were generated by CMake. That means that your changes (e.g. some additional compile flags) will be lost when you run CMake next time.
CMake searches by default for OGG on your system and returns an error if it cannot find it. If you want to build OGG alongside FLAC, you can download the OGG sources and extract them in a subdirectory of the FLAC source directory with the name ogg (i.e. /path/to/flac-source/ogg) before running CMake. If you don't want to build FLAC with OGG support, untick the box following WITH_OGG flag in the list of variables in cmake-gui window and run "Configure" again.
If CMake fails to find MSVC compiler then running cmake-gui from MS Developer comand prompt should help.
Building with GNU autotools
FLAC uses autoconf and libtool for configuring and building. To
configure a build, open a commmand line/terminal and run ./configure
You can provide options to this command, which are listed by running
./configure --help.
In case the configure script is not present (for example when building
from git and not from a release tarball), it can be generated by running
./autogen.sh. This may require a libtool development package though.
After configuration, build with make, verify the build with
make check and install with make install. Installation might require
administrator priviledged, i.e. sudo make install.
The 'make check' step is optional; omit it to skip all the tests, which can take about an hour to complete. Even though it will stop with an explicit message on any failure, it does print out a lot of stuff so you might want to capture the output to a file if you're having a problem. Also, don't run 'make check' as root because it confuses some of the tests.
Summarizing:
./configure
make && make check
sudo make install
Note to embedded developers
libFLAC has grown larger over time as more functionality has been included, but much of it may be unnecessary for a particular embedded implementation. Unused parts may be pruned by some simple editing of configure.ac and src/libFLAC/Makefile.am; the following dependency graph shows which modules may be pruned without breaking things further down:
metadata.h
stream_decoder.h
format.h
stream_encoder.h
stream_decoder.h
format.h
stream_decoder.h
format.h
In other words, for pure decoding applications, both the stream encoder and metadata editing interfaces can be safely removed. Note that this is specific to building the libraries for embedded use. The command line tools do not provide such compartmentalization, and require a complete libFLAC build to function.
There is a section dedicated to embedded use in the libFLAC API HTML documentation (see doc/html/api/index.html).
Also, there are several places in the libFLAC code with comments marked with "OPT:" where a #define can be changed to enable code that might be faster on a specific platform. Experimenting with these can yield faster binaries.
Top Related Projects
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot