issue_owner_repo listlengths 2 2 | issue_body stringlengths 0 262k ⌀ | issue_title stringlengths 1 1.02k | issue_comments_url stringlengths 53 116 | issue_comments_count int64 0 2.49k | issue_created_at stringdate 1999-03-17 02:06:42 2025-06-23 11:41:49 | issue_updated_at stringdate 2000-02-10 06:43:57 2025-06-23 11:43:00 | issue_html_url stringlengths 34 97 | issue_github_id int64 132 3.17B | issue_number int64 1 215k |
|---|---|---|---|---|---|---|---|---|---|
[
"libjxl",
"libjxl"
] | **Describe the bug**
gThumb does not start anymore (since today). I get the following error:
** (gthumb:4589): CRITICAL **: 19:48:07.750: Could not load the mandatory extension 'cairo_io': Could not open the module “cairo_io”: libjxl.so.0: cannot open shared object file: No such file or directory
Aborted (core dumped)
**To Reproduce**
Start gThumb
**Expected behavior**
Just start up :)
**Environment**
- OS: Ubuntu 22.04
- libjxl 0.6.1~ppa1~focal
- gThumb 3:3.12.2-0focal1
Somebody else seems to have a similar problem, although I don't understand it:
https://forum.linux-mint-czech.cz/viewtopic.php?p=46377
Related to libjxl?
Anything I can do? | gThumb would not start | https://api.github.com/repos/libjxl/libjxl/issues/1515/comments | 1 | 2022-06-17T18:13:23Z | 2022-06-21T13:21:12Z | https://github.com/libjxl/libjxl/issues/1515 | 1,275,333,252 | 1,515 |
[
"libjxl",
"libjxl"
] | Please add JXL_PRIMARIES_XYZ = 10 to JxlPrimaries, Primaries::kXYZ = 10, and associated coordinates to ColorEncoding::GetPrimaries() and ColorEncoding::SetPrimaries()
There is already JXL_WHITE_POINT_E = 10 so this would make encoding the CIE 1931 XYZ color space much more convenient. | Add CIE XYZ color primaries | https://api.github.com/repos/libjxl/libjxl/issues/1507/comments | 3 | 2022-06-16T12:26:59Z | 2025-01-30T12:29:14Z | https://github.com/libjxl/libjxl/issues/1507 | 1,273,495,072 | 1,507 |
[
"libjxl",
"libjxl"
] | Currently `cjxl` can't handle text chunks (`tEXt`/`iTXt`/`zTXt`) in PNG files and transfer metadata to JXL. It would be useful to have support of this. | Feature request: Support for `cjxl` to handle text chunks in PNGs | https://api.github.com/repos/libjxl/libjxl/issues/1498/comments | 6 | 2022-06-15T08:35:17Z | 2023-01-23T10:50:24Z | https://github.com/libjxl/libjxl/issues/1498 | 1,271,874,668 | 1,498 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
When using the benchmark tool, the quality parameter seems to be ignored. All the results have the same compressed size and BPP.
**To Reproduce**
Run the following command with any picture : `benchmark_xl --input images/image.png --codec jxl:q100,jxl:q0`
**Expected behavior**
The benchmark tool should produce different compressed sizes and BPPs according to the specified quality factor.
**Screenshots**
Example output that shows identical compressed size (Bytes) and BPP :
```
Encoding kPixels Bytes BPP E MP/s D MP/s Max norm pnorm BPP*pnorm Bugs
------------------------------------------------------------------------------------------------------------
jxl:q100 1638 425223 2.0758787 5.250 34.098 1.50533056 0.70551218 1.464557721644 0
jxl:q0 1638 425223 2.0758787 5.088 32.011 1.50533056 0.70551218 1.464557721644 0
Aggregate: 1638 425223 2.0758787 5.169 33.038 1.50533056 0.70551218 1.464557721644 0
```
**Environment**
- OS: Ubuntu 20.04
- Compiler version: clang version 10.0.0-4ubuntu1
- CPU type: x86_64
- cjxl/djxl version string: v0.6.1 a205468 [AVX2,SSE4,Scalar] | The benchmark tool ignores the quality parameter | https://api.github.com/repos/libjxl/libjxl/issues/1496/comments | 5 | 2022-06-14T13:03:49Z | 2025-01-17T21:29:36Z | https://github.com/libjxl/libjxl/issues/1496 | 1,270,777,446 | 1,496 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
libjxl cannot read from or write to any file if the path or filename contains non-ascii characters in Windows 10.
**To Reproduce**
Steps to reproduce the behavior:
* Get any image
* Use cjxl to convert "θθθθξξξ.jxl"
You will get an error message saying
Failed to write to "???????.jxl"
* Alternatively, rename any jpg to "θθθθξξξ.jpg" and try to convert it to JXL.
There will be no output whatsoever
**Examples**
```powershell
PS C:\Users\User\Downloads> cjxl .\test.jpg θθθθθθξξξ.jxl
JPEG XL encoder v0.7.0 ab775e2 [AVX2,SSE4,SSSE3,Scalar]
Read 4032x3024 image, 44.6 MP/s
Encoding [Container | JPEG, lossless transcode, squirrel | JPEG reconstruction data | 51646-byte Exif], 16 threads.
Compressed to 6611392 bytes (4.338 bpp).
4032 x 3024, 49.77 MP/s [49.77, 49.77], 1 reps, 16 threads.
Including container: 6665727 bytes (4.374 bpp).
Failed to write to "?????????.jxl"
PS C:\Users\User\Downloads> cjxl .\θθθθξξξ.jpg broken.jxl
JPEG XL encoder v0.7.0 ab775e2 [AVX2,SSE4,SSSE3,Scalar]
PS C:\Users\User\Downloads>
```
And with djxl:
```powershell
djxl .\ξξξξθθθ.jxl test.png
JPEG XL decoder v0.7.0 ab775e2 [AVX2,SSE4,SSSE3,Scalar]
Failed to read file: .\???????.jxl.
```
**Environment**
- OS: Windows 10 21H2
- CPU type: x64
- cjxl/djxl version string: JPEG XL encoder v0.7.0 ab775e2 [AVX2,SSE4,SSSE3,Scalar]
(Can also reproduce in latest official [release](https://github.com/libjxl/libjxl/releases/tag/v0.6.1))
It appears to be Windows-only, as I had no problem with any character on Fedora. | libjxl cannot read/write to any file if it contains non-ascii characters in Windows 10 | https://api.github.com/repos/libjxl/libjxl/issues/1494/comments | 2 | 2022-06-11T19:37:51Z | 2022-06-13T10:34:04Z | https://github.com/libjxl/libjxl/issues/1494 | 1,268,357,789 | 1,494 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
I've tried to convert DNG files to JXL via ImageMagick (which I understand uses libjxl).
exiftool shows that the data is in 16 bit depth and RGGB:
<details>
```console
$ exiftool IMG_20220603_144349_0.dng
ExifTool Version Number : 12.42
File Name : IMG_20220603_144349_0.dng
Directory : .
File Size : 24 MB
File Modification Date/Time : 2022:06:09 13:14:58+02:00
File Access Date/Time : 2022:06:09 13:14:58+02:00
File Inode Change Date/Time : 2022:06:09 22:21:47+02:00
File Permissions : -rw-r--r--
File Type : DNG
File Type Extension : dng
MIME Type : image/x-adobe-dng
Exif Byte Order : Little-endian (Intel, II)
Subfile Type : Full-resolution image
Image Width : 4000
Image Height : 3000
Bits Per Sample : 16
Compression : Uncompressed
Photometric Interpretation : Color Filter Array
Image Description :
Make : Xiaomi
Camera Model Name : M2101K6G
Strip Offsets : (Binary data 25621 bytes, use -b option to extract)
Orientation : Horizontal (normal)
Samples Per Pixel : 1
Rows Per Strip : 1
Strip Byte Counts : (Binary data 14999 bytes, use -b option to extract)
X Resolution : 72
Y Resolution : 72
Planar Configuration : Chunky
Resolution Unit : inches
Software : Redmi/sweet_eea/sweet:12/SKQ1.210908.001/V13.0.8.0.SKFEUXM:user/release-keys
Modify Date : 2022:06:03 14:43:49
CFA Repeat Pattern Dim : 2 2
CFA Pattern 2 : 1 2 0 1
Copyright :
Exposure Time : 1/941
F Number : 1.9
ISO : 50
Date/Time Original : 2022:06:03 14:43:49
Focal Length : 6.0 mm
TIFF-EP Standard ID : 1 0 0 0
DNG Version : 1.4.0.0
DNG Backward Version : 1.1.0.0
Unique Camera Model : M2101K6G-Xiaomi-Redmi
CFA Plane Color : Red,Green,Blue
CFA Layout : Rectangular
Black Level Repeat Dim : 2 2
Black Level : 64 64 64 64
White Level : 1023
Default Scale : 1 1
Default Crop Origin : 8 8
Default Crop Size : 3984 2984
Color Matrix 1 : 0.6875 -0.09375 -0.0703125 -0.4140625 1.203125 0.171875 -0.0625 0.234375 0.4140625
Color Matrix 2 : 1.34375 -0.5078125 -0.46875 -0.296875 1.4140625 -0.25 0.0390625 0.1484375 0.5234375
Camera Calibration 1 : 0.6171875 0 0 0 1 0 0 0 0.640625
Camera Calibration 2 : 1 0 0 0 1 0 0 0 1
As Shot Neutral : 0.529296875 1 0.5908203125
Baseline Exposure : 0
Calibration Illuminant 1 : D65
Calibration Illuminant 2 : Standard Light A
Active Area : 0 0 3000 4000
Forward Matrix 1 : 0.765625 0.125 0.0703125 0.2734375 0.9296875 -0.203125 -0.0234375 -0.3671875 1.2109375
Forward Matrix 2 : 0.5078125 0.046875 0.40625 0.046875 0.734375 0.21875 -0.1796875 -0.5703125 1.5703125
Opcode List 2 : GainMap, GainMap, GainMap, GainMap
Noise Profile : 9.34903000467e-05 3.209479880749e-07 4.256158549375e-05 2.425648234101e-07 3.40389499548e-05 3.24915177521575e-07
Aperture : 1.9
CFA Pattern : [Green,Blue][Red,Green]
Image Size : 4000x3000
Megapixels : 12.0
Shutter Speed : 1/941
Focal Length : 6.0 mm
Light Value : 12.7
```
</details>
So data stored in DNG which gets recompressed to JXL will produce significantly larger files. I think ImageMagick is inflating the DNG file because it does Debayering from 16 bit RGGB to 4 times 16 bit RGB - right?
Is there a "best practice" to convert raw images without any loss in data to JXL? Will cjxl/djxl support DNG import/export eventually?
**To Reproduce**
- Create a DNG
- Convert it with ImageMagick with `-quality 100 -define jxl:effort=7` to jxl
- Get a larger output file than input file
**Expected behavior**
Have a similar or smaller output size than input size and four channel RGGB data
**Screenshots**
Additionally, there seems to be an issue with some information about the raw nature of these pictures getting lost. So Gimp will render them in weird tones instead of doing a raw-import:
Otherwise, the picture looks fine (details retained etc.):
**Environment**
- OS: Linux
- Compiler version: gcc (12.1)
- CPU type: x86_64
- cjxl/djxl version string:
```console
$ cjxl --version
cjxl v0.6.1 a205468b [AVX2,SSE4,SSSE3]
Copyright (c) the JPEG XL Project
$ convert --version
Version: ImageMagick 7.1.0-37 Q16-HDRI x86_64 20104 https://imagemagick.org
Copyright: (C) 1999 ImageMagick Studio LLC
License: https://imagemagick.org/script/license.php
Features: Cipher DPC HDRI Modules OpenCL OpenMP(4.5)
Delegates (built-in): bzlib cairo djvu fontconfig freetype heic jbig jng jp2 jpeg jxl lcms lqr ltdl lzma openexr pangocairo png raqm raw rsvg tiff webp wmf x xml zip zlib
Compiler: gcc (12.1)
```
**Additional context**
File sizes:
```
$ du -h IMG_20220603_144349_0*
23M IMG_20220603_144349_0.dng
42M IMG_20220603_144349_0.jxl
27M IMG_20220603_144349_0_gimp.jxl
``` | Converting DNG to JXL nearly doubles the filesize | https://api.github.com/repos/libjxl/libjxl/issues/1492/comments | 17 | 2022-06-09T21:52:51Z | 2024-09-03T05:18:23Z | https://github.com/libjxl/libjxl/issues/1492 | 1,266,710,505 | 1,492 |
[
"libjxl",
"libjxl"
] | The AFV dequantization table encoding requires three sets of parameters (`afv_weights`, `dct_params`, `dct_params_afv_4x4`) for each channel, but last two are encoded and decoded three times both in the [encoder](https://github.com/libjxl/libjxl/blob/e39a862/lib/jxl/enc_quant_weights.cc#L108-L110) and [decoder](https://github.com/libjxl/libjxl/blob/e39a862/lib/jxl/quant_weights.cc#L453-L454). Since the decoder overwrites an already decoded set of parameters, first two sets (4 sets in total) are entirely useless. This also doesn't match the specification.
We have two choices here:
* Fix the specification to read and discard 4 sets of unused parameters. Effectively they become reserved. libjxl then can replace these sets with placeholder parameters (4 bits each), saving a handful of bytes.
* Fix libjxl to match the specification. Okay if no bitstreams encoded with libjxl are using this encoding.
| Some AFV dequantization parameters are encoded and decoded three times | https://api.github.com/repos/libjxl/libjxl/issues/1484/comments | 0 | 2022-06-08T20:51:04Z | 2024-03-04T10:12:45Z | https://github.com/libjxl/libjxl/issues/1484 | 1,265,295,389 | 1,484 |
[
"libjxl",
"libjxl"
] | **Is your feature request related to a problem? Please describe.**
Currently, libjxl builds the jxl_extras static library even with JPEGXL_ENABLE_TOOLS disabled. In this case, it will look up dependencies such as PNG, GIF, OpenEXR, etc. and build all the associated objects, which will then be left unused.
**Describe the solution you'd like**
jxl_extras should be skipped if no targets use it.
**Describe alternatives you've considered**
At Krita we hotpatch libjxl as follows:
```diff
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index a366e51..257f87d 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -132,7 +132,9 @@ endif() #!MSVC
include(jxl.cmake)
# Other libraries outside the core jxl library.
+if(JPEGXL_ENABLE_TOOLS)
include(jxl_extras.cmake)
+endif()
include(jxl_threads.cmake)
# Install all the library headers from the source and the generated ones. There
```
**Additional context**
Krita support for libjxl is scheduled for release in 5.1. See [!1363](https://invent.kde.org/graphics/krita/-/merge_requests/1363).
| jxl_extra gets built and sits unused if JPEGXL_ENABLE_TOOLS is set to FALSE | https://api.github.com/repos/libjxl/libjxl/issues/1483/comments | 1 | 2022-06-08T20:33:21Z | 2022-06-09T12:15:30Z | https://github.com/libjxl/libjxl/issues/1483 | 1,265,272,955 | 1,483 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
A file that has an extended box size fails to be read by either libjxl or djxl.
**To Reproduce**
An extended box size is when an ISOBMFF box has `size == 1`. When this happens, the size field is immediately followed by an 8-byte extended-size field, which contains a 64-bit true size. These are permitted even if the extended size is less than 4G.
Take any JXL file with an extended box size and attempt to decode it with djxl or libjxl. It will not decode properly.
**Expected behavior**
The file should decode properly.
**Other information**
I believe the fault here is in `decode.cc` line 1768. https://github.com/libjxl/libjxl/blob/ab775e2298b1ef25229e19ad3f4dba4b06000197/lib/jxl/decode.cc#L1768
The extended box size field is read after the box tag field, but it should be *immediately* after the box size field, and before the box tag field. Contrast the existing behavior with the FFmpeg `mov.c` decoder: https://github.com/ffmpeg/FFmpeg/blob/35ec5c819b0f472536eb48e8f3871eb5ca222da6/libavformat/mov.c#L7813
| libjxl cannot read extended ISOBMFF box sizes | https://api.github.com/repos/libjxl/libjxl/issues/1478/comments | 12 | 2022-06-06T19:05:20Z | 2023-11-23T18:56:56Z | https://github.com/libjxl/libjxl/issues/1478 | 1,262,252,239 | 1,478 |
[
"libjxl",
"libjxl"
] | ## desc
There is a assert failure in libjxl before version 0.6.1 that could cause deny of service attack.
## asan output
```
./lib/jxl/render_pipeline/low_memory_render_pipeline.cc:312: JXL_ASSERT: first_image_dim_stage_ == stages_.size() || i >= first_image_dim_stage_
#0 0x558c6d05047e in __sanitizer_print_stack_trace /fuzz/fuzzdeps/llvm-project-11.0.0/compiler-rt/lib/asan/asan_stack.cpp:86:3
#1 0x7fd128ed84b8 in jxl::Abort() /libjxl/SRC/lib/jxl/base/status.h:132:3
#2 0x7fd12976cc2b in jxl::LowMemoryRenderPipeline::Init() /libjxl/SRC/lib/jxl/render_pipeline/low_memory_render_pipeline.cc:311:9
#3 0x7fd12978248d in jxl::RenderPipeline::Builder::Finalize(jxl::FrameDimensions) && /libjxl/SRC/lib/jxl/render_pipeline/render_pipeline.cc:91:8
#4 0x7fd1293a62af in jxl::PassesDecoderState::PreparePipeline(jxl::ImageBundle*, jxl::PassesDecoderState::PipelineOptions) /libjxl/SRC/lib/jxl/dec_cache.cc:198:40
#5 0x7fd1293c5964 in jxl::FrameDecoder::ProcessSections(jxl::FrameDecoder::SectionInfo const*, unsigned long, jxl::FrameDecoder::SectionStatus*) /libjxl/SRC/lib/jxl/dec_frame.cc:775:5
#6 0x7fd1295aa44a in jxl::(anonymous namespace)::JxlDecoderProcessCodestream(JxlDecoderStruct*, unsigned char const*, unsigned long) /libjxl/SRC/lib/jxl/decode.cc:1555:27
#7 0x7fd1295aa44a in HandleBoxes(JxlDecoderStruct*) /libjxl/SRC/lib/jxl/decode.cc:2079:11
#8 0x7fd1295a25da in JxlDecoderProcessInput /libjxl/SRC/lib/jxl/decode.cc:2251:29
#9 0x558c6d07ed4a in DecodeJpegXlOneShot(unsigned char const*, unsigned long, std::vector<float, std::allocator<float> >*, unsigned long*, unsigned long*, std::vector<unsigned char, std::allocator<unsigned char> >*) /libjxl/SRC/examples/decode_oneshot.cc:58:31
#10 0x558c6d080317 in main /libjxl/SRC/examples/decode_oneshot.cc:233:8
#11 0x7fd12892b082 in __libc_start_main /build/glibc-SzIz7B/glibc-2.31/csu/../csu/libc-start.c:308:16
#12 0x558c6cfa152d in _start (/libjxl/fuzzrun/decode_oneshot+0x1f52d)
[1] 888096 illegal hardware instruction ./decode_oneshot /tmp/poc /dev/null /dev/null
```
## reproduce
* compile libjxl with address sanitizer
* run `./decode_oneshot ./poc /dev/null /dev/null` | Assert failure in jxl::LowMemoryRenderPipeline::Init | https://api.github.com/repos/libjxl/libjxl/issues/1477/comments | 10 | 2022-06-06T08:27:22Z | 2022-09-26T08:10:29Z | https://github.com/libjxl/libjxl/issues/1477 | 1,261,520,060 | 1,477 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
For unknown reasons cjxl crashes when trying to encode to jxl
**To Reproduce**
Download the next [2 images](https://www.mediafire.com/file/kjhquzryd6ec9ob/JPEG_XL_crash_samples.zip/file) (a png and a PPM) and try to encode them with:
`cjxl "input.ppm" "input.jxl"`
**Environment**
- OS: Win7 SP1 x64
- CPU type: i7-4790K
- djxl version string: JPEG XL decoder v0.7.0 ab775e2 [AVX2,SSE4,SSSE3,Scalar]
- cjxl version string: JPEG XL encoder v0.7.0 b432598 [AVX2,SSE4,SSSE3,Scalar] | Crash on certain files | https://api.github.com/repos/libjxl/libjxl/issues/1476/comments | 1 | 2022-06-05T10:58:25Z | 2022-06-05T12:06:35Z | https://github.com/libjxl/libjxl/issues/1476 | 1,261,020,452 | 1,476 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
I tried to compare the performance of cjxl other formats.
cjxl consumes an (IMHO) unreasonable amount of memory before it gets killed by the linux kernel.
**To Reproduce**
Steps to reproduce the behavior:
- [Download image](https://bafykbzacebf676y5eadx6xvgncvfr43e5k7yryugcj6cx4zjhwerfnoralruy.ipfs.dweb.link//rk_image_set_2022.05/Commons/03_Flat_Image_200dpi_Iglesia_Parroquial_de_San_Guillermo_de_Aquitania_Version_1.0_ProjectKisame_%2815214229916%29.jpg)
- Try to convert it to JXL via
```
cjxl --jpeg_transcode --quality=70 -e 7 '03_Flat_Image_200dpi_Iglesia_Parroquial_de_San_Guillermo_de_Aquitania_Version_1.0_ProjectKisame_(15214229916).jpg' '03_Flat_Image_200dpi_Iglesia_Parroquial_de_San_Guillermo_de_Aquitania_Version_1.0_ProjectKisame_(15214229916)_cjxl.jxl'
```
- Run out of memory on a 16 GB machine:
```
$ time cjxl --jpeg_transcode --quality=70 -e 7 '03_Flat_Image_200dpi_Iglesia_Parroquial_de_San_Guillermo_de_Aquitania_Version_1.0_ProjectKisame_(15214229916).jpg' '03_Flat_Image_200dpi_Iglesia_Parroquial_de_San_Guillermo_de_Aquitania_Version_1.0_ProjectKisame_(15214229916)_cjxl.jxl'
JPEG XL encoder v0.6.1 a205468b [AVX2,SSE4,SSSE3]
Read 24000x15000 image, 132.4 MP/s
Encoding [Container | VarDCT, d2.800, squirrel | 8239-byte Exif], 4 threads.
Killed
real 0m12.848s
user 0m9.029s
sys 0m4.368s
```
**Expected behavior**
cjxl should convert the image with the available amount of memory, or at least notify the user that it's unable to do this with the available amount of memory.
**Screenshots**
If applicable, add screenshots or example input/output images to help explain your problem.
**Environment**
- OS: Linux
- Compiler version: Unknown ([Binary Package](https://archive.archlinux.org/packages/l/libjxl/libjxl-0.6.1-3-x86_64.pkg.tar.zst) from Archlinux)
- CPU type: 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz
- cjxl/djxl version string: v0.6.1 a205468b [AVX2,SSE4,SSSE3]
**Additional context**
| cjxl runs out of memory on a 16 GB machine while converting large jpg | https://api.github.com/repos/libjxl/libjxl/issues/1475/comments | 10 | 2022-06-05T02:22:49Z | 2025-01-17T21:18:27Z | https://github.com/libjxl/libjxl/issues/1475 | 1,260,941,036 | 1,475 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
Being aware that jpeg decoding is not standardized I never observed such a decoding degradation as cjxl did.
For comparison I decoded the jpeg with mozjpeg library and compared with the output of "To Reproduce" calls.
For mozjpeg I used the call:
`djpeg -bmp -dct float "input.jpg" >"input.jpg.bmp"`
**To Reproduce**
Lossless transcode with jpeg input:
`cjxl "input.jpg" "input.jpg.jxl"`
`djxl "input.jpg.jxl" "input.jpg.jxl.png"`
**Expected behavior**
I expect an exact, if not very close rendition of a reference jpeg decoding library, not a degradation.
**Screenshots**
[dec_moz](https://i.imgur.com/tF7XRRL.png)
[dec_jxl](https://i.imgur.com/rhq5Z6i.png)
**Environment**
- OS: Win7 SP1 x64
- CPU type: i7-4790K
- djxl version string: JPEG XL decoder v0.7.0 ab775e2 [AVX2,SSE4,SSSE3,Scalar]
- cjxl version string: JPEG XL encoder v0.7.0 b432598 [AVX2,SSE4,SSSE3,Scalar]
| Subpar decoding for transcoded jpegs | https://api.github.com/repos/libjxl/libjxl/issues/1470/comments | 51 | 2022-06-02T07:27:53Z | 2024-10-31T18:06:21Z | https://github.com/libjxl/libjxl/issues/1470 | 1,257,801,213 | 1,470 |
[
"libjxl",
"libjxl"
] | Currently we return an error if JxlDecoderFlushImage() is called before all the DC image is decoded. We should instead implement something that renders whatever coefficients we already have. | Support JxlDecoderFlushImage() before DC image is ready. | https://api.github.com/repos/libjxl/libjxl/issues/1465/comments | 0 | 2022-05-31T11:15:20Z | 2022-05-31T11:15:56Z | https://github.com/libjxl/libjxl/issues/1465 | 1,253,713,200 | 1,465 |
[
"libjxl",
"libjxl"
] | **To Reproduce**
- Get this apng file (it contains multiple frames, it was encoded using ffmpeg):
- Get static Linux build from here: https://github.com/libjxl/libjxl/actions/runs/2398179621#artifacts , namely this:
https://github.com/libjxl/libjxl/suites/6690650728/artifacts/253925770
- Run this command: `./cjxl --num_threads=2 -d 0 ~/jpeg-xl/tr.png ~/jpeg-xl/out.jxl`
- This is what I saw:
```text
$ ./cjxl --num_threads=2 -d 0 ~/jpeg-xl/tr.png ~/jpeg-xl/out.jxl
JPEG XL encoder v0.7.0 422d09a4 [AVX2,SSE4,SSSE3,Scalar]
./lib/extras/packed_image_convert.cc:130: JXL_ASSERT: frame_rect.IsInside(Rect(0, 0, ppf.info.xsize, ppf.info.ysize))
Illegal instruction
```
**Expected behavior**
File should be encoded
**Environment**
- OS: Debian Stretch
- Compiler version: (I used Github artifact)
- CPU type: x86_64
- cjxl/djxl version string: cjxl v0.7.0 422d09a4 [AVX2,SSE4,SSSE3,Scalar] | "JXL_ASSERT: frame_rect.IsInside(Rect(0, 0, ppf.info.xsize, ppf.info.ysize))" on attached apng file | https://api.github.com/repos/libjxl/libjxl/issues/1457/comments | 3 | 2022-05-29T12:15:31Z | 2022-08-09T08:35:27Z | https://github.com/libjxl/libjxl/issues/1457 | 1,251,873,030 | 1,457 |
[
"libjxl",
"libjxl"
] | "./lib/jxl/enc_ans.cc:478: JXL_ASSERT: cost >= 0" when trying to encode ~880MP uncompreesed png wit q=100 or d=0.0 at effort=1, works fine when using d>0 or q<100
**To Reproduce**
1. get the image
2. try to encode it with cjxl with -q 100 -e 1
3. wait 60s or so (needs ~54GB of RAM)
4. error
**Expected behavior**
the encode does not throw an error.
**Screenshots**
screenshot of the full cjxl terminal output
**Environment**
- OS: Arch Linux
- Compiler version: clang 13.0.1
- CPU type: x86_64
- cjxl/djxl version string: JPEG XL encoder v0.7.0 1706491c [AVX2,SSE4,SSSE3,Emu128]
**Additional context**
original image
https://drive.google.com/file/d/1DpcAHnvMD2t7TqszsF4Kj1tUYsj4_2mc/view?usp=sharing
image encoded using q=1.0
https://drive.google.com/file/d/1oiA61m5O6OrIPI4cwZWN-zJyBaDoEd17/view?usp=sharing
| error encoding very large PNG file | https://api.github.com/repos/libjxl/libjxl/issues/1456/comments | 1 | 2022-05-27T21:36:05Z | 2022-05-30T12:16:53Z | https://github.com/libjxl/libjxl/issues/1456 | 1,251,294,416 | 1,456 |
[
"libjxl",
"libjxl"
] | Run: `ci.sh lint`
Result:
```
fatal: no upstream configured for branch 'exta'
Warning, not tracking any branch, using the last commit in HEAD.
```
However, it worked before. | `ci.sh lint` is broken | https://api.github.com/repos/libjxl/libjxl/issues/1454/comments | 0 | 2022-05-27T14:55:45Z | 2022-05-27T18:39:02Z | https://github.com/libjxl/libjxl/issues/1454 | 1,250,863,283 | 1,454 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
libjxl calls abort(). Since it is intended as a library to be used in other projects, it shouldn't do this.
**To Reproduce**
Steps to reproduce the behavior:
Basically any flow, including the loading of a corrupted file or API misuse, that results in a call to one of the following:
- jxl::Abort()
- JxlThreadParallelRunner::Abort()
**Expected behavior**
Calling abort() within a library is a bug because the library has no way of knowing what the calling application is doing. If the calling application is a process that is either statically linked to the library, a process that is dynamically linked to it or a process that calls a DLL that loads the library in any fashion, that abort() call will lead to the entire application suddenly crashing, sometimes for apparently no reason or a very trivial one.
Consider, for instance, a case where libjxl is being used to store and load small images used as, say, employee mugshots in a listing in an app that does something completely unrelated to graphics. The mugshots are an unimportant feature and an invalid thumbnail file should ideally just result in a blank square, but the current implementation will crash the entire app as a result of the abort() call. The HR app for payroll crashing because the new intern's photo was causing one of the many image-file loading libraries to intentionally abort() the program cannot be described as a good design.
In my view, there is no error that can be encountered within a library that justifies aborting the calling process.
There are two ways to address this:
- Use the approach taken in butteraugli.cc, which is to wrap the fault-handler that calls abort() in an "enable_checks" switch
- Implement a proper fault-handling scheme that results in the relevant error being sent back to the calling application via the return value of the currently executing libjxl function.
**Screenshots**
n/a
**Environment**
- OS: Windows
- Compiler version: MSVC 2017 (ver 14.16)]
- CPU type: x86_64
- cjxl/djxl version string: n/a
**Additional context**
| libjxl uses abort() | https://api.github.com/repos/libjxl/libjxl/issues/1450/comments | 2 | 2022-05-26T16:43:35Z | 2024-09-14T07:20:34Z | https://github.com/libjxl/libjxl/issues/1450 | 1,249,804,585 | 1,450 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
Encoder crashes with the following assert:
../lib/jxl/dec_group.cc:245: JXL_ASSERT: r[i].IsInside({0, 0, dec_state->shared->dc->Plane(i).xsize(), dec_state->shared->dc->Plane(i).ysize()})
**To Reproduce**
cjxl wollerau.png wollerau.jxl --progressive_dc=2 -e 9
**Environment**
- OS: ChromeOS
- Compiler version: clang 11.0.1
- CPU type: x86_64
- cjxl/djxl version string: JPEG XL encoder v0.7.0 dbe51c6 [AVX2,SSE4,SSSE3,Scalar]
| cjxl crashes with --progressive_dc=2 -e 9 | https://api.github.com/repos/libjxl/libjxl/issues/1448/comments | 4 | 2022-05-26T15:55:25Z | 2024-03-04T10:12:45Z | https://github.com/libjxl/libjxl/issues/1448 | 1,249,749,427 | 1,448 |
[
"libjxl",
"libjxl"
] | **Is your feature request related to a problem? Please describe.**
Yes, there's an usability issue by not being able to tell apart if a file is lossless or not without deep inspection with external tools.
This is problematic for example for file categorization, when you need to keep both a lossy and lossless version of the same image.
Sharing the same extension makes it further difficult to store them side to side, which can come handy for quality flicker tests.
**Describe the solution you'd like**
Without this QoL change I see it difficult to supersede other formats like PNG, TGA or TIF, despite their worse compression efficiency.
**Describe alternatives you've considered**
A container with a different extension (ie. *.jll, *.jlx) for losslessly compressed files.
Similarly a different one for GIF style animated JXL (ie. *.jxa, or *.jax)
**Additional context**
none
| New dummy container/extension for animated or lossless compressed files | https://api.github.com/repos/libjxl/libjxl/issues/1441/comments | 9 | 2022-05-24T14:24:05Z | 2023-07-27T12:34:26Z | https://github.com/libjxl/libjxl/issues/1441 | 1,246,639,430 | 1,441 |
[
"libjxl",
"libjxl"
] | [An extra null pointer check is not needed in a function](https://isocpp.org/wiki/faq/freestore-mgmt#delete-handles-null "Do I need to check for null before delete p?") like [the destructor for the class “QuantEncoding”](https://github.com/libjxl/libjxl/blob/f7b4c2cb35c70d81f93e04be05d8082d0ac56b58/lib/jxl/quant_weights.h#L238 "Update candidate"). | Remove an unnecessary null pointer check | https://api.github.com/repos/libjxl/libjxl/issues/1432/comments | 3 | 2022-05-20T09:55:57Z | 2022-05-23T05:55:27Z | https://github.com/libjxl/libjxl/issues/1432 | 1,242,909,393 | 1,432 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
Cjxl just crashes without errors when trying to compress any photo. Tried on two different pc's. The same crash with ffmpeg libjxl encoder. It shows return code -1073741819. Lossless compression is working.
0.6.1 version works perfectly fine.
**To Reproduce**
`cjxl 1.jpg -q 99`
**Screenshots**
**Environment**
- OS: Windows 11 Pro
- Compiler version: ?
- CPU type: x86_64
- cjxl/djxl version string: JPEG XL encoder v0.7.0 a444260 [AVX2,SSE4,SSSE3,Scalar]
**Additional context**
Build from https://artifacts.lucaversari.it/libjxl/libjxl/latest/ | Crash when trying to compress | https://api.github.com/repos/libjxl/libjxl/issues/1426/comments | 12 | 2022-05-17T19:47:54Z | 2024-03-04T10:12:45Z | https://github.com/libjxl/libjxl/issues/1426 | 1,239,086,987 | 1,426 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
When using an older version of CMake, you can get this error:
```
CMake Error at cmake/FindLCMS2.cmake:40 (add_library):
INTERFACE_LIBRARY targets may only have whitelisted properties. The
property "INCLUDE_DIRECTORIES" is not allowed.
Call Stack (most recent call first):
third_party/CMakeLists.txt:149 (find_package)
```
**To Reproduce**
- Use a CMake version before 3.19
- Build lcms2 and install it to a prefix, then attempt to build libjxl
**Expected behavior**
The CMake configure should succeed.
**Screenshots**
n/a
**Environment**
- OS: Windows
- Compiler version: clang 14.0.0 ([llvm-mingw](https://github.com/mstorsjo/llvm-mingw))
- CMake: 3.17.0
- CPU type: x86_64
- cjxl/djxl version string: n/a (commit ea6a190cd777b61662bd0470db24163a1a63bdab)
**Additional context**
Someone else also reported this to happen on Ubuntu 20.04 (CMake is 3.16.3).
This specific use of property on INTERFACE_LIBRARY seems to be allowed only starting from CMake 3.19 after commit https://gitlab.kitware.com/cmake/cmake/-/commit/afb998704e67d3d3ce5b24c112cb06e770fca78d .
<details>
<summary>Full configure output on Windows (Click to expand)</summary>
```
-- The C compiler identification is Clang 14.0.0
-- The CXX compiler identification is Clang 14.0.0
-- Check for working C compiler: C:/deps/llvm-mingw/bin/clang.exe
-- Check for working C compiler: C:/deps/llvm-mingw/bin/clang.exe - works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: C:/deps/llvm-mingw/bin/clang++.exe
-- Check for working CXX compiler: C:/deps/llvm-mingw/bin/clang++.exe - works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Performing Test JPEGXL_EMSCRIPTEN
-- Performing Test JPEGXL_EMSCRIPTEN - Failed
-- CMAKE_SYSTEM_PROCESSOR is AMD64
-- Performing Test CXX_FUZZERS_SUPPORTED
-- Performing Test CXX_FUZZERS_SUPPORTED - Failed
-- Performing Test CXX_CONSTRUCTOR_ALIASES_SUPPORTED
-- Performing Test CXX_CONSTRUCTOR_ALIASES_SUPPORTED - Success
-- Performing Test CXX_MACRO_PREFIX_MAP
-- Performing Test CXX_MACRO_PREFIX_MAP - Success
-- Performing Test CXX_NO_RTTI_SUPPORTED
-- Performing Test CXX_NO_RTTI_SUPPORTED - Success
-- Could NOT find PkgConfig (missing: PKG_CONFIG_EXECUTABLE)
-- Compiled IDs C:Clang, C++:Clang
-- Looking for pthread.h
-- Looking for pthread.h - found
-- Performing Test CMAKE_HAVE_LIBC_PTHREAD
-- Performing Test CMAKE_HAVE_LIBC_PTHREAD - Failed
-- Check if compiler accepts -pthread
-- Check if compiler accepts -pthread - yes
-- Found Threads: TRUE
-- Found HWY: C:/dev/env-9/i/lib/libhwy.a (found suitable version "0.16.0", minimum required is "0.15.0")
-- Found Brotli: C:/dev/env-9/i/include
-- Found LCMS2: C:/dev/env-9/i/lib/liblcms2.dll.a (found suitable version "2.13", minimum required is "2.10")
-- Found ZLIB: C:/dev/env-9/i/lib/libzlib.dll.a (found version "1.2.12")
-- Found PNG: C:/dev/env-9/i/lib/libpng.dll.a (found version "1.6.37")
-- Performing Test COMPILER_HAS_DEPRECATED_ATTR
-- Performing Test COMPILER_HAS_DEPRECATED_ATTR - Success
-- Performing Test LINKER_SUPPORT_EXCLUDE_LIBS
-- Performing Test LINKER_SUPPORT_EXCLUDE_LIBS - Failed
-- Could NOT find Doxygen (missing: DOXYGEN_EXECUTABLE)
CMake Warning at CMakeLists.txt:421 (message):
asciidoc was not found, the man pages will not be installed.
-- Building with JPEGXL_VERSION=0.6.1
-- Building tools:
-- Configuring done
CMake Error at cmake/FindLCMS2.cmake:40 (add_library):
INTERFACE_LIBRARY targets may only have whitelisted properties. The
property "INCLUDE_DIRECTORIES" is not allowed.
Call Stack (most recent call first):
third_party/CMakeLists.txt:149 (find_package)
CMake Error at cmake/FindLCMS2.cmake:40 (add_library):
INTERFACE_LIBRARY targets may only have whitelisted properties. The
property "INCLUDE_DIRECTORIES" is not allowed.
Call Stack (most recent call first):
third_party/CMakeLists.txt:149 (find_package)
-- Generating done
CMake Generate step failed. Build files cannot be regenerated correctly.
```
</details> | CMake <3.19 configure error with lcms2 | https://api.github.com/repos/libjxl/libjxl/issues/1425/comments | 0 | 2022-05-17T15:21:39Z | 2022-09-14T09:30:23Z | https://github.com/libjxl/libjxl/issues/1425 | 1,238,805,585 | 1,425 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
Exporting a lossy JPEG XL image crashes if the "Low resolution DC" parameter was set to "512x512 + 64x64".
**To Reproduce**
Export a blank image with the following parameters:
- JxlEncoderSetFrameLossless(frameSettings, JXL_FALSE)
- JxlEncoderFrameSettingsSetOption(frameSettings, JXL_ENC_FRAME_SETTING_PROGRESSIVE_DC, 2)
**Expected behavior**
The image gets exported successfully.
**Screenshots**
N/A
**Environment**
- OS: [e.g. Windows] Windows 10 21H2
- Compiler version: [e.g. clang 11.0.1] MSVC 2022 (19.32.31328)
- CPU type: [e.g. x86_64] x86_64
- cjxl/djxl version string: [e.g. cjxl [v0.3.7 | SIMD supported: SSE4,Scalar]] JPEG XL encoder v0.7.0 0.7.0 [AVX2,SSE4,SSSE3,Scalar]
**Additional context**
Commit: ea6a190cd777b61662bd0470db24163a1a63bdab
This is the backtrace from Krita to libjxl:
```
jxl.dll!jxl::Abort() Line 39 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\base\status.cc:39)
jxl.dll!jxl::`anonymous namespace'::FindBestQuantizationMaxError(const jxl::Image3<float> & opsin, jxl::PassesEncoderState * enc_state, const JxlCmsInterface & cms, jxl::ThreadPool * pool, jxl::AuxOut * aux_out) Line 906 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\enc_adaptive_quantization.cc:906)
jxl.dll!jxl::DefaultEncoderHeuristics::LossyFrameHeuristics(jxl::PassesEncoderState * enc_state, jxl::ModularFrameEncoder * modular_frame_encoder, const jxl::ImageBundle * original_pixels, jxl::Image3<float> * opsin, const JxlCmsInterface & cms, jxl::ThreadPool * pool, jxl::AuxOut * aux_out) Line 944 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\enc_heuristics.cc:944)
jxl.dll!jxl::LossyFrameEncoder::ComputeEncodingData(const jxl::ImageBundle * linear, jxl::Image3<float> * opsin, const JxlCmsInterface & cms, jxl::ThreadPool * pool, jxl::ModularFrameEncoder * modular_frame_encoder, jxl::BitWriter * writer, jxl::FrameHeader * frame_header) Line 517 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\enc_frame.cc:517)
jxl.dll!jxl::EncodeFrame(const jxl::CompressParams & cparams_orig, const jxl::FrameInfo & frame_info, const jxl::CodecMetadata * metadata, const jxl::ImageBundle & ib, jxl::PassesEncoderState * passes_enc_state, const JxlCmsInterface & cms, jxl::ThreadPool * pool, jxl::BitWriter * writer, jxl::AuxOut * aux_out) Line 1219 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\enc_frame.cc:1219)
jxl.dll!jxl::InitializePassesEncoder(const jxl::Image3<float> & opsin, const JxlCmsInterface & cms, jxl::ThreadPool * pool, jxl::PassesEncoderState * enc_state, jxl::ModularFrameEncoder * modular_frame_encoder, jxl::AuxOut * aux_out) Line 138 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\enc_cache.cc:138)
jxl.dll!jxl::RoundtripImage(const jxl::Image3<float> & opsin, jxl::PassesEncoderState * enc_state, const JxlCmsInterface & cms, jxl::ThreadPool * pool) Line 1064 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\enc_adaptive_quantization.cc:1064)
jxl.dll!jxl::`anonymous namespace'::FindBestQuantization(const jxl::ImageBundle & linear, const jxl::Image3<float> & opsin, jxl::PassesEncoderState * enc_state, const JxlCmsInterface & cms, jxl::ThreadPool * pool, jxl::AuxOut * aux_out) Line 792 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\enc_adaptive_quantization.cc:792)
jxl.dll!jxl::DefaultEncoderHeuristics::LossyFrameHeuristics(jxl::PassesEncoderState * enc_state, jxl::ModularFrameEncoder * modular_frame_encoder, const jxl::ImageBundle * original_pixels, jxl::Image3<float> * opsin, const JxlCmsInterface & cms, jxl::ThreadPool * pool, jxl::AuxOut * aux_out) Line 944 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\enc_heuristics.cc:944)
jxl.dll!jxl::LossyFrameEncoder::ComputeEncodingData(const jxl::ImageBundle * linear, jxl::Image3<float> * opsin, const JxlCmsInterface & cms, jxl::ThreadPool * pool, jxl::ModularFrameEncoder * modular_frame_encoder, jxl::BitWriter * writer, jxl::FrameHeader * frame_header) Line 517 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\enc_frame.cc:517)
jxl.dll!jxl::EncodeFrame(const jxl::CompressParams & cparams_orig, const jxl::FrameInfo & frame_info, const jxl::CodecMetadata * metadata, const jxl::ImageBundle & ib, jxl::PassesEncoderState * passes_enc_state, const JxlCmsInterface & cms, jxl::ThreadPool * pool, jxl::BitWriter * writer, jxl::AuxOut * aux_out) Line 1219 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\enc_frame.cc:1219)
jxl.dll!JxlEncoderStruct::RefillOutputByteQueue() Line 382 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\encode.cc:382)
jxl.dll!JxlEncoderProcessOutput(JxlEncoderStruct * enc, unsigned char * * next_out, unsigned __int64 * avail_out) Line 1341 (e:\krita-win\b_deps_msvc\ext_jpegxl\ext_jpegxl-prefix\src\ext_jpegxl\lib\jxl\encode.cc:1341)
kritajxlexport.dll!JPEGXLExport::convert(KisDocument * document, QIODevice * io, KisPinnedSharedPtr<KisPropertiesConfiguration> cfg) Line 399 (e:\krita-win\src\plugins\impex\jxl\JPEGXLExport.cpp:399)
kritaui.dll!KisImportExportManager::doExportImpl(const QString & location, QSharedPointer<KisImportExportFilter> filter, KisPinnedSharedPtr<KisPropertiesConfiguration> exportConfiguration) Line 739 (e:\krita-win\src\libs\ui\KisImportExportManager.cpp:739)
kritaui.dll!KisImportExportManager::doExport(const QString & location, QSharedPointer<KisImportExportFilter> filter, KisPinnedSharedPtr<KisPropertiesConfiguration> exportConfiguration, bool alsoAsKra) Line 709 (e:\krita-win\src\libs\ui\KisImportExportManager.cpp:709)
[Inline Frame] kritaui.dll!std::invoke(KisImportExportErrorCode(KisImportExportManager::*)(const QString &, QSharedPointer<KisImportExportFilter>, KisPinnedSharedPtr<KisPropertiesConfiguration>, bool) &) Line 1494 (c:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.32.31326\include\type_traits:1494)
[Inline Frame] kritaui.dll!std::_Invoker_ret<std::_Unforced,0>::_Call(KisImportExportErrorCode(KisImportExportManager::*)(const QString &, QSharedPointer<KisImportExportFilter>, KisPinnedSharedPtr<KisPropertiesConfiguration>, bool) &) Line 683 (c:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.32.31326\include\functional:683)
[Inline Frame] kritaui.dll!std::_Call_binder(std::_Invoker_ret<std::_Unforced,0>) Line 1961 (c:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.32.31326\include\functional:1961)
[Inline Frame] kritaui.dll!std::_Binder<std::_Unforced,KisImportExportErrorCode (__cdecl KisImportExportManager::*)(QString const &,QSharedPointer<KisImportExportFilter>,KisPinnedSharedPtr<KisPropertiesConfiguration>,bool),KisImportExportManager *,QString const &,QSharedPointer<KisImportExportFilter> &,KisPinnedSharedPtr<KisPropertiesConfiguration> &,bool &>::operator()() Line 1998 (c:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.32.31326\include\functional:1998)
```
| Exporting a lossy image with non-default Low resolution DC crashes in FindBestQuantizationMaxError | https://api.github.com/repos/libjxl/libjxl/issues/1424/comments | 4 | 2022-05-16T20:57:08Z | 2024-03-04T10:12:45Z | https://github.com/libjxl/libjxl/issues/1424 | 1,237,709,951 | 1,424 |
[
"libjxl",
"libjxl"
] | hi there,
I experience a long hang when cross compiling libjxl, where it takes about 10 minutes to finish this job:
```
[182/200] /usr/bin/armv7a-unknown-linux-gnueabihf-g++ -DJPEGXL_MAJOR_VERSION=0 -DJPEGXL_MINOR_VERSION=7 -DJPEGXL_PATCH_VERSION=0 -DJXL_INTERNAL_LIBRARY_BUILD -D__DATE__=\"redacted\" -D__TIMESTAMP__=\"redacted\" -D__TIME__=\"redacted\" -I/var/tmp/portage/portage/media-libs/libjxl-0.7.0_pre20220511/work/libjxl-libjxl-105bf1a -I/var/tmp/portage/portage/media-libs/libjxl-0.7.0_pre20220511/work/libjxl-libjxl-105bf1a/lib/include -I/var/tmp/portage/portage/media-libs/libjxl-0.7.0_pre20220511/work/libjxl-libjxl-105bf1a_build-.arm/lib/include -O2 -pipe -fomit-frame-pointer -fno-rtti -funwind-tables -fno-omit-frame-pointer -fPIC -fvisibility=hidden -fvisibility-inlines-hidden -fmacro-prefix-map=/var/tmp/portage/portage/media-libs/libjxl-0.7.0_pre20220511/work/libjxl-libjxl-105bf1a=. -Wno-builtin-macro-redefined -Wall -fmerge-all-constants -fno-builtin-fwrite -fno-builtin-fread -Wextra -Wc++11-compat -Warray-bounds -Wformat-security -Wimplicit-fallthrough -Wno-register -Wno-unused-function -Wno-unused-parameter -Wnon-virtual-dtor -Woverloaded-virtual -Wvla -fsized-deallocation -fno-exceptions -fmath-errno -std=c++11 -MD -MT lib/CMakeFiles/jxl_dec-obj.dir/jxl/convolve.cc.o -MF lib/CMakeFiles/jxl_dec-obj.dir/jxl/convolve.cc.o.d -o lib/CMakeFiles/jxl_dec-obj.dir/jxl/convolve.cc.o -c /var/tmp/portage/portage/media-libs/libjxl-0.7.0_pre20220511/work/libjxl-libjxl-105bf1a/lib/jxl/convolve.cc
```
the compile is stuck for around ten minutes, slowly increases its memory usage from some 500mb to around 900mb, and after some ten minutes somehow manages to overcome its hang.
**Expected behavior**
I expect the compile to pass through smoothly
**Environment**
- OS: linux-amd64
- Compiler version: gcc-10.3.1
- CPU type: host x86_64, target armv7a
the full build log is attached:
[libjxl-build.log.gz](https://github.com/libjxl/libjxl/files/8692352/libjxl-build.log.gz)
I don't have any experience with debugging such a hang further, any suggestions? | awfull long time is spend when compiling ../lib/jxl/convolve.cc | https://api.github.com/repos/libjxl/libjxl/issues/1422/comments | 4 | 2022-05-14T06:24:49Z | 2024-09-09T14:45:12Z | https://github.com/libjxl/libjxl/issues/1422 | 1,235,889,041 | 1,422 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
One image is decoded incrementally tile-by-tile (scanline order) in Chrome while another one is decoded in one go once all bytes are received.
**To Reproduce**
1. Download [jxl-incr.zip](https://github.com/libjxl/libjxl/files/8662348/jxl-incr.zip) and unzip
2. Run `cjxl image1.png image1.png.jxl` and `cjxl woman.png woman.png.jxl` (optional, they are in the zip too)
3. Run `python3 -m http.server`
4. Open `http://0.0.0.0:8000/image1.png.jxl` in Chrome (with Jpeg XL flag enabled)
5. Right click > Inspect > Network > Disable Cache + Throttle at 300kbs + Enable paint instrumentation
6. Reload the page
7. The image appears in one shot after 21s
8. Go to `http://0.0.0.0:8000/woman.png.jxl`
9. The image appears tile by tile as data arrives, starting at 3.5s and ending at 27s
**Expected behavior**
Both images should be decoded (or encoded?) incrementally. I do not see why this is the case for only one of the two.
**Environment**
- OS: Linux
- Chrome: 101.0.4951.54 (Official Build) (64-bit)
- Compiler version: /usr/bin/c++ (Debian 11.2.0-16+build1) 11.2.0
- CPU type: x86_64
- cjxl/djxl version string: JPEG XL encoder v0.7.0 1f849bd [AVX2,SSE4,SSSE3,Scalar]
**Additional context**
Verbose logs:
```
cjxl woman.png woman.png.jxl -v -v
JPEG XL encoder v0.7.0 1f849bd [AVX2,SSE4,SSSE3,Scalar]
Read 2048x2560 image, 9.8 MP/s
Encoding [VarDCT, d1.000, squirrel], 12 threads.
Compressed to 1011348 bytes (1.543 bpp).
2048 x 2560, 4.87 MP/s [4.87, 4.87], 1 reps, 12 threads.
Average butteraugli iters: 0.00
Total layer bits headers 0.001347% 109
Total layer bits TOC 0.018071% 1462
Total layer bits quantizer 0.000198% 16
Total layer bits quant tables 0.000025% 2
Total layer bits order 0.046340% 3749 [c/i: 4.00 | hst: 34 | ex: 97 | h+c+e: 516.819]
Total layer bits DC 8.163018% 660405
Total layer bits ControlFields 2.381942% 192704
Total layer bits AC 0.435279% 35215 [c/i: 76.00 | hst: 4375 | ex: 0 | h+c+e: 867662.668]
Total layer bits ACTokens 88.885289% 7191003
Total layer bits modularGlobal 0.055648% 4502 [c/i: 36.00 | hst: 562 | ex: 0 | h+c+e: 95155.232]
Total layer bits modularTree 0.012843% 1039 [c/i: 2.00 | hst: 33 | ex: 22 | h+c+e: 125.842]
Total image size 8090206 [c/i:118.00 | hst: 5005 | ex: 46793 | h+c+e: 1010134.187]
Allocations: 744 (max bytes in use: 2.143498E+08)
```
```
cjxl image1.png image1.png.jxl -v -v
JPEG XL encoder v0.7.0 1f849bd [AVX2,SSE4,SSSE3,Scalar]
Read 2592x1920 image, 14.7 MP/s
Encoding [VarDCT, d1.000, squirrel], 12 threads.
Compressed to 807977 bytes (1.299 bpp).
2592 x 1920, 1.35 MP/s [1.35, 1.35], 1 reps, 12 threads.
Average butteraugli iters: 0.00
Total layer bits headers 0.001826% 118
Total layer bits TOC 0.023673% 1530
Total layer bits quantizer 0.000248% 16
Total layer bits quant tables 0.000031% 2
Total layer bits order 0.053225% 3440 [c/i: 4.00 | hst: 29 | ex: 124 | h+c+e: 510.457]
Total layer bits DC 9.985088% 645355
Total layer bits ControlFields 3.719403% 240392
Total layer bits AC 0.618936% 40003 [c/i: 87.00 | hst: 4974 | ex: 0 | h+c+e: 671624.938]
Total layer bits ACTokens 85.452133% 5522932
Total layer bits modularGlobal 0.078754% 5090 [c/i: 37.00 | hst: 595 | ex: 36 | h+c+e: 95304.028]
Total layer bits modularDcGroup 0.001114% 72
Total layer bits modularAcGroup 0.049016% 3168
Total layer bits modularTree 0.016555% 1070 [c/i: 3.00 | hst: 20 | ex: 22 | h+c+e: 122.627]
Total image size 6463188 [c/i:131.00 | hst: 5619 | ex: 38445 | h+c+e: 805824.549]
Allocations: 1197 (max bytes in use: 2.720872E+08)
```
| JpegXL image not decoded incrementally tile-by-tile in Chrome | https://api.github.com/repos/libjxl/libjxl/issues/1409/comments | 4 | 2022-05-10T14:33:53Z | 2025-01-17T19:47:56Z | https://github.com/libjxl/libjxl/issues/1409 | 1,231,261,908 | 1,409 |
[
"libjxl",
"libjxl"
] | compiling latest git of libjxl for aarch64 is currently broken with:
```
In file included from /usr/aarch64-unknown-linux-gnu/tmp/portage/media-libs/libjxl-9999/work/libjxl-9999/lib/jxl/modular/transform/transform.cc:11:
/usr/aarch64-unknown-linux-gnu/tmp/portage/media-libs/libjxl-9999/work/libjxl-9999/lib/jxl/modular/transform/palette.h: In function ‘jxl::Status jxl::InvPalette(jxl::Image&, uint32_t, uint32_t, uint32_t, jxl::Predictor, const jxl::weighted::Header&, jxl::ThreadPool*)’:
/usr/aarch64-unknown-linux-gnu/tmp/portage/media-libs/libjxl-9999/work/libjxl-9999/lib/jxl/modular/transform/palette.h:124:20: error: variable ‘std::atomic<int> num_errors’ has initializer but incomplete type
124 | std::atomic<int> num_errors{0};
| ^~~~~~~~~~
```
to reproduce download latest git sources and compile libjxl for aarch64
**Environment**
- OS: Linux
- Compiler version: gcc-10.3.1
- CPU type: cross-compile from amd64 to aarch64
- cjxl/djxl version string: latest git snapshot
**Additional context**
this is cross compile, but I don't see anything cross-compile specific about the error.
the compressed build log is attached: [build.log.gz](https://github.com/libjxl/libjxl/files/8661800/build.log.gz)
| latest libjxl source code fails to compile for aarch64-linux with: ../jxl/modular/transform/palette.h:124:20: error: variable ‘std::atomic<int> num_errors’ has initializer but incomplete type | https://api.github.com/repos/libjxl/libjxl/issues/1407/comments | 6 | 2022-05-10T13:13:17Z | 2022-05-10T15:13:26Z | https://github.com/libjxl/libjxl/issues/1407 | 1,231,136,209 | 1,407 |
[
"libjxl",
"libjxl"
] | Hi there,
I'd like to implement JPEG XL encoder/decoder for iOS but I can't find any document about it.
Is there anyone success to build on iOS in xcode & decode into `UIImage` ?
Thank you! | How to build for ios? | https://api.github.com/repos/libjxl/libjxl/issues/1405/comments | 1 | 2022-05-10T10:18:56Z | 2022-12-13T10:52:07Z | https://github.com/libjxl/libjxl/issues/1405 | 1,230,935,860 | 1,405 |
[
"libjxl",
"libjxl"
] | I've noticed this during the independent reimplementation efforts. As specified, `minshift` is determined to be `downsample[n]` if there is an index `n` such that `last_pass[n]` is equal to the pass index, otherwise it's set to `maxshift`. In the current implementation though, `n` is the largest index such that `last_pass[n]` is **no less than** the pass index, or **0** if there's no such `n`.
Theoretically, and with my limited understanding of the modular mode, this can result in the following problems:
* Some modular group data will be placed in wrong passes. By itself they will decode just fine (as the decoder and encoder have the exactly same bug), but it degrades the progressive decoding performance.
* Some modular group data will be *omitted* (concrete example: `num_passes` = 2, `num_ds` = 1, `downsample[0]` = 2, `last_pass[0]` = 1). I believe the bitstream still decodes, but the decoded image would no longer match the original.
* Some modular group data will be *duplicated* (concrete example: `num_passes` = 3, `num_ds` = 2, `downsample[0..1]` = [4, 2], `last_pass[0..1]` = [1, 0]; keep in mind that the bitstream has zero guarantee about the sortedness of these arrays). I believe the bitstream still decodes, but the same channel might get painted multiple times so again the decoded image would no longer match the original.
Thankfully the current libjxl only emits five combinations of `Passes`, which greatly limit the issue's extent. The following is a summary:
| Case | A | B | C | D | E |
|---|---|---|---|---|---|
| **`--progressive_ac`** | Yes | Yes | Yes | Yes | No |
| **`--saliency_num_progressive_steps=`** | 1 | 2 | 3 | 4¹ | - |
| | | | | | |
| **`num_passes`** | 1 | 2 | 3 | 4 | 2 |
| **`downsample[0 .. num_ds-1]`** | - | 4 | 4, 2 | 4, 2 | 2 |
| **`last_pass[0 .. num_ds-1]`** | - | 0 | 0, 1 | 0, 1 | 0 |
| | | | | | |
| **`[minshift, maxshift)` (spec)** | [0,3) | [2,3), [0,2) | [2,3), [1,2), [0,1) | [2,3), [1,2), [1,1), [0,1) | [1,3), [0,1) |
| **`[minshift, maxshift)` (libjxl)²** | [0,3) | [2,3), [0,2) | **[1,3), [1,1), [0,1)** | **[1,3), [1,1), [0,1), [0,0)** | [1,3), [0,1) |
1. Also requires a non-zero `--saliency_threshold`, otherwise it's same to the case C.
2. libjxl actually uses an inclusive `maxshift`, which is converted to an exclusive bound in this table.
So the normal case is just fine; even the ordinary progressive option `-p` is actually `--qprogressive_ac` and not affected by this bug. Even in rare cases where `--progressive_ac --saliency_num_progressive_steps=3/4` are used some modular group data is just misplaced, but they will be technically an invalid bitstream under the specification.
I've written a simple [Python script](https://gist.github.com/lifthrasiir/86f15edcc5b10db27839b917c602592c) to enumerate all cases where the specification and libjxl disagrees. | `Passes::GetDownsamplingBracket` is wildly different from the ISO specification | https://api.github.com/repos/libjxl/libjxl/issues/1401/comments | 7 | 2022-05-09T21:05:19Z | 2024-03-04T10:12:44Z | https://github.com/libjxl/libjxl/issues/1401 | 1,230,250,149 | 1,401 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
As per title: `lib/jxl/libjxl.pc.in` and `lib/threads/libjxl_threads.pc.in` have
```
prefix=@INSTALLDIR@
exec_prefix=${prefix}
libdir=${exec_prefix}/@CMAKE_INSTALL_LIBDIR@
includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
```
and so can’t handle absolute paths in `CMAKE_INSTALL_{INCLUDE,LIB}DIR`. This leads to broken .pc files on NixOS in particular.
Similar to https://github.com/open-source-parsers/jsoncpp/pull/1199. See “[Concatenating paths when building pkg-config files](https://github.com/jtojnar/cmake-snips#concatenating-paths-when-building-pkg-config-files)” for a discussion of the problem and a suggested fix (I don’t know CMake myself, sorry).
**Environment**
```
$ uname -a
Linux localhost 5.15.36 #1-NixOS SMP Wed Apr 27 12:39:02 UTC 2022 x86_64 GNU/Linux
``` | pkg-config files are broken when CMAKE_INSTALL_{INCLUDE,LIB}DIR is absolute | https://api.github.com/repos/libjxl/libjxl/issues/1400/comments | 6 | 2022-05-09T05:36:21Z | 2022-05-12T14:28:37Z | https://github.com/libjxl/libjxl/issues/1400 | 1,229,201,015 | 1,400 |
[
"libjxl",
"libjxl"
] | For any gif I've tried larger than 1mb, after using cjxl to convert it to a jxl file, the speed noticeably drops. This is the case when using qView and Chromium(which is even worse). I've tried the resulting files on windows and ubuntu and there's no difference.
| GIF to JXL slows speed down | https://api.github.com/repos/libjxl/libjxl/issues/1399/comments | 8 | 2022-05-08T18:26:12Z | 2022-05-12T22:58:03Z | https://github.com/libjxl/libjxl/issues/1399 | 1,228,955,280 | 1,399 |
[
"libjxl",
"libjxl"
] |
When both patches and noise are used (e.g. a screenshot encoded with --photon_noise), the decoder does something wrong in the patch rendering: patches disappear or end up shifted a little in position.
Older decoder does it fine, so likely a regression caused by the transition to the render pipeline approach. | Regression in decoder in case of patches + noise | https://api.github.com/repos/libjxl/libjxl/issues/1397/comments | 0 | 2022-05-08T08:11:48Z | 2024-03-04T10:12:43Z | https://github.com/libjxl/libjxl/issues/1397 | 1,228,823,345 | 1,397 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
djxl from a file, that has JPEG reconstruction data with XMP in the JFIF file but no corresponding xml box in the JXL file, to JPEG crashes
**To Reproduce**
djxl out4.jxl out.jpg
with out4.jxl from [out4.jxl.zip](https://github.com/libjxl/libjxl/files/8645667/out4.jxl.zip)
**Expected behavior**
should not crash
**Environment**
- OS: Linux
- Compiler version: g++ 9.4.0
- CPU type: x86_64
- cjxl/djxl version string: JPEG XL decoder v0.7.0 2f872a1 [AVX2,SSE4,SSSE3,Scalar]
**Additional context**
```
$ valgrind ~/libjxl/build/tools/djxl out4.jxl out.jpg
==1311894== Memcheck, a memory error detector
==1311894== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==1311894== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==1311894== Command: /home/even/libjxl/build/tools/djxl out4.jxl out.jpg
==1311894==
JPEG XL decoder v0.7.0 2f872a1 [AVX2,SSE4,SSSE3,Scalar]
Read 757 compressed bytes.
==1311894== Invalid read of size 8
==1311894== at 0x128D58: jpegxl::tools::DecodeJpegXlToJpeg(jxl::DecompressParams, jpegxl::tools::JpegXlContainer const&, jxl::CodecInOut*, jxl::ThreadPool*) (box.cc:318)
==1311894== by 0x121FB9: jpegxl::tools::DecompressJxlToJPEG(jpegxl::tools::JpegXlContainer const&, jpegxl::tools::DecompressArgs const&, jxl::ThreadPool*, jxl::PaddedBytes*, jpegxl::tools::SpeedStats*) (djxl.cc:209)
==1311894== by 0x11D111: jpegxl::tools::(anonymous namespace)::DecompressMain(int, char const**) (djxl_main.cc:116)
==1311894== by 0x4FFD0B2: (below main) (libc-start.c:308)
==1311894== Address 0x8 is not stack'd, malloc'd or (recently) free'd
```
| Crash in djxl from a file with JPEG reconstruction data with XMP in the JFIF file but no xml JXL box | https://api.github.com/repos/libjxl/libjxl/issues/1396/comments | 7 | 2022-05-07T17:25:29Z | 2022-08-15T07:54:25Z | https://github.com/libjxl/libjxl/issues/1396 | 1,228,679,453 | 1,396 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
b90ba633a7ac419f24115e4f623ac400d89d0e23 added JXL_DEPRECATED to types:
https://github.com/libjxl/libjxl/blob/192ddd90fdf0c69cd1db1c8d7850db036dd87f4b/lib/include/jxl/types.h#L58-L64
This works since `JXL_DEPRECATED` is currently `__attribute__ ((__deprecated__))`, but the standard `[[deprecated]]` cannot be in this position. Perhaps it should be:
```cpp
JXL_DEPRECATED static const int JXL_TYPE_BOOLEAN = 1;
```
**To Reproduce**
Steps to reproduce the behavior: Try replacing it to `[[deprecated]]` and build.
**Expected behavior**
It should build with `[[deprecated]]`
**Environment**
- OS: Windows
- Compiler version: Clang 14.0.1
- CPU type: x86_64
- cjxl/djxl version string: 192ddd90fdf0c69cd1db1c8d7850db036dd87f4b
**Additional context**
```
0:13.02 C:/Users/sasch/Documents/GitHub/gecko-dev/media/libjxl/include\jxl/jxl_export.h(11,26): note: expanded from macro 'JXL_DEPRECATED'
0:13.03 #define JXL_DEPRECATED [[deprecated]]
```
I found this because Gecko does not use cmake and we had to add our own definition of JXL_DEPRECATED.
| JXL_DEPRECATED is added to wrong positions | https://api.github.com/repos/libjxl/libjxl/issues/1388/comments | 0 | 2022-05-03T14:06:23Z | 2024-03-04T10:12:42Z | https://github.com/libjxl/libjxl/issues/1388 | 1,224,154,229 | 1,388 |
[
"libjxl",
"libjxl"
] | From what I understand from the documentation, level 5 is supposed to support up to 16 bits per channel. However with current main branch the encoder will now fail with `./lib/jxl/encode.cc:645: Codestream level verification for level 5 failed: Too high modular bit depth` when encoding a 16bit uint channel. From the code, it seems that the check will fail if the bit depth is higher than 12, not 16 (https://github.com/libjxl/libjxl/blob/d382e5d5abd655f78b910f72c3be6e8f2465e087/lib/jxl/encode.cc#L580) | codestream level 5/10 bit-per-channel clarification | https://api.github.com/repos/libjxl/libjxl/issues/1386/comments | 5 | 2022-04-29T10:12:33Z | 2025-01-17T19:22:27Z | https://github.com/libjxl/libjxl/issues/1386 | 1,220,431,591 | 1,386 |
[
"libjxl",
"libjxl"
] | ```
build/tools/cjxl -v pq-wedge.pfm pq.jxl -x color_space=RGB_D65_202_Rel_PeQ
JPEG XL encoder v0.7.0 638ca59 [AVX2,SSE4,SSSE3,Scalar]
Read 1024x512 image, 31.9 MP/s
Encoding [VarDCT, d1.000, squirrel], 8 threads.
./lib/jxl/enc_patch_dictionary.cc:780: JXL_CHECK: DecodeFrame({}, &dec_state, pool, &br, &decoded, *state->shared.metadata, nullptr)
Illegal instruction (core dumped)
```
This occurs on both Ubuntu Linux 20.04.4 LTS and MacOS 10.15.7. (same line number on both systems).
On Linux, it occurs when libjxl is built with clang (Clang 10.0.0) and with gcc/g++ (GNU 9.4.0).
It occurs (identically) whether the color_space flag is used or omitted.
It does not appear to be critically dependent on the dimensions of the image, although I've only tried dimensions around 1000 x 500.
It is not triggered because the image is a pure grey scale (setting the green channel to all zeros changes nothing).
It *does* depend on the "effort" setting. It works with -e 9 and -e 1 but not with the default (-e 7).
I've attached a zip of the PFM in question.
Hope this is helpful.
[pq-wedge.pfm.gz](https://github.com/libjxl/libjxl/files/8552363/pq-wedge.pfm.gz)
| cjxl crashes with illegal instruction when processing a greyscale wedge image in PFM format. | https://api.github.com/repos/libjxl/libjxl/issues/1380/comments | 5 | 2022-04-25T07:10:57Z | 2022-04-27T03:49:51Z | https://github.com/libjxl/libjxl/issues/1380 | 1,214,069,366 | 1,380 |
[
"libjxl",
"libjxl"
] | Hi,
Not a feature request, just a question.
We all know it. File browsers.
They, depending on which file browser you use, likely present your images in thumbnails where you get the full version once you click it.
When looking at the JPEG XL features there are a couple features that could be very interesting for the thumbnail part of file browsers.
1. thumbnail support
2. progressive loading
What i'm wondering about is if progressive loading could be (ab)used as a thumbnail too?
Say you have a 2000x2000 resolution source image and a thumbnail of 200x200.
At some point in the thumbnail process the source image gets resized to 200x200. The mere act of resizing is already lozing image detail. My thinking is that, for example, loading just a couple percent of the main image file would result in enough thumbnail quality that you'd otherwise get if you'd do: source image -> resize to 200x200 -> render.
This approach, if it works, has some potential cool advantages that i can think of:
1. No need for a separate thumbnail
2. Thumbnail sizes can be totally dynamic too. A bigger thumbnail is just means progressively loading more data from the source image
Note that i am aware that this idea doesn't give you a thumbnail in a hypothetical 200x200 resolution. It would give you the thumbnail "data" in a 2000x2000 image which the one using this trick still has to downscale to 200x200. This part alone probably makes it slightly computational expensive then having a "native" 200x200 thumbnail.
So what do you folks think of this? Is this technically possible? Does the API even allow progressive loading and just stopping after x percentage is loaded? | Can progressive loading be used as a thumbnail? | https://api.github.com/repos/libjxl/libjxl/issues/1379/comments | 1 | 2022-04-24T21:55:40Z | 2022-07-20T13:08:35Z | https://github.com/libjxl/libjxl/issues/1379 | 1,213,779,756 | 1,379 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
I want to convert a png file to jxl. Without any feedback the file will be not converted.
**To Reproduce**
Picture was shot with an Nikon Z7 in RAW, converted with Lightroom to PNG 16-Bit, processed with "Sharpen AI".
`cjxl.exe "F:\Workspace\sample.PNG" "F:\Workspace\sample.PNG.jxl" --num_threads 8 -v -v`
**Expected behavior**
I expect that the file sample.PNG.jxl was written and that the a got verbose output.
**Screenshots**
**Environment**
- OS: Microsoft Windows 11 Pro 21H2
- CPU type: x86_64
- cjxl/djxl version string: cjxl v0.6.1 a205468 [SSE4,Scalar]
**Additional context**
```
PS F:\Workspace> magick identify .\sample.PNG
.\sample.PNG PNG 7593x5062 7593x5062+0+0 16-bit sRGB 198.656MiB 0.000u 0:00.001
```
Untouched sample file:
- https://mega.nz/file/mKhkDIaD#a4v_D62NGNbl7cDaKvvK4Vy4TYbCl-9W9TLfi-tJg4Y
- https://gateway.pinata.cloud/ipfs/QmYSCDPxYs9CbA81NUmUDZtAbUxfZEFUEyFGw9WdqitTpf
- https://cloudflare-ipfs.com/ipfs/QmYSCDPxYs9CbA81NUmUDZtAbUxfZEFUEyFGw9WdqitTpf
| PNG 16-bit sRGB cannot converted, verbose output is missing | https://api.github.com/repos/libjxl/libjxl/issues/1378/comments | 13 | 2022-04-24T11:57:11Z | 2025-01-23T22:48:31Z | https://github.com/libjxl/libjxl/issues/1378 | 1,213,633,658 | 1,378 |
[
"libjxl",
"libjxl"
] | **Is your feature request related to a problem? Please describe.**
JPEG XL allows us to include Catmull–Rom splines, vector curves which are similar to SVG paths. There is even a tool to convert [svg2jxl](https://github.com/wwww-wwww/spline) and it produces much smaller JXL image than the corresponding SVG or PNG. However, the splines in JXL images look blurry, especially thicker ones and when the image is zoomed in, even though they are vectors. Could you please improve rendering them?
**Describe the solution you'd like**
Splines could be more sharp, less blurry, especially thicker ones.
**Describe alternatives you've considered**
An obvious alternative is SVG, but JXL could become a much smaller replacement for SVG if it was better rendered.
**Additional context**
Compare files: [cubic.svg (3.9KB)](https://user-images.githubusercontent.com/384997/164676403-01f76b98-4b52-4112-9cc7-2978f713210d.svg),
[cubic.jxl.zip (1.15KB)](https://github.com/libjxl/libjxl/files/8539459/cubic.jxl.zip)
| Better rendering of splines | https://api.github.com/repos/libjxl/libjxl/issues/1370/comments | 4 | 2022-04-22T09:21:04Z | 2022-05-14T13:48:28Z | https://github.com/libjxl/libjxl/issues/1370 | 1,212,067,025 | 1,370 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
Bug of encoding from any image file to jxl in cjxl for default command (7)
**To Reproduce**
Steps to reproduce the behavior:
1: Used code default in Windows Terminal Command Prompt: cjxl fefefe.png fefefe.jxl
2: Nothing compressed.
**Expected behavior**
Expected needs to be compressed and saved file after default command and effort number seven.
**Code:**
```
cjxl fefefe.png fefefe.jxl
JPEG XL encoder v0.7.0 75a039a [AVX2,SSE4,SSSE3,Scalar]
Read 1353x852 image, 48.0 MP/s
Encoding [VarDCT, d1.000, squirrel], 16 threads.
```
**Environment**
- OS: Windows 11
- Compiler version: VCPKG 2022
- CPU type: x86_64
- JPEG XL encoder v0.7.0 75a039a [AVX2,SSE4,SSSE3,Scalar]
**Additional context**
The problem is that the default effort does not work. From effort 1 to 4 are working well. Since effort 5, it won't work well.
- Martin Eesmaa
| Default command (effort 7) does not work in cjxl | https://api.github.com/repos/libjxl/libjxl/issues/1356/comments | 2 | 2022-04-19T06:12:56Z | 2022-04-19T06:37:44Z | https://github.com/libjxl/libjxl/issues/1356 | 1,207,795,160 | 1,356 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
When converting image to visually lossless in modular mode, cmd output says lossless encoding, and image size is same as loslessy encoded.
E:\Pobrane\jxl-x64-windows-static>cjxl -d 1 -m "E:\Pictures\ActKey\ScanToApplication1\Czas_przestrzen_kwanty\skan1.png" E:\Pictures\ActKey\ScanToApplication1\Czas_przestrzen_kwanty\jpeg_xl\skan1.jxl
JPEG XL encoder v0.6.1 a205468 [AVX2,SSE4,Scalar]
Read 2624x4479 image, 52.8 MP/s
Encoding [Modular, lossless, squirrel], 4 threads.
Compressed to 3760029 bytes (2.559 bpp).
2624 x 4479, 1.02 MP/s [1.02, 1.02], 1 reps, 4 threads.
E:\Pobrane\jxl-x64-windows-static>cjxl -d 0 -m "E:\Pictures\ActKey\ScanToApplication1\Czas_przestrzen_kwanty\skan1.png" E:\Pictures\ActKey\ScanToApplication1\Czas_przestrzen_kwanty\jpeg_xl\skan1_d0.jxl
JPEG XL encoder v0.6.1 a205468 [AVX2,SSE4,Scalar]
Read 2624x4479 image, 52.7 MP/s
Encoding [Modular, lossless, squirrel], 4 threads.
Compressed to 3760029 bytes (2.559 bpp).
2624 x 4479, 1.03 MP/s [1.03, 1.03], 1 reps, 4 threads.
However, cjxl -m -q 95 produces lossy image as expected.
**To Reproduce**
Steps to reproduce the behavior:
cjxl -m -d 1 [input] [output]
**Expected behavior**
-d 1 -m should encode to lossy and show this in CLI
**Environment**
- OS: Windows 10 x64
- Compiler version: precompiled binary
- CPU type: x86_64 | cjxl -m -d 1 converts to lossless instead of lossy | https://api.github.com/repos/libjxl/libjxl/issues/1355/comments | 1 | 2022-04-17T12:04:45Z | 2022-04-17T12:18:27Z | https://github.com/libjxl/libjxl/issues/1355 | 1,206,357,648 | 1,355 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
```JxlDecoderFlushImage()``` always returns ```JXL_DEC_ERROR``` when using an image-out callback.
The first line of the function is:
```
if (!dec->image_out_buffer) return JXL_DEC_ERROR;
```
So it only works with an image-out buffer.
**To Reproduce**
Setup a callback with ```JxlDecoderSetImageOutCallback()```, then use ```JxlDecoderFlushImage()``` after loading some data.
**Expected behaviour**
The image data should be flushed using the callback function. The documentation for ```JxlDecoderSetImageOutCallback()``` has a paragraph starting with "If JxlDecoderFlushImage is used,...". So it seems this was the intention at some point. | JxlDecoderFlushImage() does not work with an image-out callback | https://api.github.com/repos/libjxl/libjxl/issues/1354/comments | 0 | 2022-04-17T08:59:51Z | 2024-03-04T10:12:41Z | https://github.com/libjxl/libjxl/issues/1354 | 1,206,321,357 | 1,354 |
[
"libjxl",
"libjxl"
] | Back in December, JxlDecoderSetProgressiveDetail() was added to decode.h (4ca53d55b075846124f9783461c01ffbffb431f8).
But there is still no implementation of this function anywhere.
Has this been forgotten about in someone's private repository? | No implementation of JxlDecoderSetProgressiveDetail(), defined in decode.h | https://api.github.com/repos/libjxl/libjxl/issues/1353/comments | 0 | 2022-04-16T20:05:04Z | 2024-03-04T10:12:41Z | https://github.com/libjxl/libjxl/issues/1353 | 1,206,205,339 | 1,353 |
[
"libjxl",
"libjxl"
] | Hi. When converting 8-bit grayscale images to jpeg xl output is 32-bit. How to make 8-bit grayscale jxl? | How to convert 8-bit grayscale png to same jxl? | https://api.github.com/repos/libjxl/libjxl/issues/1342/comments | 10 | 2022-04-13T08:05:19Z | 2022-04-15T16:02:12Z | https://github.com/libjxl/libjxl/issues/1342 | 1,202,909,357 | 1,342 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
After building with clang on a 32-bit system, all tests succeed. But after building with gcc, the following tests fail:
- CodecPGXTest.Test16bits
- StatsTest.CompareCentralMomentsAgainstTwoPass
- FastMathTargetTestGroup/FastMathTargetTest.TestFastPow2/SSE4#GetParam()=64
- FastMathTargetTestGroup/FastMathTargetTest.TestFastPQDFE/SSE4#GetParam()=64
- FastMathTargetTestGroup/FastMathTargetTest.TestFastPQDFE/SSSE3#GetParam()=128
- RobustStatisticsTest.CleanLine
**Environment**
- OS: Void Linux
- Compiler version: clang 12.0.1, gcc 10.2.1
- CPU type: x86
- cjxl/djxl version string: JPEG XL encoder v0.6.1 [SSE4,SSSE3,Scalar] | Tests fail after building with 32-bit gcc | https://api.github.com/repos/libjxl/libjxl/issues/1340/comments | 6 | 2022-04-12T15:06:54Z | 2024-09-16T05:51:38Z | https://github.com/libjxl/libjxl/issues/1340 | 1,201,990,032 | 1,340 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
There is something odd going on with non-multiple of 8 and pgm input. I cannot reproduce it using PNG. It appears as if `-d 0` is not lossless in those cases.
**To Reproduce**
```
% convert -depth 7 -size 512x512 xc:gray gray.7.pgm
% cjxl -d 0 gray.7.pgm gray.7.pgm.jxl
% djxl gray.7.pgm.jxl gray.7.pgm.jxl.pgm
% compare -metric pae gray.7.pgm gray.7.pgm.jxl.pgm null:
31478 (0.480323)
```
**Expected behavior**
```
% compare -metric pae gray.7.pgm gray.7.pgm.jxl.pgm null:
0(0)
```
**Screenshots**
none
**Environment**
- OS: Linux
- Compiler version: gcc-10
- CPU type: x86_64
- cjxl/djxl version string: JPEG XL encoder v0.7.0 e43c719 [AVX2,SSE4,SSSE3,Scalar]
| PGM and non-multiple of 8 | https://api.github.com/repos/libjxl/libjxl/issues/1335/comments | 1 | 2022-04-11T15:41:54Z | 2022-04-12T10:20:24Z | https://github.com/libjxl/libjxl/issues/1335 | 1,200,160,113 | 1,335 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
It seems like built'in decoder can't compress some type of large files
**To Reproduce**
```# cjxl sample.png compressed.jxl```
_gives:_
```JPEG XL encoder v0.7.0 [SSE4]
./lib/extras/dec/apng.cc:298: APNG chunk size is too big
./lib/extras/dec/color_hints.cc:56: No color_space/icc_pathname given, assuming sRGB
./lib/extras/dec/decode.cc:127: JXL_FAILURE: Codecs failed to decode
./lib/extras/codec.cc:49: JXL_FAILURE: Codecs failed to decode
Failed to read image comment_1620718615PMoN9rgOE6Az4AXDSibg8e.png.
```
**Expected behavior**
It should be compressed as usual.
**Environment**
- OS: Gentoo Linux
- Compiler version: gcc 11.2.0
- CPU type: x86_64
- cjxl/djxl version string: JPEG XL encoder v0.7.0 [SSE4] / version 0.7.0_pre20220329
**Additional context**
Sample image too big to attach it directly, I'll upload it to Yandex Disk (can contain NSFW parts):
https://disk.yandex.ru/d/Aj7gv1NKTWvTYw
```sample_cjxl_bug.png: PNG image data, 10032 x 14164, 8-bit/color RGB, non-interlaced```
Please say if you got downloading issues. | cjpeg: "APNG chunk size is too big" when trying to compress very large (142.1Mpix) png image | https://api.github.com/repos/libjxl/libjxl/issues/1330/comments | 4 | 2022-04-10T08:51:18Z | 2024-03-04T10:12:40Z | https://github.com/libjxl/libjxl/issues/1330 | 1,198,945,350 | 1,330 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
I'd like to achieve good compression ratio using `-e 9` using cjxl command line tool with pfm (rgb) input.
Here is the entropy plot (-d 0 -e 9):
Compared to a zstd (no option) :
or gzip (no option):
**To Reproduce**
```
% wget https://telparia.com/fileFormatSamples/image/pfm/sample_1920×1280.pfm
% sha1sum sample_1920×1280.pfm
bd579ee0144d6d3dd4495de3cb95d2283fd6c0e0 sample_1920×1280.pfm
% time cjxl -d 0 -e 9 sample_1920×1280.pfm sample_1920×1280.pfm.9.jxl
JPEG XL encoder v0.7.0 e3a3558 [AVX2,SSE4,SSSE3,Scalar]
./lib/extras/dec/color_hints.cc:56: No color_space/icc_pathname given, assuming sRGB
Read 1920x1280 image, 107.4 MP/s
Encoding [Modular, lossless, tortoise], 8 threads.
Compressed to 13425615 bytes (43.703 bpp).
1920 x 1280, 0.01 MP/s [0.01, 0.01], 1 reps, 8 threads.
cjxl -d 0 -e 9 sample_1920×1280.pfm sample_1920×1280.pfm.9.jxl 197.76s user 0.20s system 102% cpu 3:12.67 total
```
For comparison:
```
% time zstd -o sample_1920×1280.pfm.zstd sample_1920×1280.pfm
sample_1920×1280.pfm : 30.04% (29491217 => 8858010 bytes, sample_1920×1280.pfm.zstd)
zstd -o sample_1920×1280.pfm.zstd sample_1920×1280.pfm 0.19s user 0.02s system 106% cpu 0.198 total
```
```
% time gzip -c sample_1920×1280.pfm > sample_1920×1280.pfm.gz
gzip -c sample_1920×1280.pfm > sample_1920×1280.pfm.gz 1.91s user 0.01s system 99% cpu 1.920 total
```
**Expected behavior**
I'd like to have a flat entropy histogram on pfm inputs (32bits float). Here is a typical plot for uint16 (grayscale pgm original input):
**Screenshots**
See above
**Environment**
- OS: Linux
- Compiler version: gcc-10
- CPU type: x86_64
- cjxl/djxl version string: JPEG XL encoder v0.7.0 e3a3558 [AVX2,SSE4,SSSE3,Scalar]
**Additional context**
To generate plot I used:
```
% binwalk -EJ <input file>
``` | Poor compression ratio for 32bits float | https://api.github.com/repos/libjxl/libjxl/issues/1323/comments | 6 | 2022-04-07T06:59:24Z | 2022-05-11T12:34:52Z | https://github.com/libjxl/libjxl/issues/1323 | 1,195,602,842 | 1,323 |
[
"libjxl",
"libjxl"
] | **Is your feature request related to a problem? Please describe.**
Right now palette are internal encoding tool in jxl.
**Describe the solution you'd like**
I'd like to have palette part of the externally exposed image metadata.
**Describe alternatives you've considered**
Re-encode PNG24 into PNG8 using third party tool.
Use case is mostly archiving (lossless only in my case).
Use case:
1. I would like to be able to do a round-trip PNG8 -> JPEG-XL -> PNG8.
2. Assuming palette (<= 256 entries) is internally encoded in JPEG-XL, I should be able to decide wether or not to decode to PNG8 or PNG24. | Make palette externally exposed image metadata | https://api.github.com/repos/libjxl/libjxl/issues/1313/comments | 1 | 2022-04-01T15:40:17Z | 2022-04-08T10:16:48Z | https://github.com/libjxl/libjxl/issues/1313 | 1,189,974,716 | 1,313 |
[
"libjxl",
"libjxl"
] | **Describe the solution you'd like**
Add localization of man pages to help users.
| Localization for the man pages | https://api.github.com/repos/libjxl/libjxl/issues/1306/comments | 0 | 2022-03-30T13:07:42Z | 2022-03-30T13:07:54Z | https://github.com/libjxl/libjxl/issues/1306 | 1,186,435,679 | 1,306 |
[
"libjxl",
"libjxl"
] | This will uncover few more warnings / give an early heads-up on problems of our customers. | Try to add MSVC compilation to matrix | https://api.github.com/repos/libjxl/libjxl/issues/1300/comments | 0 | 2022-03-29T11:30:25Z | 2024-03-04T10:19:38Z | https://github.com/libjxl/libjxl/issues/1300 | 1,184,720,374 | 1,300 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
I'd like to use JPEG-XL to compress unsigned int (32bits). I tried using PGX inputs but it fails.
**To Reproduce**
```
% convert -depth 32 -size 512x512 xc:black black32.pgx
% ./tools/cjxl --num_threads=0 -d 0 black32.pgx black32.jxl
JPEG XL encoder v0.7.0 ff032c3 [AVX2,SSE4,SSSE3,Scalar]
./lib/extras/dec/pgx.cc:122: JXL_FAILURE: PGX: >16 bits not yet supported
./lib/extras/dec/exr.cc:93: JXL_FAILURE: OpenEXR failed to parse input
./lib/extras/dec/decode.cc:127: JXL_FAILURE: Codecs failed to decode
./lib/extras/codec.cc:49: JXL_FAILURE: Codecs failed to decode
Failed to read image black32.pgx.
```
Applying the following patch:
```
% git diff lib/extras/dec/pgx.cc
diff --git a/lib/extras/dec/pgx.cc b/lib/extras/dec/pgx.cc
index 7b79eaf..e319a36 100644
--- a/lib/extras/dec/pgx.cc
+++ b/lib/extras/dec/pgx.cc
@@ -117,9 +117,11 @@ class Parser {
// 0xa, or 0xd 0xa.
JXL_RETURN_IF_ERROR(SkipLineBreak());
+#if 0
if (header->bits_per_sample > 16) {
return JXL_FAILURE("PGX: >16 bits not yet supported");
}
+#endif
// TODO(lode): support signed integers. This may require changing the way
// external_image works.
if (header->is_signed) {
```
lead to:
```
JPEG XL encoder v0.7.0 ff032c3 [AVX2,SSE4,SSSE3,Scalar]
./lib/extras/dec/color_hints.cc:56: No color_space/icc_pathname given, assuming sRGB
Read 512x512 image, 107.9 MP/s
Encoding [Modular, lossless, squirrel], 0 threads.
./lib/jxl/image_metadata.cc:56: JXL_FAILURE: Invalid bits_per_sample: 32
./lib/jxl/fields.cc:595: JXL_ABORT: AllDefault should never fail
zsh: illegal hardware instruction ./tools/cjxl --num_threads=0 -d 0 black32.pgx black32.jxl
```
with:
```
(gdb) bt
#0 jxl::Abort () at libjxl/lib/jxl/base/status.cc:42
#1 0x00005555563fb7bc in jxl::Bundle::AllDefault (fields=...) at libjxl/lib/jxl/fields.cc:595
#2 0x00005555563faed8 in jxl::(anonymous namespace)::CanEncodeVisitor::AllDefault(const jxl::Fields &, bool * __restrict__) (this=0x7fffffffa270, fields=..., all_default=0x5555578f2008)
at libjxl/lib/jxl/fields.cc:469
```
**Expected behavior**
```
% convert -depth 32 -size 512x512 xc:black black32.pgx
% cjxl -d 0 black32.pgx black32.jxl && echo success
success
```
**Screenshots**
none
**Environment**
- OS: Linux
- Compiler version: gcc-10
- CPU type: x86_64
- cjxl/djxl version string: JPEG XL encoder v0.7.0 ff032c3 [AVX2,SSE4,SSSE3,Scalar]
**Additional context**
For some reason I can compress 31bits unsigned int PGX. I fail to understand the symptoms of `CanEncodeVisitor::AllDefault` failure.
| 32 bits: pgx.cc:122: JXL_FAILURE: PGX: >16 bits not yet supported | https://api.github.com/repos/libjxl/libjxl/issues/1295/comments | 1 | 2022-03-29T08:05:48Z | 2022-04-08T10:17:45Z | https://github.com/libjxl/libjxl/issues/1295 | 1,184,474,067 | 1,295 |
[
"libjxl",
"libjxl"
] | Hi
I am working on fast decompression on web client side, with high rate of compression for huge data and seamless.
so, for the performance side, I tried to splite the original data into several segments and compress them individually.
but, in this case, I faced the seam between separated data when I decompress the compressed data again.
I think I can get the seamless compression if I compress the whole data without split them.
(my huge data has dimension of `32768x32768`)
But, after I get the whole compressed data, then the decompression time is very long.
for decompression, I think I can reduce the decompression time if I split the compressed data.
Does exist the way that compress the whole data, but decompress it with split? | Does exist the way that compress the whole data, but decompress it with split? | https://api.github.com/repos/libjxl/libjxl/issues/1294/comments | 3 | 2022-03-29T07:56:21Z | 2022-04-01T06:04:27Z | https://github.com/libjxl/libjxl/issues/1294 | 1,184,463,599 | 1,294 |
[
"libjxl",
"libjxl"
] | **Is your feature request related to a problem? Please describe.**
When libjpeg v6 was released (Aug 1995) it cames with a low level tool: `jpegtran`. this is a tool to provide lossless editing mode to existing JPEG files.
Currently supported operations are:
```
Switches for modifying the image:
-crop WxH+X+Y Crop to a rectangular region
-drop +X+Y filename Drop (insert) another image
-flip [horizontal|vertical] Mirror image (left-right or top-bottom)
-grayscale Reduce to grayscale (omit color data)
-perfect Fail if there is non-transformable edge blocks
-rotate [90|180|270] Rotate image (degrees clockwise)
-transpose Transpose image
-transverse Transverse transpose image
-trim Drop non-transformable edge blocks
with -drop: Requantize drop file to match source file
-wipe WxH+X+Y Wipe (gray out) a rectangular region
```
**Describe the solution you'd like**
It would make sense to provide an equivalent tool (eg. `jxltran`) at least to edit JPEG-XL files containing JPEG bitstream.
**Describe alternatives you've considered**
```
% djxl input.jxl output.tmp.jpg
% jpegtran -outfile output.jpg -rotate 90 output.tmp.jpg
% cjxl output.tmp.jpg output.jxl
```
| Provide a jxltran command line tool | https://api.github.com/repos/libjxl/libjxl/issues/1291/comments | 2 | 2022-03-28T13:03:20Z | 2022-03-28T14:16:57Z | https://github.com/libjxl/libjxl/issues/1291 | 1,183,409,117 | 1,291 |
[
"libjxl",
"libjxl"
] | **Is your feature request related to a problem? Please describe.**
CJXL is a great encoder when it comes to high compression high fidelity image coding.
However, it can have some problems when it comes to low luminance detail retention.
So while an image can look excellent when encoded at say `-e 8 -d 1`, darker spots might have some problems regarding detail retention, particularly when photographic noise/dithering are at play.
**Describe the solution you'd like**
On the CLI interface side, an `aq-mode` toggle could be added with 2 modes: 1 being the default aq-mode behavior, and 2 being the luma adjusted aq-mode.
On the code side, a LumaModulation function could be added to lib/jxl/enc_adaptive_quantization.cc, featuring a curve on how much to vary the quantizer per block, working in either 4x4/8x8 blocks to prevent noise from causing issues.
As for how it would work, it's simple:
- Mid-high luminance = no offset.
- Low-mid luminance = small negative offset to the general quantizer of the block.
- Low luminance = larger negative quantizer offset.
- Very low-low luminance = even larger negative quantizer offset
- Very low luminance = same quantizer offset, but only applied to the luminance value, as chroma<-> luma correlation breaks down at very low brightness according to the HVS in lighting.
**Additional context**
This behavior might be related to how metric/encoder quality evaluation is usually done in the development phase.
Development is done on high end professional monitors(mostly IPS) with lots of environmental lighting(like in an office setting), which affects the viewing experience quite a bit. This can therefore bias the viewer on how to tune the encoder/metric evaluation per the quality target, as dark detail retention can't be as easily noticed like in other settings described below.
As you increase screen contrast(VA, self-emissive) and decrease environmental lighting, you increase the perceived contrast from the screen, increasing dynamic range, and making it easier to see flaws in darker areas.
For now, I do not think it is necessary for any of the team members to actually work on this feature request.
I'll work on adding the function and if everything works as expected, I'll open a PR for it to get reviewed.
If not, I'll ask for help :)
| [Feature request] Luma adjusted quantizer offset for adaptive quantization | https://api.github.com/repos/libjxl/libjxl/issues/1285/comments | 1 | 2022-03-26T16:49:55Z | 2025-01-13T03:14:47Z | https://github.com/libjxl/libjxl/issues/1285 | 1,181,898,578 | 1,285 |
[
"libjxl",
"libjxl"
] | Hello,
On Gentoo Linux on riscv64 architecture, we have problems to build libjxl.a
```
/usr/lib/gcc/riscv64-unknown-linux-gnu/11.2.1/../../../../riscv64-unknown-linux-gnu/bin/ld: lib/libjxl.a(dec_group_border.cc.o): in function `.L0 ':
dec_group_border.cc:(.text+0x158): undefined reference to `__atomic_fetch_and_1'
```
Complete build log:
[build.log.txt](https://github.com/libjxl/libjxl/files/8355338/build.log.txt)
| build problem on riscv64: undefined reference to `__atomic_fetch_or_1 | https://api.github.com/repos/libjxl/libjxl/issues/1283/comments | 2 | 2022-03-26T12:11:50Z | 2022-03-28T14:11:34Z | https://github.com/libjxl/libjxl/issues/1283 | 1,181,712,151 | 1,283 |
[
"libjxl",
"libjxl"
] | This is just with VarDCT mode, effort 1-4 produces a file, but with 5 and above and cjxl just silently exits. This is happening with this [jxl-x64-windows-static](https://github.com/libjxl/libjxl/suites/5806493331/artifacts/194198286) build from Github Actions
The source picture I'm using is [here](https://jpegxl.info/comparison.png), but this happens with any PNG input I've tried (Or JPEG when passing the `-j` option)
```
PS > .\cjxl.exe .\comparison.png .\comparison.jxl -e 1|2|3|4
JPEG XL encoder v0.7.0 7594374 [AVX2,SSE4,SSSE3,Scalar]
libpng warning: iCCP: known incorrect sRGB profile
Read 2560x2850 image, 135.3 MP/s
Encoding [Container | VarDCT, d1.000, cheetah | 875-byte XMP], 12 threads.
Compressed to 476609 bytes (0.523 bpp).
2560 x 2850, 74.79 MP/s [74.79, 74.79], 1 reps, 12 threads.
Including container: 477532 bytes (0.524 bpp).
PS >
```
While higher levels output this (And don't create an output file)
```
PS > .\cjxl.exe .\comparison.png .\comparison.jxl -e 5|6|7|8|9
JPEG XL encoder v0.7.0 7594374 [AVX2,SSE4,SSSE3,Scalar]
libpng warning: iCCP: known incorrect sRGB profile
Read 2560x2850 image, 133.5 MP/s
Encoding [Container | VarDCT, d1.000, hare | 875-byte XMP], 12 threads.
PS >
```
`--verbose` only prints extra output at effort 4 and below, above that and the output is the same as the non-verbose runs.
**Environment**
- OS: Windows 11
- Compiler version: Whatever GitHub CI uses
- CPU type: x86_64 AMD Ryzen 5 3600X 6-Core Processor, 3793 Mhz, 6 Core(s), 12 Logical Processor(s)
- cjxl/djxl version string: JPEG XL encoder v0.7.0 7594374 [AVX2,SSE4,SSSE3,Scalar] | cjxl effort >= 5 produces no output file | https://api.github.com/repos/libjxl/libjxl/issues/1282/comments | 12 | 2022-03-26T08:35:09Z | 2024-03-04T10:12:38Z | https://github.com/libjxl/libjxl/issues/1282 | 1,181,593,554 | 1,282 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
I'd like to use libjxl to compress without loss 16 bits / sRGB PPM inputs. I did check the bug tracker all I could find is:
* https://github.com/libjxl/libjxl/issues/692
which seems related but slightly different.
**To Reproduce**
```
% for c in white black red green blue; do convert -size 512x512 -depth 16 xc:$c $c.ppm; cjxl $c.ppm $c.jxl; djxl $c.jxl $c.jxl.ppm; done
% md5sum *.ppm
2b677152c85951ffa01d492ad091e404 black.jxl.ppm
2b677152c85951ffa01d492ad091e404 black.ppm
2daaadde9f19360b56b40b6537b67cb2 blue.jxl.ppm
cb541dd4b1ad5b2afefd73e903d564dc blue.ppm
c33316e841523aaf6e2b29fd918064cd green.jxl.ppm
e7a85c6831a581574de47d902ff69523 green.ppm
89b3501df8978c52ee0d963ec8043b25 red.jxl.ppm
2f3c512220a44b0e97360c16ba8d37f4 red.ppm
1f843df4714bdd958deb15411a096ae2 white.jxl.ppm
1f843df4714bdd958deb15411a096ae2 white.ppm
```
**Expected behavior**
```
% md5sum *.ppm
2b677152c85951ffa01d492ad091e404 black.jxl.ppm
2b677152c85951ffa01d492ad091e404 black.ppm
cb541dd4b1ad5b2afefd73e903d564dc blue.jxl.ppm
cb541dd4b1ad5b2afefd73e903d564dc blue.ppm
e7a85c6831a581574de47d902ff69523 green.jxl.ppm
e7a85c6831a581574de47d902ff69523 green.ppm
2f3c512220a44b0e97360c16ba8d37f4 red.jxl.ppm
2f3c512220a44b0e97360c16ba8d37f4 red.ppm
1f843df4714bdd958deb15411a096ae2 white.jxl.ppm
1f843df4714bdd958deb15411a096ae2 white.ppm
```
**Environment**
- OS: Debian/amd64
- Compiler version: gcc
- CPU type: x86_64
- cjxl/djxl version string: git commit 89875cb
| round-trip lossless encoding for sRGB and 16bits. | https://api.github.com/repos/libjxl/libjxl/issues/1273/comments | 1 | 2022-03-25T08:33:54Z | 2022-03-25T08:46:44Z | https://github.com/libjxl/libjxl/issues/1273 | 1,180,495,367 | 1,273 |
[
"libjxl",
"libjxl"
] | Hello, libjxl community. I have a problem of build failed on libjxl.
I tried build libjxl of cjxl and djxl, I build all using keyboard shortcut CTRL + SHIFT + B.
During building, I got my build all failed. See the error log:
https://pastebin.com/wkKFqWPx
Visual Studio version: 2022 (17.10.2)
Windows (winver): Windows Server 2022 (Version Dev OS Build 22483.1011)
System type: x86_64
Clang version: 13.0.0
VCPKG version: 2022-03-09-1affd32f93b299d5a907816c328ca3ededb73a7e
Cmake version: 3.23.0-rc2
Cmake configure and generation finished log:
https://pastebin.com/PxF72Uzi
Is there any possible to fix?
I followed the docs of libjxl and vcpkg on Github.
1. Install vcpkg on C:/src/vcpkg, used .bat Microsoft/vcpkg
2. Install packages with vcpkg and integrated with Visual Studio 2022
3. Git cloned libjxl with checking out code.
4. Open libjxl folder with Visual Studio, right clicked CMakeLists.txt, changed from debug to Clang Release x64
5. Clicked edit json and saved file before editor pop up... replaced json with [JSON Example](https://github.com/libjxl/libjxl/blob/main/doc/developing_in_windows_vcpkg.md#building)
6. Waiting for configuring and generating in Cmake. https://pastebin.com/PxF72Uzi
7. I pressed F7, but nothing happened. I pressed CTRL + SHIFT + B as Build all.
8. Log file error: https://pastebin.com/wkKFqWPx
# Update 25th February 2022 18:53 (AEDT)
I used configure, build and install and it worked without GUI.
Configure:
```
cmake -Bbuild -H. -A x64 -DBUILD_TESTING=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=C:/Users/Administrator/Downloads/libjxl/prefix -DCMAKE_TOOLCHAIN_FILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake -DJPEGXL_ENABLE_OPENEXR=OFF -DJPEGXL_ENABLE_PLUGINS=OFF -DJPEGXL_ENABLE_TCMALLOC=OFF -DJPEGXL_ENABLE_VIEWERS=OFF -DVCPKG_TARGET_TRIPLET=x64-windows-static -DJPEGXL_BUNDLE_GFLAGS=ON
```
Build:
```
cmake --build build --config Release
```
Install:
```
cmake --build build --config Release --target install
``` | Error building on VCPKG 2022 x86_64... trying build on #544 | https://api.github.com/repos/libjxl/libjxl/issues/1272/comments | 4 | 2022-03-25T07:23:14Z | 2024-03-04T10:12:38Z | https://github.com/libjxl/libjxl/issues/1272 | 1,180,435,730 | 1,272 |
[
"libjxl",
"libjxl"
] | `FastLosslessEncode()` modifies the values of the first three channels when the fourth channel is `0x00`.
See, for example, `"qoi_benchmark_suite/images/pngimg/academy_awards_PNG9.png"`.
https://github.com/libjxl/libjxl/blob/4e656e740a0bae9ef7129ea7851c96023d736958/experimental/fast_lossless/fast_lossless.cc#L870 | FastLosslessEncode() is not lossless | https://api.github.com/repos/libjxl/libjxl/issues/1268/comments | 3 | 2022-03-23T21:59:04Z | 2022-03-31T13:24:58Z | https://github.com/libjxl/libjxl/issues/1268 | 1,178,713,867 | 1,268 |
[
"libjxl",
"libjxl"
] | This issue was found by [oss-fuzz](https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=45866), which is testing Qt plug-in for JXL format. libjxl 0.6.1 is used.
Test file:
[oss-fuzz_45866.zip](https://github.com/libjxl/libjxl/files/8318714/oss-fuzz_45866.zip)
Please verify whether the issue is serious or not and/or whether it was resolved meanwhile.
```
/src/libjxl/lib/jxl/modular/transform/palette.h:87:14: runtime error: signed integer overflow: 128 * 16777216 cannot be represented in type 'int'
#0 0x5d222a in jxl::palette_internal::GetPaletteValue(int const*, int, unsigned long, int, int, int) libjxl/lib/jxl/modular/transform/palette.h:87:14
#1 0x5d47ca in operator() libjxl/lib/jxl/modular/transform/palette.h:264:21
#2 0x5d47ca in jxl::ThreadPool::RunCallState<jxl::Status (unsigned long), jxl::InvPalette(jxl::Image&, unsigned int, unsigned int, unsigned int, jxl::Predictor, jxl::weighted::Header const&, jxl::ThreadPool*)::$_5>::CallDataFunc(void*, unsigned int, unsigned long) libjxl/lib/jxl/base/data_parallel.h:88:14
#3 0x4fd308 in jxl::ThreadPool::SequentialRunnerStatic(void*, void*, int (*)(void*, unsigned long), void (*)(void*, unsigned int, unsigned long), unsigned int, unsigned int) libjxl/lib/jxl/base/data_parallel.cc:18:5
#4 0x5d44ae in Run<jxl::Status (unsigned long), (lambda at /src/libjxl/lib/jxl/modular/transform/palette.h:255:11)> libjxl/lib/jxl/base/data_parallel.h:51:12
#5 0x5d44ae in bool jxl::ThreadPool::Run<jxl::InvPalette(jxl::Image&, unsigned int, unsigned int, unsigned int, jxl::Predictor, jxl::weighted::Header const&, jxl::ThreadPool*)::$_5>(unsigned int, unsigned int, jxl::ThreadPool::SkipInit, jxl::InvPalette(jxl::Image&, unsigned int, unsigned int, unsigned int, jxl::Predictor, jxl::weighted::Header const&, jxl::ThreadPool*)::$_5 const&, char const*) libjxl/lib/jxl/base/data_parallel.h:60:12
#6 0x5cfec5 in RunOnPool<jxl::ThreadPool::SkipInit, (lambda at /src/libjxl/lib/jxl/modular/transform/palette.h:255:11)> libjxl/lib/jxl/base/data_parallel.h:0:9
#7 0x5cfec5 in jxl::InvPalette(jxl::Image&, unsigned int, unsigned int, unsigned int, jxl::Predictor, jxl::weighted::Header const&, jxl::ThreadPool*) libjxl/lib/jxl/modular/transform/palette.h:253:7
#8 0x5cf6e9 in jxl::Transform::Inverse(jxl::Image&, jxl::weighted::Header const&, jxl::ThreadPool*) libjxl/lib/jxl/modular/transform/transform.cc:32:14
#9 0x5cc473 in jxl::Image::undo_transforms(jxl::weighted::Header const&, int, jxl::ThreadPool*) libjxl/lib/jxl/modular/modular_image.cc:20:23
#10 0x71cd93 in jxl::ModularFrameDecoder::FinalizeDecoding(jxl::PassesDecoderState*, jxl::ThreadPool*, jxl::ImageBundle*) libjxl/lib/jxl/dec_modular.cc:605:6
#11 0x6ea6b2 in jxl::FrameDecoder::Flush() libjxl/lib/jxl/dec_frame.cc:830:3
#12 0x6e187b in jxl::FrameDecoder::FinalizeFrame() libjxl/lib/jxl/dec_frame.cc:927:3
#13 0x515eee in jxl::(anonymous namespace)::JxlDecoderProcessInternal(JxlDecoderStruct*, unsigned char const*, unsigned long) libjxl/lib/jxl/decode.cc:1340:28
#14 0x5119ef in JxlDecoderProcessInput libjxl/lib/jxl/decode.cc:1755:14
``` | Issue 45866: kimageformats:kimgio_jxl_fuzzer: Integer-overflow in jxl::palette_internal::GetPaletteValue | https://api.github.com/repos/libjxl/libjxl/issues/1260/comments | 1 | 2022-03-21T19:46:41Z | 2022-03-29T18:43:43Z | https://github.com/libjxl/libjxl/issues/1260 | 1,175,862,932 | 1,260 |
[
"libjxl",
"libjxl"
] | If the codestream requires a Level 10 (e.g. size too big, `modular_16bit_buffers = false`, more than 4 extra channels, etc.), and the information that tells you this is in `JxlBasicInfo` then the library should automatically increase the codestream level to 10.
There's no particular reason that the library should fail so late in the encode process with no clear indication of why it failed. Either the encode process needs a status `JXL_ENC_INCREASE_LEVEL` which forces the user to call the codestream level increase, or, preferably, it should just do this automatically without requiring an extra API call.
One possible idea would be to have `JXL_ENC_INCREASE_LEVEL` be an event that could be subscribed to in the encode loop, so if the encoder automatically increases the codestream level, then this event will be fired as an informational message, but if the client does not need this info they can simply not subscribe to the event.
| Automatically increase codestream level based on basic info | https://api.github.com/repos/libjxl/libjxl/issues/1250/comments | 6 | 2022-03-20T15:03:23Z | 2024-03-04T10:12:38Z | https://github.com/libjxl/libjxl/issues/1250 | 1,174,578,380 | 1,250 |
[
"libjxl",
"libjxl"
] | **Is your feature request related to a problem? Please describe.**
I have 200 color channels of the same image (hyperspectral satellite imagery) and I'd like to compress it as efficiently as possible losslessly. When I encode exactly 3 channels, I get better compression than with a single channel, but I haven't found a way to ask libjxl to encode more channels at the same time.
**Describe the solution you'd like**
Maybe what I want is already possible and I'm missing pointers to documentation to input the channels correctly, or define a new custom colorspace/colorencoding/something similar? Or maybe what I want simply isn't possible as the code in color_encoding_internal.cc seems to talk about primaries r/g/b? It seems to work very well for 3 channels even though the colors I tested with were nothing near red/green/blue in physical reality.
**Describe alternatives you've considered**
I've tried adding more channels as new frames, or as extra channels in the same frame. Both of these seem to work (didn't try decoding), but provide the same compression as compressing each channel to a separate single channel file.
**Additional context**
I'm currently testing with the exported C API, but if the solution is hacking the internals (or better yet, improving them for everybody) then that's fine for me too. | Compress efficiently more than 3 color channels | https://api.github.com/repos/libjxl/libjxl/issues/1245/comments | 18 | 2022-03-18T08:35:24Z | 2025-03-29T06:53:23Z | https://github.com/libjxl/libjxl/issues/1245 | 1,173,333,155 | 1,245 |
[
"libjxl",
"libjxl"
] | Hi. I found such a bug if I did everything right.
```
JPEG XL encoder v0.7.0 0.7.0-373c592 [Scalar]
color_hints.cc:56: No color_space/icc_pathname given, assuming sRGB
Read 1563x1558 image, 25.8 MP/s
Encoding [Modular, lossless, hare], 4 threads.
enc_palette.cc:558: JXL_RETURN_IF_ERROR code=1: FwdPaletteIteration( input, begin_c, end_c, nb_colors, nb_deltas, ordered, lossy, predictor, wp_header, palette_iteration_data)
```
cjxl.exe image_21447_24bit.png image_21447_24bit.jxl -v -m -q 100 -s 5 -C 1 --num_threads=4 | Error converting PNG | https://api.github.com/repos/libjxl/libjxl/issues/1244/comments | 4 | 2022-03-18T06:29:53Z | 2022-03-22T19:01:48Z | https://github.com/libjxl/libjxl/issues/1244 | 1,173,232,052 | 1,244 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
I'm using `JxlEncoderSetExtraChannelBuffer` to encode extra channel data for a base image that's RGB. It work great up-to 4 channels, but then adding a 5th (even if it's the exact same data or new data) causes an error in `JxlEncoderProcessOutput` which returns status code 1.
**To Reproduce**
Encode an RGB image with 5 extra_channels of greyscale data. This does not seem to depend on the image resolution. I fetched the main branch yesterday (bd074245ad2d96d818ed253d0571550dc95e600c).
(I'm calling `libjxl` wrapped via `jxlpy`, but the error is passed back directly from `JxlEncoderProcessOutput`.)
**Expected behavior**
Either one of the following:
* An error is returned earlier in `JxlEncoderSetExtraChannelBuffer` if there's a hard-limit or other reason why the extra_channel can't be processed.
* No error is returned at any stage and `JxlEncoderProcessOutput` processes channels beyond 4.
**Environment**
- OS: Linux 20.04 LTS
- Compiler version: gcc
- CPU type: AMD Threadripper
- cjxl/djxl version string: JPEG XL encoder v0.7.0 bd07424 [AVX2,SSE4,SSSE3,Scalar]
| Hard limit at extra_channels=4 when encoding via API? Throws error at 5 or more. | https://api.github.com/repos/libjxl/libjxl/issues/1237/comments | 2 | 2022-03-15T16:36:39Z | 2022-03-24T14:41:34Z | https://github.com/libjxl/libjxl/issues/1237 | 1,169,916,994 | 1,237 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
I can't open certain large JPEG XL files (the breaking point is somewhere between 4097x2731 and 6000x4000; I can do a more exhaustive test if needed) in eog. This holds for lossless and lossy files, as well as losslessly transcoded JPEGs. I'm pretty sure that these files used to work in eog, although I'm not certain. I don't think this is a bug in GdkPixbuf or eog, since the full-resolution source JPEGs (6000x4000) open just fine.
**To Reproduce**
Steps to reproduce the behavior:
- Try to open a large JPEG XL image (one that breaks is attached) with eog
**Expected behavior**
The image is displayed.
**Screenshots**
If applicable, add screenshots or example input/output images to help explain your problem.
**Environment**
- OS: Arch Linux
- Compiler version: clang 13.0.0 (what Arch's package was built with)
- CPU type: x86_64
- cjxl/djxl version string: cjxl v0.6.1 a205468b [AVX2,SSE4,SSSE3,Scalar]
- GdkPixbuf version: 2.42.6-2
- eog version: 41.1
**Additional context**
Log output from eog:
```
(eog:264174): GdkPixbuf-CRITICAL **: 23:41:50.805: gdk_pixbuf_animation_is_static_image: assertion 'GDK_IS_PIXBUF_ANIMATION (animation)' failed
(eog:264174): GdkPixbuf-CRITICAL **: 23:41:50.805: gdk_pixbuf_animation_get_iter: assertion 'GDK_IS_PIXBUF_ANIMATION (animation)' failed
(eog:264174): GdkPixbuf-CRITICAL **: 23:41:50.805: gdk_pixbuf_animation_iter_get_pixbuf: assertion 'GDK_IS_PIXBUF_ANIMATION_ITER (iter)' failed
(eog:264174): EOG-WARNING **: 23:41:50.902: Thumbnail creation failed
(eog:264174): EOG-WARNING **: 23:41:50.902: Thumbnail creation failed
(eog:264174): EOG-WARNING **: 23:41:50.902: Thumbnail creation failed
(eog:264174): EOG-WARNING **: 23:41:50.902: Thumbnail creation failed
```
ZIP archive containing a file that breaks in eog (works with Chromium and djxl):
[broken-file.zip](https://github.com/libjxl/libjxl/files/8237276/broken-file.zip)
| GdkPixbuf loader (as used by eog) breaks on large files | https://api.github.com/repos/libjxl/libjxl/issues/1232/comments | 2 | 2022-03-12T08:15:08Z | 2022-03-17T00:52:57Z | https://github.com/libjxl/libjxl/issues/1232 | 1,167,219,439 | 1,232 |
[
"libjxl",
"libjxl"
] | **Is your feature request related to a problem? Please describe.**
I am working on QEMU & QXL. The graphic data I get from QXL driver is BMP format.
So I need to encode bitmap to jxl, but I found we currently do not support bitmap encoding.
**Describe the solution you'd like**
Is there a plan to support bitmap encoding? Or in fact there has been, but I don't know?
Any suggestions are welcome. Thanks guys~
| Bitmap support | https://api.github.com/repos/libjxl/libjxl/issues/1211/comments | 6 | 2022-03-07T07:09:05Z | 2023-07-03T07:53:13Z | https://github.com/libjxl/libjxl/issues/1211 | 1,160,991,724 | 1,211 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
https://github.com/libjxl/libjxl/blob/ec7adc703541daad0b6b1ec8bde5cbe3a3bfcf7c/lib/include/jxl/encode.h#L100-L106
This matches its setter:
https://github.com/libjxl/libjxl/blob/ec7adc703541daad0b6b1ec8bde5cbe3a3bfcf7c/lib/jxl/encode.cc#L768
But according to the encoder itself, the default value is not -1, it's **0** according to enc_file.cc:
https://github.com/libjxl/libjxl/blob/ec7adc703541daad0b6b1ec8bde5cbe3a3bfcf7c/lib/jxl/enc_file.cc#L204-L208
or **1** if we check enc_params.h:
https://github.com/libjxl/libjxl/blob/ec7adc703541daad0b6b1ec8bde5cbe3a3bfcf7c/lib/jxl/enc_params.h#L248-L253
This means that if I try to set it, e.g. when extracting the value from an UI dialog, this happens:
https://github.com/libjxl/libjxl/blob/ec7adc703541daad0b6b1ec8bde5cbe3a3bfcf7c/lib/jxl/enc_frame.cc#L322-L324
**To Reproduce**
Just append this line here:
https://github.com/libjxl/libjxl/blob/ec7adc703541daad0b6b1ec8bde5cbe3a3bfcf7c/examples/encode_oneshot.cc#L186-L190
```cpp
JxlEncoderFrameSettingsSetOption(frameSettings,
JXL_ENC_FRAME_SETTING_RESAMPLING,
cfg->getInt("resampling", -1));
```
**Expected behavior**
Encoding succeeds.
**Screenshots**
**Environment**
- OS: [e.g. Windows] Windows 10 21H2
- Compiler version: [e.g. clang 11.0.1] MSVC 14.29.30133
- CPU type: [e.g. x86_64] x86_64
- cjxl/djxl version string: [e.g. cjxl [v0.3.7 | SIMD supported: SSE4,Scalar]] JPEG XL encoder v0.7.0 0.6.1 [AVX2,SSE4,SSSE3,Scalar]
**Additional context**
The only place where `JXL_ENC_FRAME_SETTING_RESAMPLING` is declared to be `-1` by default is here:
https://github.com/libjxl/libjxl/blob/ec7adc703541daad0b6b1ec8bde5cbe3a3bfcf7c/tools/cjxl_ng_main.cc#L526-L536
| Setting JXL_ENC_FRAME_SETTING_RESAMPLING with its documented default value breaks encoding | https://api.github.com/repos/libjxl/libjxl/issues/1210/comments | 0 | 2022-03-06T14:43:12Z | 2022-03-11T14:42:58Z | https://github.com/libjxl/libjxl/issues/1210 | 1,160,628,500 | 1,210 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
Both ImageMagick and GraphicsMagick (C programs) both support JXL. Reading JXL works fine, but writing JXL produces corrupt output which does not even include a JXL header. The output is smaller than expected. For GraphicsMagick, a single thread is used.
It is observed that cjxl and djxl work fine.
**To Reproduce**
This procedure was used to build and install libjxl under Ubuntu 20.04:
```
git clone https://github.com/libjxl/libjxl.git --recursive --shallow-submodules
cd ./libjxl
mkdir build
cd ./build
export CC=clang-12 CXX=clang++-12
cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_INSTALL_PREFIX=/usr/local ..
cmake --build . -- -j$(nproc)
make test
[ check for 100% tests passed ]
make install
```
and then
```
hg clone https://hg.osdn.net/view/graphicsmagick/GM
./configure LDFLAGS=-L/usr/local/lib -Wl,-rpath,/usr/local/lib' '--with-quantum-depth=8' '--disable-shared' '--enable-static' '--disable-openmp' '--with-jxl
make
./utilities/gm convert rose: rose.jxl
djxl rose.jxl rose.ppm
JPEG XL decoder v0.7.0 ec7adc7 [AVX2,SSE4,SSSE3,Scalar]
Read 1067 compressed bytes.
Failed to decompress to pixels.
```
**Expected behavior**
I expect that the encoded file will be a JXL file and dxjl will be able to decode it. The file should at least contain the string "JXL".
**Environment**
- OS: [Ubuntu 20.04 LTS]
- Compiler version: [e.g. clang 12.0.0 or gcc 10]
- CPU type: [e.g. x86_64]
- cjxl/djxl version string: [e.g. cjxl v0.7.0 ec7adc7 [AVX2,SSE4,SSSE3,Scalar]]
**Additional context**
It is reported that ImageMagick is able to write JXL under Windows using an older JXL release version.
| ImageMagick and GraphicsMagick write corrupt JXL with current ("v0.7.0") libjxl | https://api.github.com/repos/libjxl/libjxl/issues/1209/comments | 8 | 2022-03-05T21:43:41Z | 2022-03-11T20:05:06Z | https://github.com/libjxl/libjxl/issues/1209 | 1,160,452,541 | 1,209 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
CMake fails to find gflags.
**To Reproduce**
Clone the repository, pull down deps with git submodule, and run CMake with or without any flags.
**Expected behavior**
I expected CMake to configure the project correctly.
**Environment**
- OS: Windows 10 21H2 and up-to-date no-testing-repos Arch Linux
- Compiler version: MSVC 2022 17.1.0 Build Tools or Community, with Windows SDK 10.0.19041.685 or clang 11.0.0 on same Windows or gcc 11.2.0 on same Windows or clang 13.0.1 on said Arch Linux or gcc 11.2.0 on same Arch Linux. CMake 3.22.2 in all cases.
- CPU type: x86_64
- cjxl/djxl version string: Ain't one cuz it didn't build but it was from libjxl commit [89875cb](https://github.com/libjxl/libjxl/commit/89875cba4d18485ec9692c80b747b59b73ce712e) and gflags commit [986e8ee](https://github.com/gflags/gflags/commit/986e8eed00ded8168ef4eaa6f925dc6be50b40fa) | CMake Error at third_party/CMakeLists.txt:170 (find_package): By not providing "Findgflags.cmake" in CMAKE_MODULE_PATH this project has asked CMake to find a package configuration file provided by "gflags", but CMake did not find one. | https://api.github.com/repos/libjxl/libjxl/issues/1206/comments | 6 | 2022-03-02T23:13:24Z | 2024-03-04T10:12:37Z | https://github.com/libjxl/libjxl/issues/1206 | 1,157,787,582 | 1,206 |
[
"libjxl",
"libjxl"
] | BufferToImageBundle / ConvertFromExternal in enc_external_image.cc does not look at pixel_format to determine the number of channels given in the input buffer, it just assumes that if the color encoding is grayscale, there is 1 color channel, and otherwise there are 3.
This causes bigtime trouble if you try encoding an image that happens to be grayscale by giving the encoder an RGB(A) buffer (where R=G=B). It's quite common for applications to do everything with RGBA buffers regardless of whether the image actually has alpha or is grayscale or not, to reduce the number of cases / code paths. If you pass an RGBA buffer (marked as such in the pixel_format), the current code will treat it as if it's a Gray+Alpha buffer if the color encoding is grayscale, i.e. it will interpret R and B as gray samples and G and A as alpha samples, which is of course not what it should do.
Possible solutions to correctly deal with this case:
- check that R=G=B if the color encoding is grayscale (otherwise return error since "you lied") but an RGB(A) buffer gets passed
- assume that R=G=B in this case, and e.g. just ignore R and B and put G in the gray channel
- don't assume anything, and convert to grayscale in some way (e.g. 0.299*R + 0.587*G + 0.114*B)
It probably also causes trouble if you try to pass a grayscale buffer when the image is RGB (though that's less likely to actually happen in practice).
| encode api: grayscale input sent as RGB(A) buffer is broken | https://api.github.com/repos/libjxl/libjxl/issues/1198/comments | 0 | 2022-02-25T15:26:47Z | 2022-03-11T19:26:24Z | https://github.com/libjxl/libjxl/issues/1198 | 1,150,579,892 | 1,198 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
I cannot build libjxl from scratch on Windows due to [CMake issue 22919](https://gitlab.kitware.com/cmake/cmake/-/issues/22919). This affects specifically the gflags dependency; since libjxl imports libraries in a sibling directory to `tools`, `gflags`'s location cannot be seen at link time:
(excerpt of `build\tools\cjxl_ng.vcxproj)
```xml
<Link>
<AdditionalDependencies>..\lib\MinSizeRel\jxl.lib;gflags.lib;box\MinSizeRel\box.lib;..\lib\MinSizeRel\jxl-static.lib;..\lib\MinSizeRel\jxl_extras-static.lib;..\lib\MinSizeRel\jxl_threads-static.lib;MinSizeRel\jxl_tool.lib;..\lib\MinSizeRel\jxl_extras_dec-static.lib;E:\krita-win\i_deps_msvc\lib\gif.lib;E:\krita-win\i_deps_msvc\lib\jpeg.lib;E:\krita-win\i_deps_msvc\lib\libpng16.lib;E:\krita-win\i_deps_msvc\lib\zlib.lib;..\lib\MinSizeRel\jxl-static.lib;E:\krita-win\i_deps_msvc\lib\brotlidec.lib;E:\krita-win\i_deps_msvc\lib\brotlicommon.lib;E:\krita-win\i_deps_msvc\lib\hwy.lib;E:\krita-win\i_deps_msvc\lib\brotlienc.lib;E:\krita-win\i_deps_msvc\lib\lcms2.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;comdlg32.lib;advapi32.lib</AdditionalDependencies>
```
(excerpt of build log):
```
[build] LINK : fatal error LNK1104: no se puede abrir el archivo 'gflags.lib' [E:\libjxl\build\tools\cjxl_ng.vcxproj]
```
**To Reproduce**
Build and install all dependencies separately: brotli gflags giflib highway jpeg lcms2 openexr png
Then configure and build libjxl with e.g.:
```json
{
"cmake.configureSettings": {
"CMAKE_PREFIX_PATH": "E:/krita-win/i_deps_msvc",
"JPEGXL_VERSION": "0.6.1",
"BUILD_TESTING": false,
"JPEGXL_ENABLE_BENCHMARK": false,
"JPEGXL_ENABLE_COVERAGE": false,
"JPEGXL_ENABLE_EXAMPLES": false,
"JPEGXL_ENABLE_FUZZERS": false,
"JPEGXL_ENABLE_JNI": false,
"JPEGXL_ENABLE_SJPEG": false,
"JPEGXL_ENABLE_SKCMS": false,
"JPEGXL_ENABLE_VIEWERS": false
},
}
```
**Expected behavior**
The library is correctly built and installed.
**Screenshots**
N/A
**Environment**
- OS: [e.g. Windows]: Windows 10 20H2
- Compiler version: [e.g. clang 11.0.1] MSVC 19.29.30140
- CPU type: [e.g. x86_64] x86_64
- cjxl/djxl version string: [e.g. cjxl [v0.3.7 | SIMD supported: SSE4,Scalar]] commit ea6a190cd777b61662bd0470db24163a1a63bdab
**Additional context**
N/A
| Importing libraries via thirdparty makes libjxl impossible to build on Windows | https://api.github.com/repos/libjxl/libjxl/issues/1197/comments | 0 | 2022-02-24T16:53:10Z | 2024-03-04T10:12:37Z | https://github.com/libjxl/libjxl/issues/1197 | 1,149,520,145 | 1,197 |
[
"libjxl",
"libjxl"
] | Hi, I have noticed that sometimes the output of djxl can be as much as 50% larger than the original input JPEG. I understand that JXL is not meant to be used solely as a JPEG optimizer, but I would like to reap some of the benefits of the JXL codec back in the original JPEG domain.
Is it possible to guarantee that the output of djxl will be within some factor of the original input JPEG size? If not, how should I go about trying to make the output file as small as is reasonably possible?
Thanks
| Constraining djxl lossy JPEG output size? | https://api.github.com/repos/libjxl/libjxl/issues/1195/comments | 1 | 2022-02-23T21:15:53Z | 2022-03-11T12:14:58Z | https://github.com/libjxl/libjxl/issues/1195 | 1,148,588,817 | 1,195 |
[
"libjxl",
"libjxl"
] | Doesn’t it mean that this is also not used? (Should it be?)
_Originally posted by @sboukortt in https://github.com/libjxl/libjxl/pull/1189#discussion_r811075496_ | Unused extra channel name in djxl_conformance | https://api.github.com/repos/libjxl/libjxl/issues/1191/comments | 3 | 2022-02-21T12:33:52Z | 2024-03-04T10:12:37Z | https://github.com/libjxl/libjxl/issues/1191 | 1,145,741,620 | 1,191 |
[
"libjxl",
"libjxl"
] | ## Comment:
Hello jxl team, sorry to bother you,
I focus on non-photo content quality and feature for a long time,
in the beginning, I focus on test varDCT lossy performance for non-photo content,
varDCT is work very well for some type non-photo picture,
but I get some quality and compression ratio issue for specific type non-photo picture.
In previous jxl discord discuss, Jon mention non-photo content can divided to
"photo-like" non-photo and "really non-photographic" non-photo two type,
varDCT and XYB is more suitable photo and "photo-like" non-photo,
"really non-photographic" non-photo use non-DCT method(jxl delta palette|lossy palette)
and colorspace close to RGB(YCoCg-R) can get better performance.
## Feature request:
1. Current jxl delta palette don't have quality control and only have RGB implement,
probably can implement quality control with target butteraugli distance(`-d`) and XYB implement?
(Current jxl delta palette also happen file size inflate issue for specific type non-photo picture.
similar DCT worst case issue)
2. I think some "photo-like" non-photo still need use varDCT,
probably can implement a vardct(XYB) and delta palette(XYB) combine mode on target distance(`-d`),
and have heuristic auto switch vardct(XYB) and delta palette(XYB) for different situation?
3. Probably combine other jxl feature `--patches`, `--epf`, `--noise`, `--dots` can let delta palette work better?
example:
> cjxl -d 0.5 -e 8 // vardct (XYB)
> cjxl -d 0.5 -e 8 -m --lossy-palette // delta palette `-d` implement (XYB)
> cjxl -d 0.5 -e 8 --combine-mode // vardct(XYB) and delta palette (XYB)
## From jxl discord:
> https://discord.com/channels/794206087879852103/805176455658733570/942120326999978024
> wb — 2022/02/13
> XYB is also suitable for non-photo, but perhaps less so than for photo.
> A lot of non-photo material does get created in RGB, so there are certainly cases where it's a better idea
> (for compression) to stay in RGB or something close to RGB (like YCoCg).
>
> https://discord.com/channels/794206087879852103/805176455658733570/942129214361047140
> wb — 2022/02/13
> I think (var)DCT is only really suitable for photo and "photo-like" non-photo,
> like realistic paintings or renders, fps games, drawings with pencil, charcoal, chalk etc.
> For "really non-photographic" non-photo, like screenshots with mostly text and
> UI elements, logos, charts, and digital illustrations with hard edges,
> I think DCT is not the most effective approach. Lossless compression techniques
> (with lossy preprocessing, e.g. (delta)-palettization) will work better for that imo.
> We already do that for patches of text (it's encoded losslessly after doing color quantization in XYB,
> and subtracted from the DCT image so if the color quantization introduced some error,
> there's still a chance for the DCT part to fix it)
| Non-photo content quality,feature improvement and delta palette | https://api.github.com/repos/libjxl/libjxl/issues/1188/comments | 2 | 2022-02-18T18:40:24Z | 2022-11-18T08:54:22Z | https://github.com/libjxl/libjxl/issues/1188 | 1,143,564,174 | 1,188 |
[
"libjxl",
"libjxl"
] | /libjxl-main/tools/djxl_ng_main.cc line 327 same as line 302
Code:
} else if (status == JXL_DEC_NEED_IMAGE_OUT_BUFFER) {
| Identical condition | https://api.github.com/repos/libjxl/libjxl/issues/1187/comments | 2 | 2022-02-18T14:19:35Z | 2022-03-11T14:42:31Z | https://github.com/libjxl/libjxl/issues/1187 | 1,143,147,581 | 1,187 |
[
"libjxl",
"libjxl"
] | PSNR is a start but it seems there are new metrics that can be complementary:
https://paperswithcode.com/paper/nima-neural-image-assessment
https://paperswithcode.com/paper/a-study-of-deep-perceptual-metrics-for-image
And much more here:
https://paperswithcode.com/task/image-quality-assessment
Generally, using neural networks to assess image quality might give complementary insights that are closer to human judgment in pathological cases where PSNR would diverge from human judgment. | Complementary metrics for assessing image quality | https://api.github.com/repos/libjxl/libjxl/issues/1186/comments | 3 | 2022-02-18T12:28:58Z | 2022-03-11T21:17:16Z | https://github.com/libjxl/libjxl/issues/1186 | 1,142,971,500 | 1,186 |
[
"libjxl",
"libjxl"
] | Hello,
I have a series of 16 bits TIFF that I would like to compress with jxl and I would like them to stay in 16bit.
How can I ensure that the compression preserve the bit depth and how can I check the bit depth of a resulting jxl file?
Thank you
| How to know if a jxl file is 8bit or 16bit? | https://api.github.com/repos/libjxl/libjxl/issues/1183/comments | 2 | 2022-02-17T20:24:24Z | 2022-03-11T14:06:21Z | https://github.com/libjxl/libjxl/issues/1183 | 1,141,829,888 | 1,183 |
[
"libjxl",
"libjxl"
] | libjxl-main/lib/jxl/enc_cluster.cc:177] (performance) Searching before insertion is not necessary. Instead of 'new_index[symbol]=next_index' consider using 'new_index.try_emplace(symbol, next_index);'. [stlFindInsert] | enc_cluster.cc | https://api.github.com/repos/libjxl/libjxl/issues/1181/comments | 2 | 2022-02-17T10:50:46Z | 2025-01-17T18:33:36Z | https://github.com/libjxl/libjxl/issues/1181 | 1,141,175,184 | 1,181 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
When encoding an image with `cjxl` that combines `--lossy-palette` with `-p`, the resulting image decodes incorrectly when using the `-s` option with djxl
**To Reproduce**
1. Run `cjxl <input> -m --lossy-palette --palette=0 -p <output1>`
2. Then `djxl <output1> -s 2 <output2>` (Or any value >1)
**Expected behavior**
I'd expect to either get a lower quality version of the image, or a blank result like regular non-progressive lossless modular
**Screenshots**
This is what I get with `-s 8`
**Environment**
x86_64 Windows 11, binary from github CI
JPEG XL decoder v0.7.0 b6d7ba0 [AVX2,SSE4,SSSE3,Scalar] | `--lossy-palette` and progressive mode don't mix | https://api.github.com/repos/libjxl/libjxl/issues/1177/comments | 3 | 2022-02-16T10:36:37Z | 2024-03-04T10:12:37Z | https://github.com/libjxl/libjxl/issues/1177 | 1,139,835,317 | 1,177 |
[
"libjxl",
"libjxl"
] | I've compiled libjxl from source on my ubuntu machine. Now, I want to ```find_package(LibJxl)``` or something similar in my own CMake project so that I can use libjxl in my codes. But it seems that libjxl does not provide any config.cmake file.
| How to link to libjxl with Cmake? | https://api.github.com/repos/libjxl/libjxl/issues/1175/comments | 3 | 2022-02-15T10:12:57Z | 2022-03-11T14:44:43Z | https://github.com/libjxl/libjxl/issues/1175 | 1,138,468,728 | 1,175 |
[
"libjxl",
"libjxl"
] | Compatibility of jpeg(XT) 8bit photos, i.e. all types of jpeg lossless, progressice, sequetial, baseline (RGB and YCbCr).
Oddly enough, these pictures seem to be reading the jpeg-turbo codec (assembler) these days.
Jpeg(XT) lossless and variations can still be problematic.
Code:
```
Unsupported marker type 0xf7
Unsupported marker type 0xc3
```
I tested aom, libavif, libwebp2 and libjxl.
Code:
```
JPEG XL encoder v0.7.0 0.7.0-4bba562 [Scalar] with JPEG lossy transcode
jpg.cc:202: JXL_FAILURE: arithmetic code JPEGs are not supported
JPEG XL encoder v0.7.0 0.7.0-4bba562 [Scalar] without JPEG lossy transcode
enc_jpeg_data_reader.cc:170: Invalid comps_in_scan: 3
enc_jpeg_data.cc:305: JXL_FAILURE: Error reading JPEG
```
**_Independent JPEG Group's CJPEG, version 9e 16-Jan-2022
Copyright (C) 2022, Thomas G. Lane, Guido Vollbeding_**
cjpeg_08bit.exe -quality 100 -rgb -progressive -arithmetic -bgycc -verbose image_21447_24bit.ppm image_21448_24bit(ps)_RGB.jpg
cjpeg_08bit.exe -quality 100 -progressive -arithmetic -bgycc -verbose image_21447_24bit.ppm image_21448_24bit(ps)_YCbCr.jpg
cjpeg_08bit.exe -quality 100 -rgb -arithmetic -bgycc -verbose image_21447_24bit.ppm image_21448_24bit(ss)_RGB.jpg
cjpeg_08bit.exe -quality 100 -arithmetic -bgycc -verbose image_21447_24bit.ppm image_21448_24bit(ss)_YCbCr.jpg
Failed `progressive` to create temporary file
**_jpegXT Copyright (C) 2012-2022 Thomas Richter, University of Stuttgart
and Accusoft_**
jpegLS.exe -encodepnm image_21447_24bit.ppm image_21448_24bit(l)_YCbCr.jls
jpegXT.exe -q 100 -l -c -a -r -qt 3 -s 1x1,1x1,1x1 image_21447_24bit.ppm image_21448_24bit(l)_RGB.jxt
jpegXT.exe -q 100 -v -c -a -r -qt 3 -s 1x1,1x1,1x1 image_21447_24bit.ppm image_21448_24bit(p)_RGB.jxt
jpegXT.exe -q 100 -v -a -r -qt 3 -s 1x1,1x1,1x1 image_21447_24bit.ppm image_21448_24bit(p)_YCbCr.jxt
jpegXT.exe -q 100 -c -a -r -qt 3 -s 1x1,1x1,1x1 image_21447_24bit.ppm image_21448_24bit(s)_RGB.jxt
jpegXT.exe -q 100 -a -r -qt 3 -s 1x1,1x1,1x1 image_21447_24bit.ppm image_21448_24bit(s)_YCbCr.jxt
av1enc.exe -q 100 -444 -size 1563x1558 -effort 5 -tune butteraugli -thread 4 image_21448_24bit(l)_YCbCr.jls -d image_21447_24bit(1).av1
av1enc.exe -q 100 -444 -size 1563x1558 -effort 5 -tune butteraugli -thread 4 image_21448_24bit(l)_RGB.jxt -d image_21447_24bit(2).av1
av1enc.exe -q 100 -444 -size 1563x1558 -effort 5 -tune butteraugli -thread 4 image_21448_24bit(p)_RGB.jxt -d image_21447_24bit(3).av1
av1enc.exe -q 100 -444 -size 1563x1558 -effort 5 -tune butteraugli -thread 4 image_21448_24bit(p)_YCbCr.jxt -d image_21447_24bit(4).av1
av1enc.exe -q 100 -444 -size 1563x1558 -effort 5 -tune butteraugli -thread 4 image_21448_24bit(s)_RGB.jxt -d image_21447_24bit(5).av1
av1enc.exe -q 100 -444 -size 1563x1558 -effort 5 -tune butteraugli -thread 4 image_21448_24bit(s)_YCbCr.jxt -d image_21447_24bit(6).av1
cjxl.exe image_21448_24bit(l)_RGB.jxt image_21447_24bit(2).jxl -e 5 -m -v -q 100 -s 5 -C 1 --num_threads=4
cjxl.exe image_21448_24bit(p)_RGB.jxt image_21447_24bit(3).jxl -e 5 -p -v -j -q 100 -s 5 -C 1 --num_threads=4
cjxl.exe image_21448_24bit(p)_YCbCr.jxt image_21447_24bit(4).jxl -e 5 -p -v -j -q 100 -s 5 -C 1 --num_threads=4
cjxl.exe image_21448_24bit(s)_RGB.jxt image_21447_24bit(5).jxl -e 5 -v -j -q 100 -s 5 -C 1 --num_threads=4
cjxl.exe image_21448_24bit(s)_YCbCr.jxt image_21447_24bit(6).jxl -e 5 -v -j -q 100 -s 5 -C 1 --num_threads=4
cwp2.exe image_21448_24bit(l)_RGB.jxt -info -q 100 -nometadata -mt -effort 5 -uv_mode 2 -csp 0 -o image_21448_24bit(2).wp2
cwp2.exe image_21448_24bit(p)_RGB.jxt -info -q 100 -nometadata -mt -effort 5 -uv_mode 2 -csp 0 -o image_21448_24bit(3).wp2
cwp2.exe image_21448_24bit(p)_YCbCr.jxt -info -q 100 -nometadata -mt -effort 5 -uv_mode 2 -csp 0 -o image_21448_24bit(4).wp2
cwp2.exe image_21448_24bit(s)_RGB.jxt -info -q 100 -nometadata -mt -effort 5 -uv_mode 2 -csp 0 -o image_21448_24bit(5).wp2
cwp2.exe image_21448_24bit(s)_YCbCr.jxt -info -q 100 -nometadata -mt -effort 5 -uv_mode 2 -csp 0 -o image_21448_24bit(6).wp2
htj2k-cgrok_ojph.exe -v -i image_21448_24bit(l)_RGB.jxt -o image_21447_24bit-grok(2).j2k -H 1 -M 32 -r 1 -mct 1
htj2k-cgrok_ojph.exe -v -i image_21448_24bit(p)_RGB.jxt -o image_21447_24bit-grok(3).j2k -H 1 -M 32 -r 1 -mct 1
htj2k-cgrok_ojph.exe -v -i image_21448_24bit(p)_YCbCr.jxt -o image_21447_24bit-grok(4).j2k -H 1 -M 32 -r 1 -mct 1
htj2k-cgrok_ojph.exe -v -i image_21448_24bit(s)_RGB.jxt -o image_21447_24bit-grok(5).j2k -H 1 -M 32 -r 1 -mct 1
htj2k-cgrok_ojph.exe -v -i image_21448_24bit(s)_YCbCr.jxt -o image_21447_24bit-grok(6).j2k -H 1 -M 32 -r 1 -mct 1
https://www.sendspace.com/file/mjx988 | Compatibility of jpeg(XT) 8bit photos with jpeg-turbo | https://api.github.com/repos/libjxl/libjxl/issues/1172/comments | 4 | 2022-02-12T14:27:56Z | 2022-04-08T10:05:36Z | https://github.com/libjxl/libjxl/issues/1172 | 1,134,123,018 | 1,172 |
[
"libjxl",
"libjxl"
] | Hi
I had build the wasm version, but cannot figure out how to run the djxl or decode_oneshot, decode_progressive in javascript.
Please provide some example code to run djxl or decode_oneshot, decode_progressive in javascript.
Thanks in advance. | Ask for an example code of wasm usage. | https://api.github.com/repos/libjxl/libjxl/issues/1165/comments | 1 | 2022-02-08T05:13:58Z | 2022-02-09T02:34:03Z | https://github.com/libjxl/libjxl/issues/1165 | 1,126,803,851 | 1,165 |
[
"libjxl",
"libjxl"
] | Hello,
I'm here to humbly ask for a tag after 0.6.1.
It seems that many patches have been added to help with building libjxl with dynamic libraries in mind.
This would help us get it onto conda forge without requriing too much backporting of patches
https://github.com/conda-forge/staged-recipes/pull/17812
Best,
Mark | New release after 0.6.1 | https://api.github.com/repos/libjxl/libjxl/issues/1159/comments | 2 | 2022-02-05T21:46:22Z | 2024-03-04T10:12:36Z | https://github.com/libjxl/libjxl/issues/1159 | 1,125,038,257 | 1,159 |
[
"libjxl",
"libjxl"
] | cjxl.exe image_21447_24bit.png image_21447_24bit.jxl -v -m -q 100 -s 5 -C 1 --num_threads=4
djxl.exe image_21447_24bit.jxl image_21447_24bitj.jpg --num_threads=4
```
JPEG XL decoder v0.7.0 0.7.0-3476d12 [Scalar]
Read 2558725 compressed bytes.
box.cc:290: JXL_FAILURE: Cannot decode to JPEG without a JPEG reconstruction box
``` | Problem with JPEG | https://api.github.com/repos/libjxl/libjxl/issues/1147/comments | 0 | 2022-02-01T16:34:09Z | 2022-02-09T20:04:25Z | https://github.com/libjxl/libjxl/issues/1147 | 1,120,933,620 | 1,147 |
[
"libjxl",
"libjxl"
] | ```
system_libs:INFO: retrieving port: zlib from https://github.com/madler/zlib/archive/v1.2.11.zip
em++: error: Unexpected hash: 9ec7c573fac2cd4d6ba64dd4dfd7330f317be75367575013da4004d7da7ff51b70b85783dc8533df081e70527135cdbf2ffc12b40f2d011fd7fbe6cb52d2f47d
If you are updating the port, please update the hash in the port module.
``` | CI: it seems that GH actions has problem fetching zlib sources | https://api.github.com/repos/libjxl/libjxl/issues/1145/comments | 1 | 2022-02-01T14:55:35Z | 2022-02-02T08:49:27Z | https://github.com/libjxl/libjxl/issues/1145 | 1,120,789,551 | 1,145 |
[
"libjxl",
"libjxl"
] | Hybrid integer decoding is relatively complex and could be simplified by precomputing some quantities, reducing the decoding cost.
Something like `offset[token] + ReadBits(nbits[token]) << shift[token]` should be possible. | Hybrid integer decoding could be tabled | https://api.github.com/repos/libjxl/libjxl/issues/1141/comments | 0 | 2022-02-01T11:22:38Z | 2022-04-08T10:04:07Z | https://github.com/libjxl/libjxl/issues/1141 | 1,120,543,138 | 1,141 |
[
"libjxl",
"libjxl"
] | Thank you so much for developing JPEG-XL! In my tests it looks like it'll be an excellent compression algorithm for satellite imagery. Thank you!
I appreciate that lossy JPEG-XL compression (like most lossy image compression) is designed primarily for compressing images that will be consumed by humans. As such, the algorithm preferentially throws away information that the human visual system won't notice is gone.
My question is: Which settings should I use when using JPEG-XL compression for monochrome satellite images that will be consumed by machines, not by humans? We want the numerical values of each pixel in the compressed image to remain as close as possible to the original numerical values.
Or is that simply out-of-scope for JPEG-XL?
Somes specific questions might be:
1. Which colorspace should I use when what matters is getting the numerical values correct (and the images will never be displayed on a monitor). We're using single channel, monochrome images.
2. Should we set `basic_info.uses_original_profile = JXL_TRUE` when doing lossy compression, if we want the numerical values in the compressed image to be as close as possible to the original values?
3. The satellite actually records 12 spectral channels (infrared, water vapour, etc.). We're currently planning to compress each channel individually as a monochrome image. Is that the right thing to do? Or should we try compressing the images 3 channels at a time? (Which would mean fibbing to JPEG-XL: We'd be pretending that we've got RGB images, even though none of the satellite channels correspond at all closely to red, green, or blue).
4. In [this comment](https://github.com/libjxl/libjxl/issues/314#issuecomment-880620569), @jonsneyers says "One option for lossy is to use lossy Modular mode in non-XYB mode (e.g. `cjxl -m -c 0 -q 90`), which is a 'stupid' (non-perceptual) form of lossy compression that treats the input numbers as just numbers without any perceptual interpretation." Is that the setting I should be using for satellite imagery? If so, how do we enable those settings using the C++ API instead of `cjxl`?
**Additional context**
This is for work that I'm doing at my non-profit, Open Climate Fix, on using satellite images and machine learning to improve near-term predictions of solar electricity power generation (here's [a good Wired article explaining our work](https://www.wired.co.uk/article/solar-weather-forecasting)). We use [Zarr](https://zarr.readthedocs.io/en/stable/) to save multiple TBytes of satellite imagery to disk. We're investigating using JPEG-XL as a "Zarr compressor" to compress each image chunk. We use the excellent [imagecodecs library](https://pypi.org/project/imagecodecs/) as a bridge between Python and JPEG-XL.
Related to issue #314 | Recommendations for compression of satellite images that will be read by machines (not humans) | https://api.github.com/repos/libjxl/libjxl/issues/1137/comments | 8 | 2022-01-31T11:20:42Z | 2022-03-11T14:47:31Z | https://github.com/libjxl/libjxl/issues/1137 | 1,119,299,719 | 1,137 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
test gif becomes black image after conversion
**To Reproduce**
cjxl 1.gif 1.jxl -d 0.0 -e 9
**Expected behavior**
lossless convertion with no color reduction
**Screenshots**
test image
**Environment**
- OS: Win11
- Compiler version: x64 ( GENERIC ) MinGW-w64 GC
- CPU type: x64
- cjxl/djxl version string :JPEG XL encoder v0.7.0 21da8c2 [SSE4,SSSE3,Scalar]
| 2 color GIF > JXL lossless = color reduction | https://api.github.com/repos/libjxl/libjxl/issues/1135/comments | 8 | 2022-01-30T02:27:01Z | 2022-02-14T00:56:18Z | https://github.com/libjxl/libjxl/issues/1135 | 1,118,386,403 | 1,135 |
[
"libjxl",
"libjxl"
] | **Is your feature request related to a problem? Please describe.**
Nope
**Describe the solution you'd like**
Use CUDA / OPENCL or Vulkan to accelerate encoding/decoding | Feat. req. Use CUDA / OpenCL / Vulkan | https://api.github.com/repos/libjxl/libjxl/issues/1134/comments | 6 | 2022-01-30T02:06:41Z | 2025-03-17T12:11:52Z | https://github.com/libjxl/libjxl/issues/1134 | 1,118,382,659 | 1,134 |
[
"libjxl",
"libjxl"
] | In some cases, for bandwidth sensitive applications, you may wish to control the amount of the progressive data that you fetch from the server with a byte range request.
Currently the decoder will notify you when a [full progression step is ready during decoding](https://libjxl.readthedocs.io/en/latest/api_decoder.html#_CPPv4N16JxlDecoderStatus25JXL_DEC_FRAME_PROGRESSIONE) but the same is not available during encoding so that an "index" of byte offsets of progression steps can be obtained such that range requests can be made.
After discussing in [Discord](https://discord.com/channels/794206087879852103/803574970180829194/936797163944550410) it was suggested this would be solved in two ways.
1. Add an api function to get byte offsets from the TOC after reading the frame header.
2. A detailed encoder return status that includes the offsets of LF and each HF scan.
The second suggestion would be particularly useful for generating metadata as the image is encoded that could be stored in a database or similar so that clients can make simple range requests toobject storage without first having to read the frame header. | Ability to determine byte offsets for each HF and LF scan during encoding or from TOC | https://api.github.com/repos/libjxl/libjxl/issues/1133/comments | 0 | 2022-01-29T09:48:10Z | 2022-04-08T10:03:07Z | https://github.com/libjxl/libjxl/issues/1133 | 1,118,156,755 | 1,133 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
Compilation warning is triggered on Debian buildds.
```
In file included from /usr/include/string.h:519,
from /<<PKGBUILDDIR>>/lib/jxl/base/padded_bytes.h:13,
from /<<PKGBUILDDIR>>/lib/jxl/color_management.h:16,
from /<<PKGBUILDDIR>>/lib/jxl/color_management.cc:6:
In function ‘void* memset(void*, int, size_t)’,
inlined from ‘jxl::Status jxl::MaybeCreateProfile(const jxl::ColorEncoding&, jxl::PaddedBytes*)’ at /<<PKGBUILDDIR>>/lib/jxl/color_management.cc:502:9:
/usr/include/aarch64-linux-gnu/bits/string_fortified.h:59:33: warning: ‘void* __builtin_memset(void*, int, long unsigned int)’ offset [0, 3] is out of the bounds [0, 0] [-Warray-bounds]
59 | return __builtin___memset_chk (__dest, __ch, __len,
| ~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~
60 | __glibc_objsize0 (__dest));
| ~~~~~~~~~~~~~~~~~~~~~~~~~~
In function ‘void* memset(void*, int, size_t)’,
inlined from ‘jxl::Status jxl::MaybeCreateProfile(const jxl::ColorEncoding&, jxl::PaddedBytes*)’ at /<<PKGBUILDDIR>>/lib/jxl/color_management.cc:503:9:
/usr/include/aarch64-linux-gnu/bits/string_fortified.h:59:33: warning: ‘void* __builtin_memset(void*, int, long unsigned int)’ offset [0, 3] is out of the bounds [0, 0] [-Warray-bounds]
59 | return __builtin___memset_chk (__dest, __ch, __len,
| ~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~
60 | __glibc_objsize0 (__dest));
| ~~~~~~~~~~~~~~~~~~~~~~~~~~
```
**To Reproduce**
Follow steps from
* https://buildd.debian.org/status/fetch.php?pkg=jpeg-xl&arch=ppc64el&ver=0.7.0%7Egit20220120.0647da4%2Bds-1&stamp=1642703759&raw=0
**Expected behavior**
Would be nice to remove the warning
**Screenshots**
See link above.
**Environment**
- OS: Debian/Linux
- Compiler version: gcc-11
- CPU type: amr64
- cjxl/djxl version string: git/master 0647da4
| error: 'void* memset(void*, int, size_t)' offset [0, 3] is out of the bounds [0, 0] [-Werror=array-bounds] | https://api.github.com/repos/libjxl/libjxl/issues/1122/comments | 2 | 2022-01-26T15:35:43Z | 2022-03-11T15:03:07Z | https://github.com/libjxl/libjxl/issues/1122 | 1,115,159,667 | 1,122 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
While decoding an image using UInt32 Buffers, i get a non- JXL_DEC_SUCCESS result from JxlDecoderImageOutBufferSize.
decoding with UInt8, UInt16 and Float32 works as expected, only UInt32 doesn't
**To Reproduce**
compile wasm32 with a emscripten executable wrapper then try and decode an image using JXL_TYPE_UINT32 pixel type.
**Expected behavior**
it returns a successful decoded pixel buffer.
**Screenshots**
**Environment**
- OS: -
- Compiler version: clang-13 (emscripten)
- CPU type: wasm_x32 [no SIMD]
- browser: known firefox & chrome
**Additional context**
CPPCode => https://github.com/KoromaruKoruko/libjxl/blob/main/lib/wasm_extras/dec_extras.cc
JSCODE (Ran in console, after loading wasm wrapper)
| UInt32 Buffers, JxlDecoderImageOutBufferSize != JXL_DEC_SUCCESS | https://api.github.com/repos/libjxl/libjxl/issues/1116/comments | 0 | 2022-01-24T18:30:17Z | 2022-04-08T10:01:01Z | https://github.com/libjxl/libjxl/issues/1116 | 1,112,998,532 | 1,116 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
Manjaro gives an error when building this package.
```
Building libjxl-git...
==> Making package: libjxl-git 0.3.7.r777.g36ece47-1 (Thu 20 Jan 2022 09:26:43 AM CST)
...
[ 54%] Building CXX object lib/CMakeFiles/ac_strategy_test.dir/jxl/ac_strategy_test.cc.o
In file included from /var/tmp/pamac-build-doklovic/libjxl-git/src/libjxl/lib/jxl/ac_strategy_test.cc:13:
/usr/include/hwy/tests/test_util-inl.h:448:3: error: statement not allowed in constexpr function
HWY_ASSERT(max_pow2 != 0);
^
/usr/include/hwy/base.h:144:3: note: expanded from macro 'HWY_ASSERT'
do { \
^
1 error generated.
make[2]: *** [lib/CMakeFiles/ac_strategy_test.dir/build.make:76: lib/CMakeFiles/ac_strategy_test.dir/jxl/ac_strategy_test.cc.o] Error 1
make[2]: Leaving directory '/var/tmp/pamac-build-doklovic/libjxl-git/src/build'
make[1]: *** [CMakeFiles/Makefile2:1764: lib/CMakeFiles/ac_strategy_test.dir/all] Error 2
make[1]: Leaving directory '/var/tmp/pamac-build-doklovic/libjxl-git/src/build'
make: *** [Makefile:146: all] Error 2
make: Leaving directory '/var/tmp/pamac-build-doklovic/libjxl-git/src/build'
```
**To Reproduce**
Just try to update the AUR package using the software update tool in Manjaro
**Expected behavior**
it builds without error
**Environment**
- Distributor ID: ManjaroLinux
- Description: Manjaro Linux
- Release: 21.2.1
- Codename: Qonos
- 5.10.89-1-MANJARO
| Broken build on Manjaro with 0.3.7.r777.g36ece47-1 | https://api.github.com/repos/libjxl/libjxl/issues/1109/comments | 6 | 2022-01-20T15:44:12Z | 2022-04-08T07:10:37Z | https://github.com/libjxl/libjxl/issues/1109 | 1,109,461,963 | 1,109 |
[
"libjxl",
"libjxl"
] | First of all: I did not test libjxl directly, but through its implementation in Irfanview and XnViewMP.
**Describe the bug**
Unfortunately memory consumption goes through the roof for JXL encoding and decoding.
Encoding a 19200 x 25200 px image of 1.35 gb uncompressed TIFF size uses more than my 16 gb for encoding and thus needs to make heavy use of the pagefile to finish.
Decoding the image peaks at over 12 gb, while decoding the same as TIFF or PNG only hits a peak of about 1.35 gb and JPEG a peak of about 2.3 gb.
**To Reproduce**
Encode/Decode (uncompressed) 1.35 gb large image file (19200 x 25200 px).
**Expected behavior**
Should not use over 10 times the memory size of the original image to encode, maybe 2-3 times max. Should not use close to 10 times the memory size to decode.
**Screenshots**
https://i.imgur.com/oB6Nc6N.png
**Environment**
- OS: Windows 11
- CPU type: 5900X
| Memory consumption extremely high? | https://api.github.com/repos/libjxl/libjxl/issues/1106/comments | 8 | 2022-01-19T11:32:38Z | 2024-04-17T08:46:45Z | https://github.com/libjxl/libjxl/issues/1106 | 1,107,989,605 | 1,106 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
Unable to build Wasm32 artifacts using the docker container as the CMAKE_FLAGS environment variable containing `-I/usr/wasm32/include` is not in the documented build commands.
**To Reproduce**
Steps to reproduce the behavior:
Attempt to build the wasm32 artifact using the docker container detailed in https://github.com/libjxl/libjxl/blob/main/doc/building_wasm.md
**Expected behavior**
It builds.
**Actual behavior**
It does not build because it cannot find the libraries jpeglib.h and gif_lib.h in /usr/wasm32/include.
**Environment**
- OS: gcr.io/jpegxl/jpegxl-builder@sha256:8cbbadbcd7ed58f1cdf549721e0b0597b9891d82b387ae439b9d7d44ecf4ef4b
- Compiler version: Provided version
- CPU type: x86_64
PR #1104 | Can't build wasm32 artifacts using default build commands in docker container | https://api.github.com/repos/libjxl/libjxl/issues/1105/comments | 1 | 2022-01-19T03:32:35Z | 2022-01-23T08:30:51Z | https://github.com/libjxl/libjxl/issues/1105 | 1,107,601,635 | 1,105 |
[
"libjxl",
"libjxl"
] | I have a lot of very large lossless images, and the GdkPixbuf loader seems to be much, much slower (roughly 4-5x) than the PNG and WebP loaders (for the same images). I believe this to be a relatively recent issue, as I remember it used to be much faster, on par with the PNG and WebP loaders. (perhaps several months ago)
Using a git master build of the plugin, at the time of writing.
It should be noted that this issue only seems to be present for lossless JXLs, and that it seems limited to the GdkPixbuf loader, as there doesn't seem to be any loading speed issue with the libjxl library or the Qt6 plugin I have. | GdkPixbuf loader is extremely slow for lossless images | https://api.github.com/repos/libjxl/libjxl/issues/1097/comments | 4 | 2022-01-14T21:50:11Z | 2025-05-17T11:11:44Z | https://github.com/libjxl/libjxl/issues/1097 | 1,104,153,280 | 1,097 |
[
"libjxl",
"libjxl"
] | I followed the build steps described in this site:
http://blog.fpliu.com/project/ndk-pkg/package?name=libjxl
I modified the formula as this:
build() {
cmakew \
-DJPEGXL_ENABLE_JNI=OFF \
-DJPEGXL_ENABLE_TOOLS=OFF \
-DJPEGXL_ENABLE_EXAMPLES=ON \
-DJPEGXL_ENABLE_MANPAGES=ON \
-DJPEGXL_ENABLE_BENCHMARK=OFF \
-DJPEGXL_WARNINGS_AS_ERRORS=OFF \
-DJPEGXL_FORCE_SYSTEM_BROTLI=ON \
-DJPEGXL_VERSION=$PACKAGE_VERSION \
-DZLIB_INCLUDE_DIR="$zlib_INCLUDE_DIR" \
-DZLIB_LIBRARY_RELEASE="$zlib_LIBRARY_DIR/libz.a" \
-DPNG_PNG_INCLUDE_DIR="$libpng_INCLUDE_DIR" \
-DPNG_LIBRARY="$libpng_LIBRARY_DIR/libpng.a" \
-DJPEG_INCLUDE_DIR="$libjpeg_turbo_INCLUDE_DIR" \
-DJPEG_LIBRARY="$libjpeg_turbo_LIBRARY_DIR/libjpeg.a"\
-DTIFF_INCLUDE_DIR="$libtiff_INCLUDE_DIR" \
-DTIFF_LIBRARY="$libtiff_LIBRARY_DIR/libtiff.a" \
-DGIF_INCLUDE_DIR="$giflib_INCLUDE_DIR" \
-DGIF_LIBRARY="$giflib_LIBRARY_DIR/libgif.a"\
-DJPEGXL_STATIC=ON
}
And got the error:
FAILED: encode_oneshot
: && /home/osboxes/.ndk-pkg/android-ndk-r23b/toolchains/llvm/prebuilt/linux-x86_64/bin/clang++ --target=armv7-none-linux-androideabi21 --sysroot=/home/osboxes/.ndk-pkg/android-ndk-r23b/toolchains/llvm/prebuilt/linux-x86_64/sysroot --sysroot /home/osboxes/.ndk-pkg/android-ndk-r23b/toolchains/llvm/prebuilt/linux-x86_64/sysroot -Qunused-arguments -fpic -Wl,--dynamic-linker=/system/bin/linker -Wl,--strip-debug -Os -DNDEBUG -I/home/osboxes/.ndk-pkg/install.d/brotli/armeabi-v7a/include -I/home/osboxes/.ndk-pkg/install.d/libwebp/armeabi-v7a/include -I/home/osboxes/.ndk-pkg/install.d/libpng/armeabi-v7a/include -I/home/osboxes/.ndk-pkg/install.d/libtiff/armeabi-v7a/include -I/home/osboxes/.ndk-pkg/install.d/zstd/armeabi-v7a/include -I/home/osboxes/.ndk-pkg/install.d/xz/armeabi-v7a/include -I/home/osboxes/.ndk-pkg/install.d/libjpeg-turbo/armeabi-v7a/include -I/home/osboxes/.ndk-pkg/install.d/giflib/armeabi-v7a/include -I/home/osboxes/.ndk-pkg/install.d/openexr/armeabi-v7a/include -I/home/osboxes/.ndk-pkg/install.d/imath/armeabi-v7a/include -I/home/osboxes/.ndk-pkg/install.d/zlib/armeabi-v7a/include --sysroot /home/osboxes/.ndk-pkg/android-ndk-r23b/toolchains/llvm/prebuilt/linux-x86_64/sysroot -Qunused-arguments -I/home/osboxes/.ndk-pkg/android-ndk-r23b/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/include/arm-linux-androideabi -include /tmp/tmp.Z14bZixPtv/1642154864/include.h -L/home/osboxes/.ndk-pkg/install.d/brotli/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/libwebp/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/libpng/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/libtiff/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/zstd/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/xz/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/libjpeg-turbo/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/giflib/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/openexr/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/imath/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/zlib/armeabi-v7a/lib --sysroot /home/osboxes/.ndk-pkg/android-ndk-r23b/toolchains/llvm/prebuilt/linux-x86_64/sysroot -L/tmp/tmp.Z14bZixPtv/1642154864 -L/home/osboxes/.ndk-pkg/android-ndk-r23b/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/lib/arm-linux-androideabi/21 -Wl,--dynamic-linker=/system/bin/linker -Wl,--strip-debug -funwind-tables -Xclang -mrelax-all -Xclang -mconstructor-aliases -fno-omit-frame-pointer -O3 -DNDEBUG -O2 -Wl,--build-id=sha1 -Wl,--no-rosegment -Wl,--fatal-warnings -Qunused-arguments -Wl,--no-undefined -Wl,--gc-sections -L/home/osboxes/.ndk-pkg/install.d/brotli/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/libwebp/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/libpng/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/libtiff/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/zstd/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/xz/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/libjpeg-turbo/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/giflib/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/openexr/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/imath/armeabi-v7a/lib -L/home/osboxes/.ndk-pkg/install.d/zlib/armeabi-v7a/lib --sysroot /home/osboxes/.ndk-pkg/android-ndk-r23b/toolchains/llvm/prebuilt/linux-x86_64/sysroot -L/tmp/tmp.Z14bZixPtv/1642154864 -L/home/osboxes/.ndk-pkg/android-ndk-r23b/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/lib/arm-linux-androideabi/21 -Wl,--dynamic-linker=/system/bin/linker -Wl,--strip-debug -static -static-libgcc -static-libstdc++ -R/home/osboxes/.ndk-pkg/install.d/brotli/armeabi-v7a/lib -fPIE -pie CMakeFiles/encode_oneshot.dir/examples/encode_oneshot.cc.o -o encode_oneshot lib/libjxl.a lib/libjxl_threads.a third_party/highway/libhwy.a -Wl,--whole-archive -lpthread -Wl,--no-whole-archive -static-libstdc++ -latomic -lm && :
ld: error: undefined symbol: BrotliEncoderCreateInstance
>>> referenced by enc_jpeg_data.cc
>>> enc_jpeg_data.cc.o:(jxl::jpeg::EncodeJPEGData(jxl::jpeg::JPEGData&, jxl::PaddedBytes*)) in archive lib/libjxl.a
ld: error: undefined symbol: BrotliEncoderSetParameter
>>> referenced by enc_jpeg_data.cc
>>> enc_jpeg_data.cc.o:(jxl::jpeg::EncodeJPEGData(jxl::jpeg::JPEGData&, jxl::PaddedBytes*)) in archive lib/libjxl.a
>>> referenced by enc_jpeg_data.cc
>>> enc_jpeg_data.cc.o:(jxl::jpeg::EncodeJPEGData(jxl::jpeg::JPEGData&, jxl::PaddedBytes*)) in archive lib/libjxl.a
ld: error: undefined symbol: BrotliEncoderMaxCompressedSize
>>> referenced by enc_jpeg_data.cc
>>> enc_jpeg_data.cc.o:(jxl::jpeg::EncodeJPEGData(jxl::jpeg::JPEGData&, jxl::PaddedBytes*)) in archive lib/libjxl.a
ld: error: undefined symbol: BrotliEncoderCompressStream
>>> referenced by enc_jpeg_data.cc
>>> enc_jpeg_data.cc.o:(jxl::jpeg::EncodeJPEGData(jxl::jpeg::JPEGData&, jxl::PaddedBytes*)) in archive lib/libjxl.a
>>> referenced by enc_jpeg_data.cc
>>> enc_jpeg_data.cc.o:(jxl::jpeg::EncodeJPEGData(jxl::jpeg::JPEGData&, jxl::PaddedBytes*)) in archive lib/libjxl.a
>>> referenced by enc_jpeg_data.cc
>>> enc_jpeg_data.cc.o:(jxl::jpeg::EncodeJPEGData(jxl::jpeg::JPEGData&, jxl::PaddedBytes*)) in archive lib/libjxl.a
>>> referenced 1 more times
ld: error: undefined symbol: BrotliEncoderHasMoreOutput
>>> referenced by enc_jpeg_data.cc
>>> enc_jpeg_data.cc.o:(jxl::jpeg::EncodeJPEGData(jxl::jpeg::JPEGData&, jxl::PaddedBytes*)) in archive lib/libjxl.a
>>> referenced by enc_jpeg_data.cc
>>> enc_jpeg_data.cc.o:(jxl::jpeg::EncodeJPEGData(jxl::jpeg::JPEGData&, jxl::PaddedBytes*)) in archive lib/libjxl.a
>>> referenced by enc_jpeg_data.cc
>>> enc_jpeg_data.cc.o:(jxl::jpeg::EncodeJPEGData(jxl::jpeg::JPEGData&, jxl::PaddedBytes*)) in archive lib/libjxl.a
>>> referenced 1 more times
ld: error: undefined symbol: BrotliEncoderDestroyInstance
| Cannot buid with -DJPEGXL_STATIC=ON for android | https://api.github.com/repos/libjxl/libjxl/issues/1096/comments | 2 | 2022-01-14T10:12:02Z | 2024-03-04T10:12:36Z | https://github.com/libjxl/libjxl/issues/1096 | 1,103,405,320 | 1,096 |
[
"libjxl",
"libjxl"
] | **Is your feature request related to a problem? Please describe.**
I'm trying to (batch) convert images without discarding their EXIF info. Neither Exiftool nor Exiv2 are currently able to modify the raw JXL files cjxl outputs, but they support the containerized JXL files. I am not able to use JXL without metadata support in my workflow.
**Describe the solution you'd like**
I'd like to add "-iso" or "-bmff" option to cjxl that would add the 40 byte ISO BMFF header to output JXL files.
**Describe alternatives you've considered**
I have tried prepending the header manually. There is also value indicating JXL stream size (jxlc), which seems to be ignored, but I am not sure if could cause problems with other/future software if it is not set correctly.
**Additional context**
I have tried mostly free Windows software with JXL support, but they are just using cjxl or libjxl and produce the same raw JXL files. Gimp JXL plugin supports ISO BMFF, but the plugin windows binary is not publicly available and it seems difficult to use Gimp in batch processing scripts.
I do not know of any current Windows software supporting JXL to be able to output JXL in ISO BMFF container. This makes easy task like saving/copying/editing EXIF info into mission impossible even for advanced users.
There are also some reports, that JXL files inside ISO BMFF containers might be more widely supported (https://teddit.sethforprivacy.com/r/jpegxl/comments/pr2sk6/facebook_now_seems_to_accept_jpeg_xl_image_uploads/hdg252q/?context=10)
| Add cjxl option to output JXL inside ISO BMFF container file | https://api.github.com/repos/libjxl/libjxl/issues/1092/comments | 3 | 2022-01-13T13:57:04Z | 2022-03-11T18:23:54Z | https://github.com/libjxl/libjxl/issues/1092 | 1,101,781,578 | 1,092 |
[
"libjxl",
"libjxl"
] | **Describe the bug**
`cjxl` reports a confusing error message for JPEG using arithmetic coding (instead of default huffman).
```
% cjxl black.jpg black.jxl
JPEG XL encoder v0.6.1 086a674 [AVX2,SSE4,Scalar]
Corrupt or CMYK JPEG.
Failed to read image black.jpg.
```
**To Reproduce**
```
$ convert -size 512x512 -depth 8 xc:black black.pgm
$ cjpeg -arithmetic -quality 100 -grayscale -outfile black.jpg black.pgm
$ cjxl black.jpg black.jxl
```
**Expected behavior**
I've reported this issue under "bug" section. This is not clear why arithmetic coding is not supported in cjxl code path (no remaining legal restrictions on arithmetic coding AFAIK).
So either:
1. Improve the error message in this case, or
2. ~~Implement proper support for SOF9 marker~~ (cannot be implemented by design JPEG-XL)
**Environment**
- OS: Linux Debian/sid
- cjxl/djxl version string: Default Debian package (from experimental section) on amd64
| SOF9 Arithmetic Extended Sequential DCT => Corrupt or CMYK JPEG | https://api.github.com/repos/libjxl/libjxl/issues/1088/comments | 7 | 2022-01-12T10:15:45Z | 2022-03-21T08:07:52Z | https://github.com/libjxl/libjxl/issues/1088 | 1,100,149,693 | 1,088 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.