(c) 2022 by surya kandau. qoirsk (pronounced like "choir") is simple, lossless image file format that is very fast to encode and decode while achieving compression ratios roughly comparable to PNG.
It was inspired by the QOI image file format, building on it in a number of ways:
- It uses a RIFF-like file structure, allowing future extensions.
- That structure means that qoirsk files can include metadata like color profiles (QOI is limited to two choices, "linear" or "sRGB") and EXIF information.
- It integrates LZ4 compression to [produce smaller files].
- It can represent premultiplied alpha (as well as PNG's non-premultiplied alpha), which can avoid a post-processing step if your game engine or GUI toolkit works with premultiplied alpha.
- It has an optional lossy mode.
- It partitions the image into independent tiles, allowing for multi-threaded codec implementations.
- As an implementation concern (not a file format concern), it can decode into a pre-existing pixel buffer (in a variety of pixel formats), not just always returning a newly allocated pixel buffer. This also supports multi-threaded decoding, where the entire pixel buffer is allocated first and N separate threads then decode into their own separate portion of that pixel buffer.
src/qoirsk.h is a single file C library, so there's no separate
configure or build steps. Just #define qoirsk_IMPLEMENTATION before you
#include it.
The numbers below are the top-level summary of the full benchmarks, normalized so that qoirsk is 1.000 (the full benchmarks page has raw, non-normalized numbers and links to the benchmark suite of images). For example, comparing PNG/libpng with qoirsk, libpng compresses a little smaller (0.960 versus 1.000) but qoirsk encodes 30x faster (0.033 versus 1.000) and decodes 4.9x faster (0.203 versus 1.000).
For example, PNG/fpng encodes faster (1.138x) than qoirsk but produces larger (1.234x) files and decodes slower (0.536x) than qoirsk.
For example, JPEG-XL Lossless at its default encoder options produces smaller files (0.613x) but encodes slower (0.003x) and decodes slower (0.017x) than qoirsk. Inverting those last two numbers give qoirsk encoding 296x faster and decoding 60x faster than JPEG-XL Lossless (using its "effort = 7" option).
The conclusion isn't that qoirsk is always better or worse than any other format. It's all trade-offs. However, qoirsk has the fastest decode speed listed and achieves reasonable (roughly comparable to PNG) compression ratios. JXL and WebP, lossless or lossy, have better compression ratios but also slower encode and decode speeds.
Even though PNG/stb and QOI are worse than qoirsk in all three columns (compression ratio, encoding speed and decoding speed), they still have their own advantages. PNG/stb, like any PNG implementation, has unrivalled compatibility with other software (and the stb library is easy to integrate, being a single file C library). QOI is the simplest (easiest to understand and easiest to customize) format, weighing under 700 lines of C code (qoirsk is around 3000 lines of C code plus 4000 lines of data tables).
To repeat, it's all trade-offs.
CmpRatio = CompressedSize / DecompressedSize. Lower is better.
EncMPixels/s = Encode MegaPixels per second. Higher is better.
DecMPixels/s = Decode MegaPixels per second. Higher is better.
qoirsk_Lossless 1.000 CmpRatio 1.000 EncMPixels/s 1.000 DecMPixels/s (1)
JXL_Lossless/f 0.860 CmpRatio 0.630 EncMPixels/s 0.120 DecMPixels/s (2)
JXL_Lossless/l3 0.725 CmpRatio 0.032 EncMPixels/s 0.022 DecMPixels/s
JXL_Lossless/l7 0.613 CmpRatio 0.003 EncMPixels/s 0.017 DecMPixels/s
PNG/fpng 1.234 CmpRatio 1.138 EncMPixels/s 0.536 DecMPixels/s (1)
PNG/fpnge 1.108 CmpRatio 1.851 EncMPixels/s n/a DecMPixels/s (1)
PNG/libpng 0.960 CmpRatio 0.033 EncMPixels/s 0.203 DecMPixels/s
PNG/stb 1.354 CmpRatio 0.045 EncMPixels/s 0.186 DecMPixels/s (1)
PNG/wuffs 0.946 CmpRatio n/a EncMPixels/s 0.509 DecMPixels/s (3)
QOI 1.118 CmpRatio 0.870 EncMPixels/s 0.700 DecMPixels/s (1)
WebP_Lossless 0.654 CmpRatio 0.015 EncMPixels/s 0.325 DecMPixels/s
(1) means that the codec implementation is available as a single file C library.
(2) means that the fjxl encoder is a single file C library but there is no fjxl
decoder. There's also the j40 single file JXL decoder, in a separate
repository, but I couldn't get it to work. Passing it something produced by the
cjxl reference encoder produced Error: Decoding failed (rnge) during j40_next_frame.
(3) means that the Wuffs decoder is a single file C library but there is no PNG/Wuffs encoder. The "compression ratio" numbers simply take the benchmark suite PNG images "as is" without re-encoding.
qoir qoirsk
dice.png 337,811 333,374 fish.png 630,380 614,451 clover.png 2,490,373 2,488,356 grass1.png 2,661,762 2,661,422
qoirskv1:
input size qoirsk comp_time decomp_time
kodim01.png 694,365 694,330 0.063s 0.125s
kodim02.png 605,719 607,354 0.046s 0.140s
kodim03.png 482,155 496,117 0.047s 0.141s
kodim04.png 610,087 635,092 0.046s 0.140s
kodim05.png 758,418 759,242 0.047s 0.140s
kodim06.png 591,345 609,184 0.078s 0.125s
kodim07.png 539,172 556,387 0.046s 0.140s
kodim08.png 746,389 789,206 0.062s 0.141s
kodim09.png 561,120 552,440 0.047s 0.125s
kodim10.png 567,930 589,767 0.047s 0.141s
kodim11.png 601,411 611,644 0.046s 0.125s
kodim12.png 508,938 518,930 0.047s 0.125s
kodim13.png 803,553 789,293 0.046s 0.141s
kodim14.png 669,142 677,872 0.047s 0.125s
kodim15.png 574,072 603,778 0.047s 0.140s
kodim16.png 507,174 535,726 0.047s 0.125s
kodim17.png 578,568 593,599 0.046s 0.140s
pk01_door01_add.png 3,220 5,979 0.015s 0.031s
pk01_door01_local.png 73,467 105,617 0.031s 0.047s
pk01_door01_s.png 74,021 126,558 0.031s 0.031s
pk01_door01a_d.png 219,672 253,462 0.031s 0.078s
pk01_door01b_d.png 235,926 263,265 0.047s 0.078s
pk01_floor01_s.png 183,438 300,241 0.047s 0.079s
pk01_floor01a_d.png 454,077 483,273 0.047s 0.094s
pk01_floor01b_d.png 511,058 576,245 0.062s 0.109s
pk01_floor02_local.png 67,734 133,719 0.032s 0.047s
pk01_floor02_s.png 46,811 84,057 0.016s 0.031s
clover.png 2,582,326 2,488,818 0.110s 0.344s
grass1.png 2,851,919 2,661,488 0.078s 0.343s
IMGP5482_seamless.png 2,212,110 2,018,303 0.094s 0.313s
mod_screen1j.png 4,829 7,165 0.047s 0.015s
dice.png 349,827 334,126 0.047s 0.109s
fish.png 447,419 616,577 0.078s 0.328s
qoirskv2:
input size qoirsk comp_time decomp_time
dice.png 349,827 333,852 0.062s 0.094s
fish.png 447,419 615,449 0.094s 0.328s
qoirskv3:
input size qoirsk comp_time decomp_time
kodim01.png 694,365 694,236 0.047s 0.141s
kodim02.png 605,719 607,329 0.078s 0.125s
kodim03.png 482,155 496,028 0.078s 0.141s
kodim04.png 610,087 635,030 0.062s 0.141s
kodim05.png 758,418 759,186 0.094s 0.140s
kodim06.png 591,345 609,159 0.062s 0.125s
kodim07.png 539,172 556,294 0.078s 0.141s
kodim08.png 746,389 789,144 0.078s 0.140s
kodim09.png 561,120 552,384 0.062s 0.156s
kodim10.png 567,930 589,691 0.062s 0.172s
kodim11.png 601,411 611,538 0.063s 0.125s
kodim12.png 508,938 518,898 0.062s 0.125s
kodim13.png 803,553 789,273 0.094s 0.125s
kodim14.png 669,142 677,835 0.062s 0.157s
kodim15.png 574,072 603,725 0.078s 0.140s
kodim16.png 507,174 535,716 0.063s 0.141s
kodim17.png 578,568 593,556 0.047s 0.125s
pk01_door01_add.png 3,220 5,923 0.032s 0.032s
pk01_door01_local.png 73,467 105,481 0.031s 0.031s
pk01_door01_s.png 74,021 126,551 0.047s 0.047s
pk01_door01a_d.png 219,672 253,461 0.047s 0.078s
pk01_door01b_d.png 235,926 263,264 0.046s 0.062s
pk01_floor01_s.png 183,438 300,224 0.062s 0.063s
pk01_floor01a_d.png 454,077 483,273 0.046s 0.094s
pk01_floor01b_d.png 511,058 576,245 0.047s 0.109s
pk01_floor02_local.png 67,734 133,556 0.046s 0.046s
pk01_floor02_s.png 46,811 84,049 0.046s 0.031s
clover.png 2,582,326 2,488,692 0.109s 0.344s
grass1.png 2,851,919 2,661,471 0.125s 0.375s
IMGP5482_seamless.png 2,212,110 2,017,453 0.125s 0.296s
mod_screen1j.png 4,829 7,138 0.031s 0.031s
dice.png 349,827 333,468 0.063s 0.094s
fish.png 447,419 614,998 0.125s 0.328s
qoirsk is first and foremost a lossless format (for 24-bit RGB or 32-bit RGBA images) but it also has a trivial lossy mode (reducing each pixel from 8 to 6 bits per channel). Here are some comparisons to other lossy formats. Once again, there are trade-offs.
qoirsk_Lossy 0.641 CmpRatio 0.903 EncMPixels/s 0.731 DecMPixels/s (1)
JXL_Lossy/l3 0.440 CmpRatio 0.051 EncMPixels/s 0.091 DecMPixels/s
JXL_Lossy/l7 0.305 CmpRatio 0.013 EncMPixels/s 0.070 DecMPixels/s
WebP_Lossy 0.084 CmpRatio 0.065 EncMPixels/s 0.453 DecMPixels/s
Lossy encoders (other than qoirsk) use the respective libraries' default options. Different size/speed/quality trade-offs may be achievable with other options.
The benchmark numbers above are all single-threaded. Other codec implementations can be sped up (in terms of wall clock time) by using multiple threads. qoirsk is no different: multi-threaded decoding can be [over 3x faster], depending on your input image size.
These libraries are only used by the benchmark program. The qoirsk codec implementation has no dependencies (and brings its own LZ4 implementation).
JXL (libjxl/libjxl) is the official
JPEG-XL library. The /l suffix denotes the regular libjxl implementation and
the /f suffix denotes the experimental/fast_lossless encoder (also known as
fjxl) in that repository (but still using the regular libjxl decoder). The
final 3 or 7 denotes libjxl's "effort" encoding option, which defaults to 7.
PNG/fpng (richgel999/fpng) is a fast PNG encoder and decoder. The encoded output are valid PNG images but the fpng decoder only accepts fpng-encoded PNG images. It is not a general PNG decoder. It's also currently only SIMD-optimized for the x86 CPU family, not ARM.
PNG/fpnge (veluca93/fpnge) is a very fast PNG encoder. The repository only contains an encoder, not a decoder. It's also currently only SIMD-optimized for the x86 CPU family, not ARM.
PNG/libpng is the official libpng library as built on Debian Bullseye.
PNG/stb (nothings/stb) is one of the best known "single file C library" PNG implementations.
PNG/wuffs (google/wuffs) is the PNG decoder from the Wuffs repository. There is no encoder but the decoder is discussed in ["The Fastest, Safest PNG Decoder in the World"]. While its reported decode speed here is not as fast as PNG/fpng, PNG/wuffs is a general PNG decoder and isn't limited to only those PNG images produced by the PNG/fpng encoder.
QOI (phoboslab/qoi) is a recent (released in 2021), simple image file format that is remarkably competitive.
qoirsk is this repository. Lossless is the default option. Lossy means using the lossiness=2 encoding option, reducing each pixel from 8 to 6 bits per channel.
WebP is the official libwebp library as built on Debian Bullseye. The WebP file
format cannot represent an image dimension greater than 16383 pixels, such as
the 1313 x 20667 screenshot_web/phoboslab.org.png image from the benchmark
suite. For these large images, we use PNG/libpng instead.
AVIF wasn't measured. I gave up after hitting Debian bug 976349 and the combination of (1) lossless is the primary focus of qoirsk but (2) the avif examples or avif.h file not obviously showing how to encode losslessly from the library (not the command line tools). Maybe I'll try again later.
JPEG wasn't measured. Around 45% of the benchmark suite images have an alpha channel, which JPEG cannot represent.
PNG/libspng and PNG/lodepng weren't measured. They are presumably roughly comparable, [within a factor of 2], to PNG/libpng and PNG/stb.
Apache 2. See the LICENSE file for details.
Updated on November 2022.