JPEG XL image format reference C++ implementation

Overview

JPEG XL reference implementation

JXL logo

This repository contains a reference implementation of JPEG XL (encoder and decoder), called libjxl.

JPEG XL is in the final stages of standardization and its codestream format is frozen.

The libraries API, command line options and tools in this repository are subject to change, however files encoded with cjxl conform to the JPEG XL format specification and can be decoded with current and future djxl decoders or libjxl decoding library.

Quick start guide

For more details and other workflows see the "Advanced guide" below.

Checking out the code

git clone https://gitlab.com/wg1/jpeg-xl.git --recursive

This repository uses git submodules to handle some third party dependencies under third_party/, that's why is important to pass --recursive. If you didn't check out with --recursive, or any submodule has changed, run: git submodule update --init --recursive.

Important: If you downloaded a zip file or tarball from the web interface you won't get the needed submodules and the code will not compile. You can download these external dependencies from source running ./deps.sh. The git workflow described above is recommended instead.

Installing dependencies

Required dependencies for compiling the code, in a Debian/Ubuntu based distribution run:

sudo apt install cmake pkg-config libbrotli-dev

Optional dependencies for supporting other formats in the cjxl/djxl tools, in a Debian/Ubuntu based distribution run:

sudo apt install libgif-dev libjpeg-dev libopenexr-dev libpng-dev libwebp-dev

We recommend using a recent Clang compiler (version 7 or newer), for that install clang and set CC and CXX variables. For example, with clang-7:

sudo apt install clang-7
export CC=clang-7 CXX=clang++-7

Building

cd jpeg-xl
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=OFF ..
cmake --build . -- -j$(nproc)

The encoder/decoder tools will be available in the build/tools directory.

Installing

sudo cmake --install .

Basic encoder/decoder

To encode a source image to JPEG XL with default settings:

build/tools/cjxl input.png output.jxl

For more settings run build/tools/cjxl --help or for a full list of options run build/tools/cjxl -v -v --help.

To decode a JPEG XL file run:

build/tools/djxl input.jxl output.png

When possible cjxl/djxl are able to read/write the following image formats: .exr, .gif, .jpeg/.jpg, .pfm, .pgm/.ppm, .pgx, .png.

Benchmarking

For speed benchmarks on single images in single or multi-threaded decoding djxl can print decoding speed information. See djxl --help for details on the decoding options and note that the output image is optional for benchmarking purposes.

For a more comprehensive comparison of compression density between multiple options see "Benchmarking with benchmark_xl" section below.

Advanced guide

Building with Docker

We build a common environment based on Debian/Ubuntu using Docker. Other systems may have different combinations of versions and dependencies that have not been tested and may not work. For those cases we recommend using the Docker environment as explained in the step by step guide.

Building JPEG XL for developers

For experienced developers, we also provide build instructions for an up to date Debian-based Linux and 64-bit Windows. If you encounter any difficulties, please use Docker instead.

Benchmarking with benchmark_xl

We recommend build/tools/benchmark_xl as a convenient method for reading images or image sequences, encoding them using various codecs (jpeg jxl png webp), decoding the result, and computing objective quality metrics. An example invocation is:

build/tools/benchmark_xl --input "/path/*.png" --codec jxl:wombat:d1,jxl:cheetah:d2

Multiple comma-separated codecs are allowed. The characters after : are parameters for the codec, separated by colons, in this case specifying maximum target psychovisual distances of 1 and 2 (higher implies lower quality) and the encoder effort (see below). Other common parameters are r0.5 (target bitrate 0.5 bits per pixel) and q92 (quality 92, on a scale of 0-100, where higher is better). The jxl codec supports the following additional parameters:

Speed: falcon, cheetah, hare, wombat, squirrel, kitten, tortoise control the encoder effort in ascending order. This also affects memory usage: using lower effort will typically reduce memory consumption during encoding.

  • falcon disables all of the following tools.
  • cheetah enables coefficient reordering, context clustering, and heuristics for selecting DCT sizes and quantization steps.
  • hare enables Gaborish filtering, chroma from luma, and an initial estimate of quantization steps.
  • wombat enables error diffusion quantization and full DCT size selection heuristics.
  • squirrel (default) enables dots, patches, and spline detection, and full context clustering.
  • kitten optimizes the adaptive quantization for a psychovisual metric.
  • tortoise enables a more thorough adaptive quantization search.

Mode: JPEG XL has two modes. The default is Var-DCT mode, which is suitable for lossy compression. The other mode is Modular mode, which is suitable for lossless compression. Modular mode can also do lossy compression (e.g. jxl:m:q50).

  • m activates modular mode.

Other arguments to benchmark_xl include:

  • --save_compressed: save codestreams to output_dir.
  • --save_decompressed: save decompressed outputs to output_dir.
  • --output_extension: selects the format used to output decoded images.
  • --num_threads: number of codec instances that will independently encode/decode images, or 0.
  • --inner_threads: how many threads each instance should use for parallel encoding/decoding, or 0.
  • --encode_reps/--decode_reps: how many times to repeat encoding/decoding each image, for more consistent measurements (we recommend 10).

The benchmark output begins with a header:

Compr              Input    Compr            Compr       Compr  Decomp  Butteraugli
Method            Pixels     Size              BPP   #    MP/s    MP/s     Distance    Error p norm           BPP*pnorm   Errors

ComprMethod lists each each comma-separated codec. InputPixels is the number of pixels in the input image. ComprSize is the codestream size in bytes and ComprBPP the bitrate. Compr MP/s and Decomp MP/s are the compress/decompress throughput, in units of Megapixels/second. Butteraugli Distance indicates the maximum psychovisual error in the decoded image (larger is worse). Error p norm is a similar summary of the psychovisual error, but closer to an average, giving less weight to small low-quality regions. BPP*pnorm is the product of ComprBPP and Error p norm, which is a figure of merit for the codec (lower is better). Errors is nonzero if errors occurred while loading or encoding/decoding the image.

License

This software is available under a 3-clause BSD license which can be found in the LICENSE file, with an "Additional IP Rights Grant" as outlined in the PATENTS file.

Please note that the PATENTS file only mentions Google since Google is the legal entity receiving the Contributor License Agreements (CLA) from all contributors to the JPEG XL Project, including the initial main contributors to the JPEG XL format: Cloudinary and Google.

Additional documentation

Codec description

Development process

Contact

If you encounter a bug or other issue with the software, please open an Issue here.

There is a subreddit about JPEG XL, and informal chatting with developers and early adopters of libjxl can be done on the JPEG XL Discord server.

Comments
  • GIMP Plugin Updates and Fixes

    GIMP Plugin Updates and Fixes

    • Reorganize save dialog
    • Rename functions, modify messages
    • Use JxlEncoderSetBasicInfo
    • Use float as intermediary format
    • Fix float image alpha channels
    • Fix grayscale ICC profile loading
    • Fix distance/quality conversion

    screenshot

    plugin 
    opened by xiota 28
  • Segmentation fault with cjxl built under cygwin

    Segmentation fault with cjxl built under cygwin

    Am running cygwin.

    Built the code according to the instructions on the main page with the following optional libraries: libgif-dev libjpeg-dev libpng-dev libwebp-dev

    Code built successfully

    Running cjxl against any image file as instructed gets this response:

    $cjxl 12345.jpg 12345.jxl
    JPEG XL encoder v0.5.0 [AVX2,SSE4,Scalar]
    Failed to choose default num_threads; you can avoid this error by specifying a --num_threads N argument.
    Use 'cjxl -h' for more information
    

    So, re-ran this:

    $cjxl --num_threads 1 12345.jpg 12345.jxl
    JPEG XL encoder v0.5.0 [AVX2,SSE4,Scalar]
    Read 799x1200 image, 76.4 MP/s
    Encoding [Container | JPEG, lossless transcode, squirrel | JPEG reconstruction data], 1 threads.
    Segmentation fault (core dumped)
    

    To Reproduce Steps to reproduce the behavior:

    Run the locally compiled (under cygwin) cjxl against any image file
    

    Expected behavior

    A jpegxl (.jxl) version of the input image is the expected output
    

    Screenshots If applicable, add screenshots or example input/output images to help explain your problem.

    Environment

    • OS: [e.g. Windows]
    Windows 8.1 / cygwin 3.1.7(0.340/5/3)
    
    • Compiler version: [e.g. clang 11.0.1]

    ~~Dunno how to find which compiler~~

    gcc --version
    gcc (GCC) 9.3.0
    

    Thanks

    • CPU type: [e.g. x86_64]
    x86_64
    
    • cjxl/djxl version string: [e.g. cjxl [v0.3.7 | SIMD supported: SSE4,Scalar]]
    cjxl -v
    JPEG XL encoder v0.5.0 [AVX2,SSE4,Scalar]
    

    Additional context Add any other context about the problem here.

    stackdump attached:

    Exception: STATUS_ACCESS_VIOLATION at rip=0010057893E
    rax=000000000000002F rbx=000000080005EE90 rcx=00000000FFFF87F0
    rdx=0000000000000000 rsi=0000000000000001 rdi=0000000000000000
    r8 =00000000FFFF87D0 r9 =0000000000000000 r10=000000080005EE90
    r11=0000000000000000 r12=00000000000000F0 r13=000000080005F5D0
    r14=0000000000000000 r15=00000008000151F0
    rbp=00000000FFFF8810 rsp=00000000FFFF8730
    program=C:\cygwin64\usr\local\bin\cjxl.exe, pid 3362, thread main
    cs=0033 ds=002B es=002B fs=0053 gs=002B ss=002B
    Stack trace:
    Frame        Function    Args
    000FFFF8810  0010057893E (00000000021, 0000000001E, 0080005F5D0, 00000000000)
    000FFFF88A0  0010057741F (00080183758, 00000000000, 00800053B14, 00000000066)
    000FFFF88E0  0010054B2C0 (00000000006, 008000151A8, 008000151F0, 00800015258)
    000FFFF8D00  00100447AA6 (00800053920, 000FFFFA410, 00800014AA8, 00800014368)
    000FFFF8E00  0010041EABD (000FFFF9DA0, 00800014A40, 00800014220, 000FFFFA850)
    000FFFF94C0  00100419308 (00000000068, 00000000001, 000FFFFBDB0, 000FFFFA410)
    000FFFFA170  00100408CC3 (4034F98C0B0EF22D, 000FFFFBEA0, 00800012FE0, 000FFFFBDB0)
    000FFFFBD90  001004022C9 (000FFFFCC70, 000FFFFCDF0, 00000000030, 8080808080808080)
    000FFFFCCE0  0018004AF2D (00000000000, 00000000000, 00000000000, 00000000000)
    000FFFFFFF0  00180048886 (00000000000, 00000000000, 00000000000, 00000000000)
    000FFFFFFF0  00180048934 (00000000000, 00000000000, 00000000000, 00000000000)
    End of stack trace
    
    building/portability 
    opened by JohnDarkhorse 20
  • JPEG XL image compression quality

    JPEG XL image compression quality

    I tried to assess lossy compression quality for medical images. I used V0.3.7. The lossy compressed images look like useless. I tried efforts 4 and 7 there is no difference. The quality I chose include 90, 98, 99. In all cases artifacts clearly visible. Are any there parameters I missed to adjust, or JPEG XL does not work for 16 bits gray scale images in lossy mode? I tried lossless, it worked fine. I can provide a comparison display of images original and compressed if there is a way to upload. The following is command line I used to compress images:

    ./cjxl ori_file comp_file -e 7 -q 99 --num_threads=2 --num_reps=1 -p

    CJXL responded like this:

    /data/out_png/ct_head_01.png JPEG XL encoder v0.3.7 [AVX2,SSE4,Scalar] ../lib/extras/codec_png.cc:497: PNG: no color_space/icc_pathname given, assuming sRGB Read 512x512 image, 35.8 MP/s Encoding [VarDCT, d0.190, squirrel], 2 threads. Compressed to 9983 bytes (0.305 bpp). 512 x 512, 3.23 MP/s [3.23, 3.23], 1 reps, 2 threads. /data/out_png/ct_lung.png

    question encoder quality 
    opened by yongjianbao 20
  • Request of EXIF support for convert JXL to JPG (exif needs to be added after convertion)

    Request of EXIF support for convert JXL to JPG (exif needs to be added after convertion)

    Hello! I'm looking forward to builders needs to add DJXL for exif support after convertion from JXL to JPG, so JPG recompressed need to have same original metadata came from my camera picture. I tried using exiftool to add .exif metadata into JXL file, but updated file failed.

    3 Major Developers, that I need request help to add EXIF support from JXL to JPG @deymo @jonsneyers @jxl-bot

    Please add support to build.

    Regards

    • Martin Eesmaa
    djxl 
    opened by MartinEesmaa 18
  • cjxl - temp JPEG files remain

    cjxl - temp JPEG files remain

    If the input files are JPEGs, cjxl creates jpe????.tmp files in the system %temp% folder and doesn't delete them after the encoding is finished.

    Windows 10 20H2 x64, cjxl v0.3.7-12-g04267a8

    cjxl building/portability 
    opened by eddiezato 18
  • encoder api: error codes

    encoder api: error codes

    ~~Builds on top of https://github.com/libjxl/libjxl/pull/358 ~~

    ~~Adds an encoder api return code for the case where the jbrd cannot be stored (e.g. because there is too much tail data), but the jpeg image data itself can be recompressed. This is not a fatal error (can still produce a useful jxl that has all the image data and any exif/xmp if there was any), but it's also not just OK (the result is not bit-exact-reconstructible to the original jpeg file).~~

    ~~Applications that do not know this new return code will likely treat it as an (unknown) encoder error, which is fine (this is what would happen before, when failure to write the jbrd would be a fatal encode error).~~

    Adds JxlEncoderGetError which can be used to check the reason why JXL_ENCODE_ERROR was returned: it could be either bad API usage, so an application bug, or an error condition that is not caused by an application bug and an application might want to react to it, e.g. by retrying JPEG recompression without storing the jbrd or by informing the user that the input is invalid.

    Also check the tail data size and return an error slightly earlier if it is too large, and catch this error in cjxl, so instead of a somewhat mysterious error like this:

    ./lib/jxl/fields.cc:729: JXL_FAILURE: No feasible selector for 9936393
    

    you now get a somewhat more useful error like this:

    ./lib/jxl/jpeg/jpeg_data.cc:367: JXL_FAILURE: Tail data too large (max size = 4260096, size = 9936393).
    
    encoder api container/metadata 
    opened by jonsneyers 17
  • Subsampling Fails

    Subsampling Fails

    Describe the bug Attempting to subsample colors causes encoding to fail.

    To Reproduce Add --resampling=2 (or any other valid value other than 1). An error occurs: Failed to compress to VarDCT.

    Expected behavior Produce an image.

    Environment

    • OS: Windows 10
    • Compiler version: various
    • CPU type: x86_64
    • cjxl/djxl version string: [v0.3.7 | SIMD supported: AVX, Scalar]
    cjxl 
    opened by jimbo2150 16
  • Building libjxl dependency Highway 0.14.0 halfway results in

    Building libjxl dependency Highway 0.14.0 halfway results in "Error running executable: Illegal instruction"

    Hello. Hopefully I'm doing this right.

    Describe the bug

    I am trying to build libjxl (0.5) from the Arch Linux User Repository (AUR) and halfway while building its dependency Highway (0.14.0) from the AUR also , I get this error when I am using the GCC:

    [ 56%] Building CXX object CMakeFiles/highway_test.dir/hwy/highway_test.cc.o
    [ 58%] Linking CXX executable tests/highway_test
    CMake Error at /usr/share/cmake-3.21/Modules/GoogleTestAddTests.cmake:77 (message):
      Error running test executable.                                                                                                           
    
        Path: '/home/kylxbn/.cache/paru/clone/highway/src/build/tests/highway_test'                                                            
        Result: Illegal instruction                                                                                                            
        Output:                                                                                                                                
                                                                                                                                               
    
    Call Stack (most recent call first):                                                                                                       
      /usr/share/cmake-3.21/Modules/GoogleTestAddTests.cmake:173 (gtest_discover_tests_impl)                                                   
    
    
    make[2]: *** [CMakeFiles/highway_test.dir/build.make:102: tests/highway_test] Error 1
    make[2]: *** Deleting file 'tests/highway_test'
    make[2]: Leaving directory '/home/kylxbn/.cache/paru/clone/highway/src/build'
    make[1]: *** [CMakeFiles/Makefile2:368: CMakeFiles/highway_test.dir/all] Error 2
    make[1]: Leaving directory '/home/kylxbn/.cache/paru/clone/highway/src/build'
    make: *** [Makefile:146: all] Error 2
    make: Leaving directory '/home/kylxbn/.cache/paru/clone/highway/src/build'
    ==> ERROR: A failure occurred in build().
        Aborting...
    error: failed to build 'highway-0.14.0-1': 
    

    When I try using the clang compiler, I get this:

    [ 56%] Building CXX object CMakeFiles/highway_test.dir/hwy/highway_test.cc.o
    [ 58%] Linking CXX executable tests/highway_test
    CMake Error at /usr/share/cmake-3.21/Modules/GoogleTestAddTests.cmake:77 (message):
      Error running test executable.                                                                                                           
    
        Path: '/home/kylxbn/.cache/paru/clone/highway/src/build/tests/highway_test'                                                            
        Result: Illegal instruction                                                                                                            
        Output:                                                                                                                                
                                                                                                                                               
    
    Call Stack (most recent call first):                                                                                                       
      /usr/share/cmake-3.21/Modules/GoogleTestAddTests.cmake:173 (gtest_discover_tests_impl)                                                   
    
    
    make[2]: *** [CMakeFiles/highway_test.dir/build.make:102: tests/highway_test] Error 1
    make[2]: *** Deleting file 'tests/highway_test'
    make[2]: Leaving directory '/home/kylxbn/.cache/paru/clone/highway/src/build'
    make[1]: *** [CMakeFiles/Makefile2:368: CMakeFiles/highway_test.dir/all] Error 2
    make[1]: Leaving directory '/home/kylxbn/.cache/paru/clone/highway/src/build'
    make: *** [Makefile:146: all] Error 2
    make: Leaving directory '/home/kylxbn/.cache/paru/clone/highway/src/build'
    

    This has been happening since libjxl 0.3.x days (not sure if even older versions are affected, since I only tried compiling 0.3.x), and I was thinking that it was just that my CPU is really old (since it doesn't support SSE 4.2). But I guess I better ask for confirmation regarding this, too.

    To Reproduce

    I have Paru as my AUR helper, and just trying to install libjxl with it will trigger the error.

    paru -S libjxl
    

    It seems to be failing while building the test binaries for Highway. I'm not really familiar with how Highway works, but it looks like it will build test executables, then try to execute it. However, maybe because of that missing SSE 4.2 support on my CPU, some inline assembly code fails to run, resulting in that "Illegal instruction" error and the build failing.

    Expected behavior

    I was hoping that an Illegal instruction error would not occur.

    Environment

    • OS: Arch Linux with GNU/Linux 5.13.7-zen1-1-zen (Zen kernel)
    • Desktop: KDE Plasma 5.22.4
    • Multimedia: PipeWire 0.3.32 and Wayland 1.19 (with xorg-xwayland 21.1.2)
    • Compiler version: GNU GCC 11.1.0 and Clang 12.0.1
    • Compile flags: Please see below
    • Terminal: yakuake
    • Shell: bash 5.1.008
    • CPU type: Intel Core 2 Duo P8400 (x86_64) @ 2.26GHz
    • CPU flags: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ht tm pbe syscall nx lm constant_tsc arch_perfmon pebs bts rep_good nopl cpuid aperfmperf pni dtes64 monitor ds_cpl vmx smx est tm2 ssse3 cx16 xtpr pdcm sse4_1 xsave lahf_lm pti tpr_shadow vnmi flexpriority vpid dtherm ida
    • Hardware: 4GB RAM, 140GB HDD, Dell Latitude E5400
    • cjxl/djxl version string: cjxl v0.5 (not sure if that's how it's shown--I wasn't able to compile cjxl due to dependency problems)

    Compile flags:

    CARCH="x86_64"
    CHOST="x86_64-pc-linux-gnu"
    CFLAGS="-march=x86-64 -mtune=generic -O2 -pipe -fno-plt -fexceptions \
            -Wp,-D_FORTIFY_SOURCE=2 -Wformat -Werror=format-security \
    -fstack-clash-protection -fcf-protection"
    CXXFLAGS="$CFLAGS -Wp,-D_GLIBCXX_ASSERTIONS"
    LDFLAGS="-Wl,-O1,--sort-common,--as-needed,-z,zelro,-z,now"
    

    Additional context

    This is an old laptop and it probably does not support SSE 4.2. While using SIMD instructions is cool and all, maybe a fallback to good old x86_64 ISA would be good if the CPU does not support SIMD? I'm honestly not even sure if the compiler can detect it and if it can be done with stuff like preprocessor commands, but... Just a suggestion? I'm honestly not that familiar with C++.

    This was how the build files were generated when I am using GCC

    -- The C compiler identification is GNU 11.1.0
    -- The CXX compiler identification is GNU 11.1.0
    -- Detecting C compiler ABI info
    -- Detecting C compiler ABI info - done
    -- Check for working C compiler: /usr/bin/cc - skipped
    -- Detecting C compile features
    -- Detecting C compile features - done
    -- Detecting CXX compiler ABI info
    -- Detecting CXX compiler ABI info - done
    -- Check for working CXX compiler: /usr/bin/c++ - skipped
    -- Detecting CXX compile features
    -- Detecting CXX compile features - done
    -- Performing Test HWY_EMSCRIPTEN
    -- Performing Test HWY_EMSCRIPTEN - Failed
    -- Found GTest: /usr/lib64/cmake/GTest/GTestConfig.cmake (found version "1.11.0")  
    -- Configuring done
    -- Generating done
    -- Build files have been written to: /home/kylxbn/.cache/paru/clone/highway/src/build
    

    and this is for clang:

    -- The C compiler identification is Clang 12.0.1
    -- The CXX compiler identification is Clang 12.0.1
    -- Detecting C compiler ABI info
    -- Detecting C compiler ABI info - done
    -- Check for working C compiler: /usr/bin/clang - skipped
    -- Detecting C compile features
    -- Detecting C compile features - done
    -- Detecting CXX compiler ABI info
    -- Detecting CXX compiler ABI info - done
    -- Check for working CXX compiler: /usr/bin/clang++ - skipped
    -- Detecting CXX compile features
    -- Detecting CXX compile features - done
    -- Performing Test HWY_EMSCRIPTEN
    -- Performing Test HWY_EMSCRIPTEN - Failed
    -- Found GTest: /usr/lib64/cmake/GTest/GTestConfig.cmake (found version "1.11.0")  
    -- Configuring done
    -- Generating done
    -- Build files have been written to: /home/kylxbn/.cache/paru/clone/highway/src/build
    

    Hopefully this is useful! Please tell me if I can provide any more details and I would happily help.

    opened by kylxbn 15
  • Build for windows (advanced) doesn't build

    Build for windows (advanced) doesn't build

    I followed the build for windows documentation errors

    a lot of errors seems to be in test_util-int.h how can I skip the test build to see if it's work? or how can I build it for windows?

    building/portability 
    opened by fredprodibi 15
  • export version information in headers

    export version information in headers

    Library version information is currently not exported, which means client code cannot conditionally compile code for different API versions. For example, the recent addition of JxlEncoderOptionsSetInteger along with the deprecation of JxlEncoderOptionsSetEffort means it is now impossible to compile dependent code without raising a compilation error or deprecation warning for code targeting 0.6 and 0.7+, c.f. OSGeo/GDAL#4770

    This PR creates a version.h file exporting the JXL library version.

    api merge-0.7 
    opened by tbonfort 14
  • GIMP plugin: Link against the shared library.

    GIMP plugin: Link against the shared library.

    Now that the plugin only uses the external libjxl API we can link against the shared library. This reduces the binary size from 3.9 MB to 49 KB (both after stripping) which is important from a distribution point of view.

    building/portability merge-0.6 
    opened by deymo 13
  • JxlBasicInfo.alpha_bits set even for a R,G,B,undefined,alpha file

    JxlBasicInfo.alpha_bits set even for a R,G,B,undefined,alpha file

    The attached file rgbau.jxl.zip has num_color_channels = 3, num_extra_channels = 2, with the first extra channel being JXL_CHANNEL_OPTIONAL and the second one JXL_CHANNEL_ALPHA

    Yet jxlinfo -v rgbua.jxl reports

    [...]
    JPEG XL image, 20x20, (possibly) lossless, 8-bit RGBA+Optional
    num_color_channels: 3
    num_extra_channels: 2
    extra channel 0:
      type: Optional
      bits_per_sample: 8
      name: Band 4
    extra channel 1:
      type: Alpha
      bits_per_sample: 8
      name: Band 5
      alpha_premultiplied: 0 (Non-premultiplied)
    

    Note RGBA+Optional. I would rather expect RGB+Optional+Alpha

    On the decoding side, JxlBasicInfo.alpha_bits is set to 8, whether I would expect it to be 0. The documentation of the num_extra_channels, alpha_bits is not super clear if the "main alpha channel" is supposed to be the first extra channel, or could be any. In any case, it seems checking the type of the first extra channel with JxlDecoderGetExtraChannelInfo() is needed.

    Environment

    • OS: Ubuntu 20.04
    • Compiler version: gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0
    • CPU type: x86_64
    • cjxl/djxl version string: JPEG XL encoder v0.7.0 5e7ed06 [AVX2,SSE4,SSSE3,Scalar]
    opened by rouault 2
  • Unable to build man pages for MinGW

    Unable to build man pages for MinGW

    Describe the bug Building libjxl fails.

    To Reproduce Install asciidoc and run cmake. Configuration succeeds, but the build step fails:

    [1/215] Generating djxl.1
    FAILED: djxl.1 C:/msys64/home/kmilos/MINGW-packages/mingw-w64-libjxl/src/build-UCRT64/djxl.1
    cmd.exe /C "cd /D C:\msys64\home\kmilos\MINGW-packages\mingw-w64-libjxl\src\build-UCRT64 && C:\msys64\ucrt64\bin\python3.10.exe C:/msys64/ucrt64/bin/a2x.exe --format manpage --destination-dir="C:/msys64/home/kmilos/MINGW-packages/mingw-w64-libjxl/src/build-UCRT64" C:/msys64/home/kmilos/MINGW-packages/mingw-w64-libjxl/src/libjxl/doc/man/djxl.txt"
    SyntaxError: Non-UTF-8 code starting with '\x90' in file C:\msys64\ucrt64\bin\a2x.exe on line 2, but no encoding declared; see https://python.org/dev/peps/pep-0263/ for details
    

    Expected behavior Build succeeds and man pages are available.

    Perhaps C:\msys64\ucrt64\bin\python3.10.exe C:/msys64/ucrt64/bin/a2x.exe is the culprit: should be trying to interpret a Python script (C:/msys64/ucrt64/bin/a2x-script.py maybe, or C:/msys64/ucrt64/lib/python3.10/site-packages/asciidoc/a2x.py?), not a binary?

    Environment

    • OS: Windows (MSYS2 UCRT64)
    • Compiler version: gcc 12.2.0
    • CPU type: x86_64
    • cjxl/djxl version string: 0.7.0
    opened by kmilos 1
  • Lossy modular with no MA tree learning fails with a cryptic error

    Lossy modular with no MA tree learning fails with a cryptic error

    To Reproduce cjxl -m 1 -I 0 -P 0 -e 9 -g 3 --patches=0 image.png image.jxl

    Actual behavior JxlEncoderProcessOutput failed.

    Expected behavior Show a clearer message so that the user knows that the combination of lossy modular with no MA tree learning is not yet implemented.

    opened by antermin 0
  • Guidance for lossy 16bit compression

    Guidance for lossy 16bit compression

    I'm implementing support for lossy 16bit RGB compression with JXL and am encountering an issue. However I can reproduce my issue with cjxl.

    Test image (16bit png, so doesn't render in gihub): extract

    Test setup: cjxl extract.png extract.jxl , i.e. expecting compression with distance=1, visually lossless

    Expected result: visually lossless jxl Observed result: 1.5kb jxl image, severlely lossy and barely recognisable

    Attached screenshots reconverted to 8bits for visualization: Original: Screenshot from 2022-09-20 11-57-12 JXL: Screenshot from 2022-09-20 11-57-17

    Is this configuration expected to be supported? If so how?

    opened by tbonfort 8
Releases(v0.7.0)
  • v0.7.0(Sep 21, 2022)

    Added

    • decoder API: Ability to decode the content of metadata boxes: JXL_DEC_BOX, JXL_DEC_BOX_NEED_MORE_OUTPUT, JxlDecoderSetBoxBuffer, JxlDecoderGetBoxType, JxlDecoderGetBoxSizeRaw and JxlDecoderSetDecompressBoxes.
    • decoder API: ability to mark the input is finished: JxlDecoderCloseInput.
    • decoder API: ability to request updates on different progressive events using JxlDecoderSetProgressiveDetail; currently supported events are kDC, kLastPasses and kPasses.
    • decoder API: ability to specify desired intensity target using JxlDecoderSetDesiredIntensityTarget
    • decoder API: new function JxlDecoderSetCoalesced to allow decoding non-coalesced (unblended) frames, e.g. layers of a composite still image or the cropped frames of a recompressed GIF/APNG.
    • decoder API: new function JxlDecoderSetUnpremultiplyAlpha to set preference for getting an associated alpha channel with premultiplied or unpremultiplied colors.
    • decoder API: field added to JxlFrameHeader: a JxlLayerInfo struct that contains crop dimensions and offsets and blending information for the non-coalesced case.
    • decoder API: new function JxlDecoderGetExtraChannelBlendInfo to get the blending information for extra channels in the non-coalesced case.
    • decoder API: new function JxlDecoderSetMultithreadedImageOutCallback, allowing output callbacks to receive more information about the number of threads on which they are running.
    • decoder API: new function JxlDecoderSkipCurrentFrame to skip processing the current frame after a progressive detail is reached.
    • decoder API: new function JxlDecoderGetIntendedDownsamplingRatio to get the intended downsampling ratio of progressive steps, based on the information in the frame header.
    • decoder API: new function JxlDecoderSetRenderSpotcolors to allow disabling rendering of spot colors.
    • decoder/encoder API: add two fields to JXLBasicInfo: intrinsic_xsize and intrinsic_ysize to signal the intrinsic size.
    • encoder API: ability to add metadata boxes, added new functions JxlEncoderAddBox, JxlEncoderUseBoxes, JxlEncoderCloseBoxes and JxlEncoderCloseFrames.
    • encoder API: added ability to set several encoder options / extra fields to frames using JxlEncoderSetFrameName, JxlEncoderFrameSettingsSetOption, JxlEncoderFrameSettingsSetFloatOption.
    • encoder API: added ability to check required codestream compatibility level and force specified using JxlEncoderGetRequiredCodestreamLevel and JxlEncoderSetCodestreamLevel.
    • encoder API: added ability to force emitting box-based container format using JxlEncoderUseContainer.
    • encoder API: added ability to store JPEG metadata for lossless reconstruction using JxlEncoderStoreJPEGMetadata
    • encoder API: new functions JxlEncoderSetFrameHeader and JxlEncoderSetExtraChannelBlendInfo to set animation and blending parameters of the frame, and JxlEncoderInitFrameHeader and JxlEncoderInitBlendInfo to initialize the structs to set.
    • encoder API: ability to encode arbitrary extra channels: JxlEncoderInitExtraChannelInfo, JxlEncoderSetExtraChannelInfo, JxlEncoderSetExtraChannelName and JxlEncoderSetExtraChannelBuffer.
    • encoder API: ability to plug custom CMS implementation using JxlEncoderSetCms(JxlEncoder* enc, JxlCmsInterface cms)
    • encoder API: added JxlEncoderGetError to retrieve last encoder error.

    Changed

    • decoder API: using JxlDecoderCloseInput at the end of all input is required when using JXL_DEC_BOX, and is now also encouraged in other cases, but not required in those other cases for backwards compatibility.
    • encoder API: JxlEncoderCloseInput now closes both frames and boxes input.
    • CLI: cjxl and djxl have been reimplemented on the base of public decoder and encoder API; dropped dependency on gflags for argument parsing.

    Deprecated

    • decoder API: JXL_DEC_EXTENSIONS event: use JXL_DEC_BASIC_INFO
    • decoder / encoder API: pixel types JXL_TYPE_BOOLEAN and JXL_TYPE_UINT32: consider using JXL_TYPE_UINT8 and JXL_TYPE_FLOAT correspondingly.
    • decoder API: pixel format parameter for JxlDecoderGetColorAsEncodedProfile and JxlDecoderGetICCProfileSize: pass NULL.
    • decoder API: JxlDecoderDefaultPixelFormat
    • encoder API: JxlEncoderOptions: use JxlEncoderFrameSettings instead.
    • encoder API: JxlEncoderOptionsCreate: use JxlEncoderFrameSettingsCreate instead.
    • encoder API: JxlEncoderOptionsSetDistance: use JxlEncoderSetFrameDistance instead.
    • encoder API: JxlEncoderOptionsSetLossless: use JxlEncoderSetFrameLossless instead.
    • encoder API: JxlEncoderOptionsSetEffort: use JxlEncoderFrameSettingsSetOption(frame_settings, JXL_ENC_FRAME_SETTING_EFFORT, effort) instead.
    • encoder API: JxlEncoderOptionsSetDecodingSpeed: use JxlEncoderFrameSettingsSetOption(frame_settings, JXL_ENC_FRAME_SETTING_DECODING_SPEED, tier) instead.
    • encoder API: deprecated JXL_ENC_NOT_SUPPORTED, the encoder returns JXL_ENC_ERROR instead and there is no need to handle JXL_ENC_NOT_SUPPORTED.

    Note: This release is for evaluation purposes and may contain bugs, including security bugs, that may not be individually documented when fixed. See the SECURITY.md file for details. Always prefer to use the latest release.

    Please provide feedback and report bugs here.

    Source code(tar.gz)
    Source code(zip)
    jxl-linux-x86_64-static-v0.7.0.tar.gz(9.73 MB)
    jxl-x86-windows-static.zip(4.79 MB)
    jxl-x64-windows-static.zip(5.77 MB)
    jxl-debs-amd64-debian-bookworm-v0.7.0.tar.gz(78.52 MB)
    jxl-debs-amd64-debian-bullseye-v0.7.0.tar.gz(82.22 MB)
    jxl-debs-amd64-ubuntu-18.04-v0.7.0.tar.gz(82.11 MB)
    jxl-debs-amd64-ubuntu-20.04-v0.7.0.tar.gz(85.32 MB)
  • v0.7rc(Aug 9, 2022)

    THIS IS A RELEASE CANDIDATE. We expect to have v0.7 release soon.

    Added

    • decoder API: Ability to decode the content of metadata boxes: JXL_DEC_BOX, JXL_DEC_BOX_NEED_MORE_OUTPUT, JxlDecoderSetBoxBuffer, JxlDecoderGetBoxType, JxlDecoderGetBoxSizeRaw and JxlDecoderSetDecompressBoxes.
    • decoder API: ability to mark the input is finished: JxlDecoderCloseInput.
    • decoder API: ability to request updates on different progressive events using JxlDecoderSetProgressiveDetail; currently supported events are kDC, kLastPasses and kPasses.
    • decoder API: ability to specify desired intensity target using JxlDecoderSetDesiredIntensityTarget
    • decoder API: new function JxlDecoderSetCoalesced to allow decoding non-coalesced (unblended) frames, e.g. layers of a composite still image or the cropped frames of a recompressed GIF/APNG.
    • decoder API: new function JxlDecoderSetUnpremultiplyAlpha to set preference for getting an associated alpha channel with premultiplied or unpremultiplied colors.
    • decoder API: field added to JxlFrameHeader: a JxlLayerInfo struct that contains crop dimensions and offsets and blending information for the non-coalesced case.
    • decoder API: new function JxlDecoderGetExtraChannelBlendInfo to get the blending information for extra channels in the non-coalesced case.
    • decoder API: new function JxlDecoderSetMultithreadedImageOutCallback, allowing output callbacks to receive more information about the number of threads on which they are running.
    • decoder API: new function JxlDecoderSkipCurrentFrame to skip processing the current frame after a progressive detail is reached.
    • decoder API: new function JxlDecoderGetIntendedDownsamplingRatio to get the intended downsampling ratio of progressive steps, based on the information in the frame header.
    • decoder API: new function JxlDecoderSetRenderSpotcolors to allow disabling rendering of spot colors.
    • decoder/encoder API: add two fields to JXLBasicInfo: intrinsic_xsize and intrinsic_ysize to signal the intrinsic size.
    • encoder API: ability to add metadata boxes, added new functions JxlEncoderAddBox, JxlEncoderUseBoxes, JxlEncoderCloseBoxes and JxlEncoderCloseFrames.
    • encoder API: added ability to set several encoder options / extra fields to frames using JxlEncoderSetFrameName, JxlEncoderFrameSettingsSetOption, JxlEncoderFrameSettingsSetFloatOption.
    • encoder API: added ability to check required codestream compatibility level and force specified using JxlEncoderGetRequiredCodestreamLevel and JxlEncoderSetCodestreamLevel.
    • encoder API: added ability to force emitting box-based container format using JxlEncoderUseContainer.
    • encoder API: added ability to store JPEG metadata for lossless reconstruction using JxlEncoderStoreJPEGMetadata
    • encoder API: new functions JxlEncoderSetFrameHeader and JxlEncoderSetExtraChannelBlendInfo to set animation and blending parameters of the frame, and JxlEncoderInitFrameHeader and JxlEncoderInitBlendInfo to initialize the structs to set.
    • encoder API: ability to encode arbitrary extra channels: JxlEncoderInitExtraChannelInfo, JxlEncoderSetExtraChannelInfo, JxlEncoderSetExtraChannelName and JxlEncoderSetExtraChannelBuffer.
    • encoder API: ability to plug custom CMS implementation using JxlEncoderSetCms(JxlEncoder* enc, JxlCmsInterface cms)
    • encoder API: added JxlEncoderGetError to retrieve last encoder error.

    Changed

    • decoder API: using JxlDecoderCloseInput at the end of all input is required when using JXL_DEC_BOX, and is now also encouraged in other cases, but not required in those other cases for backwards compatibility.
    • encoder API: JxlEncoderCloseInput now closes both frames and boxes input.
    • CLI: cjxl and djxl have been reimplemented on the base of public decoder and encoder API; dropped dependency on gflags for argument parsing.

    Deprecated

    • decoder API: JXL_DEC_EXTENSIONS event: use JXL_DEC_BASIC_INFO
    • decoder / encoder API: pixel types JXL_TYPE_BOOLEAN and JXL_TYPE_UINT32: consider using JXL_TYPE_UINT8 and JXL_TYPE_FLOAT correspondingly.
    • decoder API: pixel format parameter for JxlDecoderGetColorAsEncodedProfile and JxlDecoderGetICCProfileSize: pass NULL.
    • decoder API: JxlDecoderDefaultPixelFormat
    • encoder API: JxlEncoderOptions: use JxlEncoderFrameSettings instead.
    • encoder API: JxlEncoderOptionsCreate: use JxlEncoderFrameSettingsCreate instead.
    • encoder API: JxlEncoderOptionsSetDistance: use JxlEncoderSetFrameDistance instead.
    • encoder API: JxlEncoderOptionsSetLossless: use JxlEncoderSetFrameLossless instead.
    • encoder API: JxlEncoderOptionsSetEffort: use JxlEncoderFrameSettingsSetOption(frame_settings, JXL_ENC_FRAME_SETTING_EFFORT, effort) instead.
    • encoder API: JxlEncoderOptionsSetDecodingSpeed: use JxlEncoderFrameSettingsSetOption(frame_settings, JXL_ENC_FRAME_SETTING_DECODING_SPEED, tier) instead.
    • encoder API: deprecated JXL_ENC_NOT_SUPPORTED, the encoder returns JXL_ENC_ERROR instead and there is no need to handle JXL_ENC_NOT_SUPPORTED.

    Note: This release is for evaluation purposes and may contain bugs, including security bugs, that may not be individually documented when fixed. See the SECURITY.md file for details. Always prefer to use the latest release.

    Please provide feedback and report bugs here.

    Source code(tar.gz)
    Source code(zip)
    jxl-linux-x86_64-static-v0.7rc.tar.gz(9.73 MB)
    jxl-x86-windows-static.zip(4.18 MB)
    jxl-x64-windows-static.zip(5.14 MB)
    jxl-debs-amd64-debian-bookworm-v0.7rc.tar.gz(79.53 MB)
    jxl-debs-amd64-debian-sid-v0.7rc.tar.gz(78.51 MB)
    jxl-debs-amd64-debian-bullseye-v0.7rc.tar.gz(82.20 MB)
    jxl-debs-amd64-debian-buster-v0.7rc.tar.gz(81.87 MB)
    jxl-debs-amd64-ubuntu-18.04-v0.7rc.tar.gz(82.09 MB)
    jxl-debs-amd64-ubuntu-20.04-v0.7rc.tar.gz(85.29 MB)
  • v0.6.1(Oct 29, 2021)

    Changed

    • Security: Fix OOB read in splines rendering (#735 - CVE-2021-22563)
    • Security: Fix OOB copy (read/write) in out-of-order/multi-threaded decoding (#708 - CVE-2021-22564)
    • Fix segfault in djxl tool with --allow_partial_files flag (#781).
    • Fix border in extra channels when using upsampling (#796)

    Note: This release is for evaluation purposes and may contain bugs, including security bugs, that may not be individually documented when fixed. See the SECURITY.md file for details. Always prefer to use the latest release.

    Please provide feedback and report bugs here.

    Source code(tar.gz)
    Source code(zip)
    jxl-linux-x86_64-static-v0.6.1.tar.gz(9.17 MB)
    jxl-x86-windows-static.zip(3.71 MB)
    jxl-debs-amd64-debian-buster-v0.6.1.tar.gz(86.60 MB)
    jxl-debs-amd64-debian-bookworm-v0.6.1.tar.gz(86.96 MB)
    jxl-debs-amd64-ubuntu-20.04-v0.6.1.tar.gz(88.41 MB)
    jxl-x64-windows-static.zip(4.53 MB)
    jxl-debs-amd64-ubuntu-18.04-v0.6.1.tar.gz(61.85 MB)
  • v0.6(Oct 4, 2021)

    Added

    • API: New functions to decode extra channels: JxlDecoderExtraChannelBufferSize and JxlDecoderSetExtraChannelBuffer.
    • API: New function JxlEncoderInitBasicInfo to initialize JxlBasicInfo (only needed when encoding). NOTE: it is now required to call this function when using the encoder. Padding was added to the struct for forward compatibility.
    • API: Support for encoding oriented images.
    • API: FLOAT16 support in the encoder API.
    • Rewrite of the GDK pixbuf loader plugin. Added proper color management and animation support.
    • Rewrite of GIMP plugin. Added compression parameters dialog and switched to using the public C API.
    • Debian packages for GDK pixbuf loader (libjxl-gdk-pixbuf) and GIMP (libjxl-gimp-plugin) plugins.
    • cjxl/djxl support for stdin and stdout.

    Changed

    • API: Renamed the field alpha_associated in JxlExtraChannelInfo to alpha_premultiplied, to match the corresponding name in JxlBasicInfo.
    • Improved the 2x2 downscaling method in the encoder for the optional color channel resampling for low bit rates.
    • Fixed: the combination of floating point original data, XYB color encoding, and Modular mode was broken (in both encoder and decoder). It now works. NOTE: this can cause the current encoder to write jxl bitstreams that do not decode with the old decoder. In particular this will happen when using cjxl with PFM, EXR, or floating point PSD input, and a combination of XYB and modular mode is used (which caused an encoder error before), e.g. using options like -m -q 80 (lossy modular), -d 4.5 or --progressive_dc=1 (modular DC frame), or default lossy encoding on an image where patches end up being used. There is no problem when using cjxl with PNG, JPEG, GIF, APNG, PPM, PGM, PGX, or integer (8-bit or 16-bit) PSD input.
    • libjxl static library now bundles skcms, fixing static linking in downstream projects when skcms is used.
    • Spline rendering performance improvements.
    • Butteraugli changes for less visual masking.

    Note: This release is for evaluation purposes and may contain bugs, including security bugs, that may not be individually documented when fixed. See the SECURITY.md file for details. Always prefer to use the latest release.

    Please provide feedback and report bugs here.

    Source code(tar.gz)
    Source code(zip)
  • v0.5(Aug 2, 2021)

    Added

    • API: New function to decode the image using a callback outputting a part of a row per call.
    • API: 16-bit float output support.
    • API: JxlDecoderRewind and JxlDecoderSkipFrames functions to skip more efficiently to earlier animation frames.
    • API: JxlDecoderSetPreferredColorProfile function to choose color profile in certain circumstances.
    • encoder: Adding center_x and center_y flags for more control of the tile order.
    • New encoder speeds lightning (1) and thunder (2).

    Changed

    • Re-licensed the project under a BSD 3-Clause license. See the LICENSE and PATENTS files for details.
    • Full JPEG XL part 1 specification support: Implemented all the spec required to decode files to pixels, including cases that are not used by the encoder yet. Part 2 of the spec (container format) is final but not fully implemented here.
    • Butteraugli metric improvements. Exact numbers are different from previous versions.
    • Memory reductions during decoding.
    • Reduce the size of the jxl_dec library by removing dependencies.
    • A few encoding speedups.
    • Clarify the security policy.
    • Significant encoding improvements (~5 %) and less ringing.
    • Butteraugli metric to have some less masking.
    • cjxl flag --speed is deprecated and replaced by the --effort synonym.

    Removed

    • API for returning a downsampled DC was deprecated (JxlDecoderDCOutBufferSize and JxlDecoderSetDCOutBuffer) and will be removed in the next release.

    Note: This release is for evaluation purposes and may contain bugs, including security bugs, that may not be individually documented when fixed. See the SECURITY.md file for details. Always prefer to use the latest release.

    Please provide feedback and report bugs here.

    Source code(tar.gz)
    Source code(zip)
Owner
libjxl
JPEG XL reference software and related tools
libjxl
Rufus is a utility that helps format and create bootable USB flash drives.

Rufus is a utility that helps format and create bootable USB flash drives.

Pete Batard 20.1k Sep 17, 2022
IntX is a C++11 port of IntX arbitrary precision Integer library with speed, about O(N * log N) multiplication/division algorithms implementation.

IntX IntX is a C++11 port of IntX arbitrary precision Integer library with speed, about O(N * log N) multiplication/division algorithms implementation

Telepati 9 Mar 9, 2022
A C++ implementation of the graph algorithm of finding all strongly connected components with DFS

SinkSCC A C++ implementation of the graph algorithm of finding all strongly connected components with DFS. Details Each SCC of a graph can be treated

Schrodinger ZHU Yifan 2 Nov 2, 2021
The Implementation of quadtree-based multi-thread tiled pyramid building algorithm.

tile-map-parallel-builder Quadtree-based multi-thread tiled pyramid building algorithm. Core Concept NOTE: The level is different from TMS zoom level.

Shepard 5 May 16, 2022
C implementation of a sudoku solver with backtracking algorithm

SUDOKU SOLVER Sudoku solver using backtracking algorithm Sudoku game To solve a sudoku, you need a sudoku. So i made a basic implmentation of one with

Jonas STIRNEMANN 2 Mar 23, 2022
C implementation of a classical prefix tree with a search function

C implementation of a classical prefix tree with a search function

Liz3 1 Nov 19, 2021
Standalone c++ implementation for computing Motif Adjacency Matrices of large directed networks, for 3-node graphlets and 4-node graphletsa containing a 4 edge loop.

Building Motif Adjacency Matrices This is an efficient C++ software for building Motif Adjacency Matrices (MAM) of networks, for a range of motifs/gra

null 5 Mar 19, 2022
A C++ implementation of timsort

TimSort A C++ implementation of TimSort, an O(n log n) stable sorting algorithm, ported from Python's and OpenJDK's. See also the following links for

TimSort 265 Sep 16, 2022
Implementation of Dijkstra's algorithm for finding the shortest paths between nodes in a graph using Priority Queue data structure in C

Implementation of Dijkstra's algorithm for finding the shortest paths between nodes in a graph using Priority Queue data structure in C. File "airport

Artem Kolpakov 1 Jan 24, 2022
C implementation of the Landau-Vishkin algorithm

This repo implements the Landau-Vishkin algorithm to compute the edit distance between two strings. This is a fast method for highly similar strings.

Heng Li 35 Sep 9, 2022
The OpenEXR project provides the specification and reference implementation of the EXR file format, the professional-grade image storage format of the motion picture industry.

OpenEXR OpenEXR provides the specification and reference implementation of the EXR file format, the professional-grade image storage format of the mot

Academy Software Foundation 1.3k Sep 26, 2022
Analysing and implementation of lossless data compression techniques like Huffman encoding and LZW was conducted along with JPEG lossy compression technique based on discrete cosine transform (DCT) for Image compression.

PROJECT FILE COMPRESSION ALGORITHMS - Huffman compression LZW compression DCT Aim of the project - Implement above mentioned compression algorithms an

null 1 Dec 14, 2021
An 'embedded-friendly' (aka Arduino) JPEG image encoding library

Starting in the late 80's I wrote my own imaging codecs for the existing standards (CCITT G3/G4 was the first). I soon added GIF, JPEG and not long after that, the PNG specification was ratified. All of this code was "clean room" - written just from the specification. I used my imaging library in many projects and products over the years and recently decided that some of my codecs could get a new lease on life as open source, embedded-friendly libraries for microcontrollers.

Larry Bank 37 Sep 18, 2022
Second life for famous JPEGView - fast and tiny viewer/editor for JPEG, BMP, PNG, WEBP, TGA, GIF and TIFF images with a minimalist GUI and base image processing.

JPEGView-Image-Viewer-and-Editor Updated Dec 07 2021. Version 1.1.1.0 has been released. Download link1, link2 added. Second life for famous JPEGView

Ann Hatt 30 Sep 14, 2022
The “Quite OK Image” format for fast, lossless image compression

The “Quite OK Image” format for fast, lossless image compression

Dominic Szablewski 5.8k Sep 16, 2022
Official repository of the ISO Base Media File Format Reference Software

ISO Base Media File Format (ISOBMFF) This repository is the official repository for the ISO Base Media File Format Reference Software. The ISO base me

null 80 Jul 27, 2022
A Linux reference software for building the Demo Core-Image on Renesas RZ/V2M Evaluation Kit

Introduction This repository is a Linux reference software for building the Demo Core-Image on Renesas RZ/V2M Evaluation Kit . You have to get the pro

Lexra Chang 3 Jan 20, 2022
(Simple String Format) is an syntax of format and a library for parse this.

SSFMT (Simple String Format) is an syntax of format and a library for parse this. SSFMT != {fmt} SSFMT is NOT an API/library for parse {fmt} syntax !

null 2 Jan 30, 2022
Tiny ISO-compliant C++ EXIF and XMP parsing library for JPEG.

TinyEXIF: Tiny ISO-compliant C++ EXIF and XMP parsing library for JPEG Introduction TinyEXIF is a tiny, lightweight C++ library for parsing the metada

cDc 81 Aug 16, 2022
Single header lib for JPEG encoding. Public domain. C99. stb style.

tiny_jpeg.h A header-only public domain implementation of Baseline JPEG compression. Features: stb-style header only library. Does not do dynamic allo

Sergio Gonzalez 200 Aug 24, 2022