Dear maintainer,
I missed to include some files in the diff, sorry for that, the
updated attached patch would be the correct one to look at as example
for updating the packaging to 0.10.1.
With best regards,
Julian Wollrath
--
() ascii ribbon campaign - against html e-mail
/\ - against proprietary attachments
diff --git a/debian/changelog b/debian/changelog
index 98ba746..b45cf38 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,12 @@
+jpeg-xl (0.10.1-0.1) UNRELEASED; urgency=medium
+
+ * Non-maintainer upload.
+ * New upstream version 0.10.1
+ * Build GDK pixbuf plugin. Closes: #1001786
+ * Build libjpegli. Closes: #1041234
+
+ -- Julian Wollrath <jwollr...@web.de> Sun, 03 Mar 2024 11:38:22 +0100
+
jpeg-xl (0.8.2-1) experimental; urgency=medium
* New upstream version 0.8.2
diff --git a/debian/cjpeg_hdr.1.in b/debian/cjpeg_hdr.1.in
deleted file mode 100644
index 382fb1e..0000000
--- a/debian/cjpeg_hdr.1.in
+++ /dev/null
@@ -1,81 +0,0 @@
-[NAME]
-cjpeg_hdr - cjpeg_hdr
-
-[DESCRIPTION]
-# High bit depth JPEG encoder
-`cjpeg_hdr` is an (experimental) JPEG encoder that can preserve a higher bit
-depth than a traditional JPEG encoder. In particular, it may be used to produce
-HDR JPEGs that do not show obvious signs of banding.
-
-Note that at this point in time `cjpeg_hdr` does not attempt to actually
-*compress* the image - it behaves in the same way as a "quality 100" JPEG
-encoder would normally do, i.e. no quantization, to achieve the maximum
-possible visual quality. Moreover, no Huffman optimization is performed.
-
-## Generating HBD JPEGs
-Note: this and the following sections assume that `libjxl` has been built in
-the `build/` directory, either by using CMake or by running `./ci.sh opt`.
-
-It should be sufficient to run `build/tools/cjpeg_hdr input_image output.jpg`.
-Various input formats are supported, including NetBPM and (8- or 16-bit) PNG.
-
-If the PNG image includes a colour profile, it will be copied in the resulting
-JPEG image. If this colour profile approximates the PQ or HLG transfer curves,
-some applications will consider the resulting image to be HDR.
-
-To attach a PQ profile to an image without a colour profile (or with a
-different colour profile), the following command can be used:
-
-```
- build/tools/decode_and_encode input RGB_D65_202_Rel_PeQ output_with_pq.png 16
-```
-
-Similarly, to attach an HLG profile, the following command can be used
-
-```
- build/tools/decode_and_encode input RGB_D65_202_Rel_HLG output_with_pq.png 16
-```
-
-## Decoding HBD JPEGs
-HBD JPEGs are fully retrocompatible with libjpeg, and any JPEG viewer ought to
-be able to visualize them. Nonetheless, to achieve the best visual quality, a
-high bit depth decoder should be used.
-
-Such a decoder does not exist today. As a workaround, it is possible to do a
-lossless conversion to JPEG XL and then view the resulting image:
-
-```
- build/tools/cjxl --jpeg_transcode_disable_cfl hbd.jpeg hbd.jxl
-```
-
-The resulting JPEG XL file can be visualized, for example, in a browser,
-assuming that the corresponding flag is enabled in the settings.
-
-In particular, if the HBD JPEG has a PQ or HLG profile attached and the current
-display is an HDR display, Chrome ought to visualize the image as HDR content.
-
-It is also possible to convert the JPEG XL file back to a 16-bit PNG:
-
-```
- build/tools/djxl hbd.jxl --bits_per_sample=16 output.png
-```
-
-Note however that as of today (2 Nov 2021) Chrome does not interpret such a PNG
-as an HDR image, even if a PQ or HLG profile is attached. Thus, to display the
-HDR image correctly it is recommended to either display the JPEG XL image
-directly or to convert the PNG to a format that Chrome interprets as HDR, such
-as AVIF. This can be done with the following command for a PQ image:
-
-```
- avifenc -l -y 444 --depth 10 --cicp 9/16/9 image.png output.avif
-```
-
-and the following one for an HLG image:
-
-```
- avifenc -l -y 444 --depth 10 --cicp 9/18/9 image.png output.avif
-```
-
-[AUTHOR]
-This manual page was written by Mathieu Malaterre <ma...@debian.org> for the
-Debian GNU/Linux system (but may be used by others).
diff --git a/debian/fuzzer_corpus.1.in b/debian/cjpegli.1.in
similarity index 83%
rename from debian/fuzzer_corpus.1.in
rename to debian/cjpegli.1.in
index 0a307b9..93416bb 100644
--- a/debian/fuzzer_corpus.1.in
+++ b/debian/cjpegli.1.in
@@ -1,5 +1,5 @@
[NAME]
-fuzzer_corpus - fuzzer_corpus
+cjpegli - cjpegli
[AUTHOR]
This manual page was written by Mathieu Malaterre <ma...@debian.org> for the
diff --git a/debian/control b/debian/control
index fd9dce2..a776af3 100644
--- a/debian/control
+++ b/debian/control
@@ -12,6 +12,7 @@ Build-Depends: asciidoc-base,
help2man,
libavif-dev (>= 0.10.1),
libbrotli-dev,
+ libgdk-pixbuf-2.0-dev,
libgflags-dev,
libgif-dev (>= 5.1),
libgmock-dev <!nocheck>,
@@ -25,7 +26,7 @@ Build-Depends: asciidoc-base,
libpng-dev,
libwebp-dev (>= 1.3),
ninja-build,
- pkg-config
+ pkgconf
Build-Depends-Indep: doxygen, graphviz
Homepage: https://github.com/libjxl/libjxl
Vcs-Git: https://salsa.debian.org/debian-phototools-team/libjxl.git
@@ -52,7 +53,7 @@ Architecture: any
Section: libdevel
Depends: libbrotli-dev,
libhwy-dev,
- libjxl0.8 (= ${binary:Version}),
+ libjxl0.10 (= ${binary:Version}),
liblcms-dev,
${misc:Depends}
Multi-Arch: same
@@ -65,7 +66,7 @@ Description: JPEG XL Image Coding System - "JXL" (development files)
.
This package installs development files.
-Package: libjxl0.8
+Package: libjxl0.10
Architecture: any
Multi-Arch: same
Section: libs
@@ -107,6 +108,16 @@ Description: JPEG XL Image Coding System - "JXL" (dev command line utility)
.
This package installs the devtools command line utilities.
+Package: libjxl-gdk-pixbuf
+Architecture: any
+Multi-Arch: same
+Section: libs
+Depends: ${misc:Depends}, ${shlibs:Depends}
+Pre-Depends: ${misc:Pre-Depends}
+Description: JPEG XL Plugin for gdk-pixbuf
+ This package installs the required files for reading JPEG XL files in
+ GTK applications.
+
Package: libjpegxl-java
Architecture: amd64 arm64 armel armhf i386 mips64el ppc64el riscv64 s390x alpha ia64 m68k powerpc ppc64 sh4 sparc64 x32
Section: java
@@ -120,3 +131,50 @@ Description: JPEG XL Image Coding System - "JXL" (java bindings)
several features that help transition from the legacy JPEG format.
.
This package installs the Java Bindings.
+
+Package: libjpegli62
+Architecture: any
+Multi-Arch: same
+Section: libs
+Depends: ${misc:Depends}, ${shlibs:Depends}
+Pre-Depends: ${misc:Pre-Depends}
+Conflicts: libjpeg62, libjpeg62-turbo
+Replaces: libjpeg62, libjpeg62-turbo
+Provides: libjpeg62-turbo (= 1:2.0.2)
+Description: Improved JPEG encoder and decoder implementation (shared libraries)
+ JPEGLIS provides a JPEG encoder and decoder implementation that is
+ API and ABI compatible with libjpeg62.
+ .
+ This package installs jpegli shared libraries.
+
+Package: libjpegli62-dev
+Architecture: any
+Section: libdevel
+Multi-Arch: same
+Depends: libc-dev, libjpegli62 (= ${binary:Version}), ${misc:Depends}
+Conflicts: libjpeg62-dev,
+ libjpeg62-turbo-dev,
+ libjpeg7-dev,
+ libjpeg8-dev,
+ libjpeg9-dev
+Replaces: libjpeg62-dev,
+ libjpeg62-turbo-dev,
+ libjpeg7-dev,
+ libjpeg8-dev,
+ libjpeg9-dev
+Provides: libjpeg-dev
+Description: Improved JPEG encoder and decoder implementation (development files)
+ JPEGLIS provides a JPEG encoder and decoder implementation that is
+ API and ABI compatible with libjpeg62.
+ .
+ This package installs jpegli jpeg62 headers.
+
+Package: libjpegli-tools
+Architecture: any
+Section: utils
+Depends: ${misc:Depends}, ${shlibs:Depends}
+Description: Improved JPEG encoder and decoder implementation (command line utility)
+ JPEGLIS provides a JPEG encoder and decoder implementation that is
+ API and ABI compatible with libjpeg62.
+ .
+ This package installs the JPEGLI tools command line utilities.
diff --git a/debian/control.in b/debian/control.in
index c2e3117..ef9f0c4 100644
--- a/debian/control.in
+++ b/debian/control.in
@@ -12,6 +12,7 @@ Build-Depends: asciidoc-base,
help2man,
libavif-dev (>= 0.10.1),
libbrotli-dev,
+ libgdk-pixbuf-2.0-dev,
libgflags-dev,
libgif-dev (>= 5.1),
libgmock-dev <!nocheck>,
@@ -25,7 +26,7 @@ Build-Depends: asciidoc-base,
libpng-dev,
libwebp-dev (>= 1.3),
ninja-build,
- pkg-config
+ pkgconf
Build-Depends-Indep: doxygen, graphviz
Homepage: https://github.com/libjxl/libjxl
Vcs-Git: https://salsa.debian.org/debian-phototools-team/libjxl.git
@@ -52,7 +53,7 @@ Architecture: any
Section: libdevel
Depends: libbrotli-dev,
libhwy-dev,
- libjxl0.8 (= ${binary:Version}),
+ libjxl0.10 (= ${binary:Version}),
liblcms-dev,
${misc:Depends}
Multi-Arch: same
@@ -65,7 +66,7 @@ Description: JPEG XL Image Coding System - "JXL" (development files)
.
This package installs development files.
-Package: libjxl0.8
+Package: libjxl0.10
Architecture: any
Multi-Arch: same
Section: libs
@@ -107,6 +108,16 @@ Description: JPEG XL Image Coding System - "JXL" (dev command line utility)
.
This package installs the devtools command line utilities.
+Package: libjxl-gdk-pixbuf
+Architecture: any
+Multi-Arch: same
+Section: libs
+Depends: ${misc:Depends}, ${shlibs:Depends}
+Pre-Depends: ${misc:Pre-Depends}
+Description: JPEG XL Plugin for gdk-pixbuf
+ This package installs the required files for reading JPEG XL files in
+ GTK applications.
+
Package: libjpegxl-java
Architecture: @JAVA_ARCHS@
Section: java
@@ -120,3 +131,50 @@ Description: JPEG XL Image Coding System - "JXL" (java bindings)
several features that help transition from the legacy JPEG format.
.
This package installs the Java Bindings.
+
+Package: libjpegli62
+Architecture: any
+Multi-Arch: same
+Section: libs
+Depends: ${misc:Depends}, ${shlibs:Depends}
+Pre-Depends: ${misc:Pre-Depends}
+Conflicts: libjpeg62, libjpeg62-turbo
+Replaces: libjpeg62, libjpeg62-turbo
+Provides: libjpeg62-turbo (= 1:2.0.2)
+Description: Improved JPEG encoder and decoder implementation (shared libraries)
+ JPEGLIS provides a JPEG encoder and decoder implementation that is
+ API and ABI compatible with libjpeg62.
+ .
+ This package installs jpegli shared libraries.
+
+Package: libjpegli62-dev
+Architecture: any
+Section: libdevel
+Multi-Arch: same
+Depends: libc-dev, libjpegli62 (= ${binary:Version}), ${misc:Depends}
+Conflicts: libjpeg62-dev,
+ libjpeg62-turbo-dev,
+ libjpeg7-dev,
+ libjpeg8-dev,
+ libjpeg9-dev
+Replaces: libjpeg62-dev,
+ libjpeg62-turbo-dev,
+ libjpeg7-dev,
+ libjpeg8-dev,
+ libjpeg9-dev
+Provides: libjpeg-dev
+Description: Improved JPEG encoder and decoder implementation (development files)
+ JPEGLIS provides a JPEG encoder and decoder implementation that is
+ API and ABI compatible with libjpeg62.
+ .
+ This package installs jpegli jpeg62 headers.
+
+Package: libjpegli-tools
+Architecture: any
+Section: utils
+Depends: ${misc:Depends}, ${shlibs:Depends}
+Description: Improved JPEG encoder and decoder implementation (command line utility)
+ JPEGLIS provides a JPEG encoder and decoder implementation that is
+ API and ABI compatible with libjpeg62.
+ .
+ This package installs the JPEGLI tools command line utilities.
diff --git a/debian/djpegli.1.in b/debian/djpegli.1.in
new file mode 100644
index 0000000..851047b
--- /dev/null
+++ b/debian/djpegli.1.in
@@ -0,0 +1,6 @@
+[NAME]
+djpegli - djpegli
+
+[AUTHOR]
+This manual page was written by Mathieu Malaterre <ma...@debian.org> for the
+Debian GNU/Linux system (but may be used by others).
diff --git a/debian/libjpegli-tools.install b/debian/libjpegli-tools.install
new file mode 100644
index 0000000..d5e6af8
--- /dev/null
+++ b/debian/libjpegli-tools.install
@@ -0,0 +1,2 @@
+usr/bin/cjpegli
+usr/bin/djpegli
diff --git a/debian/libjpegli-tools.manpages b/debian/libjpegli-tools.manpages
new file mode 100644
index 0000000..af23b77
--- /dev/null
+++ b/debian/libjpegli-tools.manpages
@@ -0,0 +1,2 @@
+debian/cjpegli.1
+debian/djpegli.1
diff --git a/debian/libjpegli62-dev.install b/debian/libjpegli62-dev.install
new file mode 100644
index 0000000..97516eb
--- /dev/null
+++ b/debian/libjpegli62-dev.install
@@ -0,0 +1 @@
+usr/lib/*/libjpeg*.so
diff --git a/debian/libjpegli62.install b/debian/libjpegli62.install
new file mode 100644
index 0000000..5dd0e11
--- /dev/null
+++ b/debian/libjpegli62.install
@@ -0,0 +1 @@
+usr/lib/*/libjpeg*.so.*
diff --git a/debian/libjpegli62.lintian-overrides b/debian/libjpegli62.lintian-overrides
new file mode 100644
index 0000000..16a95b1
--- /dev/null
+++ b/debian/libjpegli62.lintian-overrides
@@ -0,0 +1,2 @@
+# Debian has libjpeg62 and it's IJG libjpeg, this one is libjpegli...
+libjpegli62: package-name-doesnt-match-sonames libjpeg62
diff --git a/debian/libjxl-devtools.install b/debian/libjxl-devtools.install
index 7fdd98e..8e90896 100644
--- a/debian/libjxl-devtools.install
+++ b/debian/libjxl-devtools.install
@@ -2,7 +2,6 @@ usr/bin/benchmark_xl
usr/bin/butteraugli_main
usr/bin/decode_and_encode
usr/bin/display_to_hlg
-usr/bin/fuzzer_corpus
usr/bin/generate_lut_template
usr/bin/jxl_from_tree
usr/bin/pq_to_hlg
diff --git a/debian/libjxl-devtools.manpages b/debian/libjxl-devtools.manpages
index f9239df..04fccbf 100644
--- a/debian/libjxl-devtools.manpages
+++ b/debian/libjxl-devtools.manpages
@@ -2,7 +2,6 @@ debian/benchmark_xl.1
debian/butteraugli_main.1
debian/decode_and_encode.1
debian/display_to_hlg.1
-debian/fuzzer_corpus.1
debian/generate_lut_template.1
debian/jxl_from_tree.1
debian/pq_to_hlg.1
diff --git a/debian/libjxl-gdk-pixbuf.install b/debian/libjxl-gdk-pixbuf.install
new file mode 100644
index 0000000..91a4d49
--- /dev/null
+++ b/debian/libjxl-gdk-pixbuf.install
@@ -0,0 +1,2 @@
+usr/lib/*/gdk-pixbuf-*/*/loaders/*
+usr/share/thumbnailers/jxl.thumbnailer
diff --git a/debian/libjxl-gdk-pixbuf.postinst b/debian/libjxl-gdk-pixbuf.postinst
new file mode 100644
index 0000000..d48bb7a
--- /dev/null
+++ b/debian/libjxl-gdk-pixbuf.postinst
@@ -0,0 +1,3 @@
+#!/bin/sh -e
+/usr/lib/x86_64-linux-gnu/gdk-pixbuf-2.0/gdk-pixbuf-query-loaders --update-cache
+#DEBHELPER#
diff --git a/debian/libjxl-gdk-pixbuf.postrm b/debian/libjxl-gdk-pixbuf.postrm
new file mode 100644
index 0000000..7d6f4c7
--- /dev/null
+++ b/debian/libjxl-gdk-pixbuf.postrm
@@ -0,0 +1,5 @@
+#!/bin/sh -e
+if [ -x /usr/lib/x86_64-linux-gnu/gdk-pixbuf-2.0/gdk-pixbuf-query-loaders ]; then
+ /usr/lib/x86_64-linux-gnu/gdk-pixbuf-2.0/gdk-pixbuf-query-loaders --update-cache
+fi
+#DEBHELPER#
diff --git a/debian/libjxl-tools.install b/debian/libjxl-tools.install
index 3da963a..cd5227b 100644
--- a/debian/libjxl-tools.install
+++ b/debian/libjxl-tools.install
@@ -1,4 +1,3 @@
-usr/bin/cjpeg_hdr
usr/bin/cjxl
usr/bin/djxl
usr/bin/jxlinfo
diff --git a/debian/libjxl-tools.manpages b/debian/libjxl-tools.manpages
index b79694f..ad4763b 100644
--- a/debian/libjxl-tools.manpages
+++ b/debian/libjxl-tools.manpages
@@ -1,2 +1 @@
-debian/cjpeg_hdr.1
debian/jxlinfo.1
diff --git a/debian/libjxl0.8.install b/debian/libjxl0.10.install
similarity index 100%
rename from debian/libjxl0.8.install
rename to debian/libjxl0.10.install
diff --git a/debian/libjxl0.8.symbols b/debian/libjxl0.10.symbols
similarity index 70%
rename from debian/libjxl0.8.symbols
rename to debian/libjxl0.10.symbols
index a9e9658..e3d802b 100644
--- a/debian/libjxl0.8.symbols
+++ b/debian/libjxl0.10.symbols
@@ -1,25 +1,26 @@
-libjxl.so.0.8 libjxl0.8 #MINVER#
+libjxl.so.0.10 libjxl0.10 #MINVER#
* Build-Depends-Package: libjxl-dev
JXL_0@JXL_0 0.6.1
- JxlButteraugliApiCreate@JXL_0 0.6.1
- JxlButteraugliApiDestroy@JXL_0 0.6.1
- JxlButteraugliApiSetHFAsymmetry@JXL_0 0.6.1
- JxlButteraugliApiSetIntensityTarget@JXL_0 0.6.1
- JxlButteraugliApiSetParallelRunner@JXL_0 0.6.1
- JxlButteraugliCompute@JXL_0 0.6.1
- JxlButteraugliResultDestroy@JXL_0 0.6.1
- JxlButteraugliResultGetDistance@JXL_0 0.6.1
- JxlButteraugliResultGetDistmap@JXL_0 0.6.1
- JxlButteraugliResultGetMaxDistance@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlButteraugliApiCreate@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlButteraugliApiDestroy@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlButteraugliApiSetHFAsymmetry@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlButteraugliApiSetIntensityTarget@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlButteraugliApiSetParallelRunner@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlButteraugliCompute@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlButteraugliResultDestroy@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlButteraugliResultGetDistance@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlButteraugliResultGetDistmap@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlButteraugliResultGetMaxDistance@JXL_0 0.6.1
JxlColorEncodingSetToLinearSRGB@JXL_0 0.6.1
JxlColorEncodingSetToSRGB@JXL_0 0.6.1
JxlDecoderCloseInput@JXL_0 0.7.0
JxlDecoderCreate@JXL_0 0.6.1
- JxlDecoderDefaultPixelFormat@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlDecoderDefaultPixelFormat@JXL_0 0.6.1
JxlDecoderDestroy@JXL_0 0.6.1
JxlDecoderExtraChannelBufferSize@JXL_0 0.6.1
JxlDecoderFlushImage@JXL_0 0.6.1
JxlDecoderGetBasicInfo@JXL_0 0.6.1
+ JxlDecoderGetBoxSizeContents@JXL_0 0.10.0
JxlDecoderGetBoxSizeRaw@JXL_0 0.7.0
JxlDecoderGetBoxType@JXL_0 0.7.0
JxlDecoderGetColorAsEncodedProfile@JXL_0 0.6.1
@@ -40,6 +41,7 @@ libjxl.so.0.8 libjxl0.8 #MINVER#
JxlDecoderReset@JXL_0 0.6.1
JxlDecoderRewind@JXL_0 0.6.1
JxlDecoderSetBoxBuffer@JXL_0 0.7.0
+ JxlDecoderSetCms@JXL_0 0.9.0
JxlDecoderSetCoalescing@JXL_0 0.7.0
JxlDecoderSetDecompressBoxes@JXL_0 0.7.0
JxlDecoderSetDesiredIntensityTarget@JXL_0 0.7.0
@@ -51,6 +53,7 @@ libjxl.so.0.8 libjxl0.8 #MINVER#
JxlDecoderSetJPEGBuffer@JXL_0 0.6.1
JxlDecoderSetKeepOrientation@JXL_0 0.6.1
JxlDecoderSetMultithreadedImageOutCallback@JXL_0 0.7.0
+ JxlDecoderSetOutputColorProfile@JXL_0 0.9.0
JxlDecoderSetParallelRunner@JXL_0 0.6.1
JxlDecoderSetPreferredColorProfile@JXL_0 0.6.1
JxlDecoderSetPreviewOutBuffer@JXL_0 0.6.1
@@ -63,14 +66,18 @@ libjxl.so.0.8 libjxl0.8 #MINVER#
JxlDecoderSubscribeEvents@JXL_0 0.6.1
JxlDecoderVersion@JXL_0 0.6.1
JxlEncoderAddBox@JXL_0 0.7.0
+ JxlEncoderAddChunkedFrame@JXL_0 0.9.0
JxlEncoderAddImageFrame@JXL_0 0.6.1
JxlEncoderAddJPEGFrame@JXL_0 0.6.1
JxlEncoderAllowExpertOptions@JXL_0 0.8.0
JxlEncoderCloseBoxes@JXL_0 0.7.0
JxlEncoderCloseFrames@JXL_0 0.7.0
JxlEncoderCloseInput@JXL_0 0.6.1
+ JxlEncoderCollectStats@JXL_0 0.9.0
JxlEncoderCreate@JXL_0 0.6.1
JxlEncoderDestroy@JXL_0 0.6.1
+ JxlEncoderDistanceFromQuality@JXL_0 0.9.0
+ JxlEncoderFlushInput@JXL_0 0.9.0
JxlEncoderFrameSettingsCreate@JXL_0 0.7.0
JxlEncoderFrameSettingsSetFloatOption@JXL_0 0.7.0
JxlEncoderFrameSettingsSetOption@JXL_0 0.7.0
@@ -80,19 +87,21 @@ libjxl.so.0.8 libjxl0.8 #MINVER#
JxlEncoderInitBlendInfo@JXL_0 0.7.0
JxlEncoderInitExtraChannelInfo@JXL_0 0.7.0
JxlEncoderInitFrameHeader@JXL_0 0.7.0
- JxlEncoderOptionsCreate@JXL_0 0.6.1
- JxlEncoderOptionsSetDecodingSpeed@JXL_0 0.6.1
- JxlEncoderOptionsSetDistance@JXL_0 0.6.1
- JxlEncoderOptionsSetEffort@JXL_0 0.6.1
- JxlEncoderOptionsSetLossless@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlEncoderOptionsCreate@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlEncoderOptionsSetDecodingSpeed@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlEncoderOptionsSetDistance@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlEncoderOptionsSetEffort@JXL_0 0.6.1
+#MISSING: 0.9.0# JxlEncoderOptionsSetLossless@JXL_0 0.6.1
JxlEncoderProcessOutput@JXL_0 0.6.1
JxlEncoderReset@JXL_0 0.6.1
JxlEncoderSetBasicInfo@JXL_0 0.6.1
JxlEncoderSetCms@JXL_0 0.7.0
JxlEncoderSetCodestreamLevel@JXL_0 0.7.0
JxlEncoderSetColorEncoding@JXL_0 0.6.1
+ JxlEncoderSetDebugImageCallback@JXL_0 0.9.0
JxlEncoderSetExtraChannelBlendInfo@JXL_0 0.7.0
JxlEncoderSetExtraChannelBuffer@JXL_0 0.7.0
+ JxlEncoderSetExtraChannelDistance@JXL_0 0.9.0
JxlEncoderSetExtraChannelInfo@JXL_0 0.7.0
JxlEncoderSetExtraChannelName@JXL_0 0.7.0
JxlEncoderSetFrameBitDepth@JXL_0 0.8.0
@@ -101,13 +110,21 @@ libjxl.so.0.8 libjxl0.8 #MINVER#
JxlEncoderSetFrameLossless@JXL_0 0.7.0
JxlEncoderSetFrameName@JXL_0 0.7.0
JxlEncoderSetICCProfile@JXL_0 0.6.1
+ JxlEncoderSetOutputProcessor@JXL_0 0.9.0
JxlEncoderSetParallelRunner@JXL_0 0.6.1
+ JxlEncoderSetUpsamplingMode@JXL_0 0.9.0
+ JxlEncoderStatsCreate@JXL_0 0.9.0
+ JxlEncoderStatsDestroy@JXL_0 0.9.0
+ JxlEncoderStatsGet@JXL_0 0.9.0
+ JxlEncoderStatsMerge@JXL_0 0.9.0
JxlEncoderStoreJPEGMetadata@JXL_0 0.6.1
JxlEncoderUseBoxes@JXL_0 0.7.0
JxlEncoderUseContainer@JXL_0 0.6.1
JxlEncoderVersion@JXL_0 0.6.1
JxlSignatureCheck@JXL_0 0.6.1
-libjxl_threads.so.0.8 libjxl0.8 #MINVER#
+libjxl_cms.so.0.10 libjxl0.10 #MINVER#
+ JxlGetDefaultCms@Base 0.9.1
+libjxl_threads.so.0.10 libjxl0.10 #MINVER#
* Build-Depends-Package: libjxl-dev
JXL_0@JXL_0 0.6.1
JxlResizableParallelRunner@JXL_0 0.6.1
diff --git a/debian/patches/0008-Fix-conformance-test.patch b/debian/patches/0008-Fix-conformance-test.patch
deleted file mode 100644
index ed2c439..0000000
--- a/debian/patches/0008-Fix-conformance-test.patch
+++ /dev/null
@@ -1,36 +0,0 @@
-From: Boyuan Yang <by...@debian.org>
-Date: Fri, 22 Sep 2023 17:34:23 -0400
-Subject: Fix conformance test
-
-Bug-Debian: https://bugs.debian.org/1051560
-
----
- tools/conformance/generator.py | 2 +-
- tools/conformance/tooling_test.sh | 1 +
- 2 files changed, 2 insertions(+), 1 deletion(-)
-
-diff --git a/tools/conformance/generator.py b/tools/conformance/generator.py
-index e2a9b2e..d59c3f4 100755
---- a/tools/conformance/generator.py
-+++ b/tools/conformance/generator.py
-@@ -67,7 +67,7 @@ def GenerateConformanceCorpus(args):
- cmd.extend(['--icc_out', pixel_prefix + '.icc'])
-
- # Decode and generate the reference files.
-- subprocess.check_call(cmd)
-+ subprocess.check_call(' '.join(cmd), shell=True)
-
- with open(metadata_filename, 'r') as f:
- metadata = json.load(f)
-diff --git a/tools/conformance/tooling_test.sh b/tools/conformance/tooling_test.sh
-index 95adefb..892b7a2 100755
---- a/tools/conformance/tooling_test.sh
-+++ b/tools/conformance/tooling_test.sh
-@@ -41,6 +41,7 @@ main() {
- build_dir=$(realpath "${MYDIR}/../../build")
- fi
-
-+ export LD_LIBRARY_PATH=${build_dir}
- local decoder="${build_dir}/tools/djxl"
- "${MYDIR}/generator.py" \
- --decoder="${decoder}" \
diff --git a/debian/patches/0009-fast_dct-inl.h-Include-std-headers-to-solve-missing-.patch b/debian/patches/0009-fast_dct-inl.h-Include-std-headers-to-solve-missing-.patch
deleted file mode 100644
index 390b3d7..0000000
--- a/debian/patches/0009-fast_dct-inl.h-Include-std-headers-to-solve-missing-.patch
+++ /dev/null
@@ -1,28 +0,0 @@
-From: Boyuan Yang <by...@debian.org>
-Date: Sat, 7 Oct 2023 20:24:01 -0400
-Subject: fast_dct-inl.h: Include std headers to solve missing std::round on
- arm64
-
-Using std::round() needs at least <cmath>, and possibly <array>.
-This patch is a hotfix to circumvent build errors caused by the
-missing of headers on arm64.
-
-Ref: https://buildd.debian.org/status/fetch.php?pkg=jpeg-xl&arch=arm64&ver=0.7.0-10.1&stamp=1696704163&raw=0
----
- lib/jxl/fast_dct-inl.h | 3 +++
- 1 file changed, 3 insertions(+)
-
-Index: libjxl/lib/jxl/fast_dct-inl.h
-===================================================================
---- libjxl.orig/lib/jxl/fast_dct-inl.h
-+++ libjxl/lib/jxl/fast_dct-inl.h
-@@ -17,6 +17,9 @@
-
- #include "lib/jxl/base/status.h"
-
-+#include <cmath>
-+#include <array>
-+
- HWY_BEFORE_NAMESPACE();
- namespace jxl {
- namespace HWY_NAMESPACE {
diff --git a/debian/patches/22d12d74e7bc56b09cfb1973aa89ec8d714fa3fc.patch b/debian/patches/22d12d74e7bc56b09cfb1973aa89ec8d714fa3fc.patch
deleted file mode 100644
index 61014cd..0000000
--- a/debian/patches/22d12d74e7bc56b09cfb1973aa89ec8d714fa3fc.patch
+++ /dev/null
@@ -1,42 +0,0 @@
-From 22d12d74e7bc56b09cfb1973aa89ec8d714fa3fc Mon Sep 17 00:00:00 2001
-From: Eastdong <31920925+ie...@users.noreply.github.com>
-Date: Thu, 23 Feb 2023 06:08:36 +0800
-Subject: [PATCH] Add missing <atomic> content to fix gcc compilation for RISCV
- architecture. (#2211)
-
-* Add missing <atomic> content to fix gcc compilation for RISCV architecture.
-
-* add name to AUTHORS
-
-* lint fix
-
-Co-authored-by: Moritz Firsching <firsch...@google.com>
----
- AUTHORS | 1 +
- lib/jxl/enc_xyb.cc | 1 +
- 2 files changed, 2 insertions(+)
-
-Index: libjxl/AUTHORS
-===================================================================
---- libjxl.orig/AUTHORS
-+++ libjxl/AUTHORS
-@@ -30,6 +30,7 @@ Daniel Novomeský <dnovome...@gmail.com>
- David Burnett <vargols...@gmail.com>
- Dirk Lemstra <d...@lemstra.org>
- Don Olmstead <don.j.olmst...@gmail.com>
-+Dong Xu <xdong...@gmail.com>
- Even Rouault <even.roua...@spatialys.com>
- Fred Brennan <copypa...@kittens.ph>
- Heiko Becker <heire...@exherbo.org>
-Index: libjxl/lib/jxl/enc_xyb.cc
-===================================================================
---- libjxl.orig/lib/jxl/enc_xyb.cc
-+++ libjxl/lib/jxl/enc_xyb.cc
-@@ -6,6 +6,7 @@
- #include "lib/jxl/enc_xyb.h"
-
- #include <algorithm>
-+#include <atomic>
- #include <cstdlib>
-
- #undef HWY_TARGET_INCLUDE
diff --git a/debian/patches/383df4487f59da140fd1ce112548a2cd11e4eaeb.patch b/debian/patches/383df4487f59da140fd1ce112548a2cd11e4eaeb.patch
deleted file mode 100644
index c542ac5..0000000
--- a/debian/patches/383df4487f59da140fd1ce112548a2cd11e4eaeb.patch
+++ /dev/null
@@ -1,46 +0,0 @@
-From 383df4487f59da140fd1ce112548a2cd11e4eaeb Mon Sep 17 00:00:00 2001
-From: Sami Boukortt <sbouko...@google.com>
-Date: Thu, 22 Jun 2023 12:26:25 +0200
-Subject: [PATCH] Make sure to read the rendering intent before the CICP tag
-
-The code that reads the CICP tag exits the function if it succeeds, but
-it should not skip reading the rendering intent, so make sure to have
-already done it by that point.
----
- lib/jxl/enc_color_management.cc | 16 ++++++++--------
- 1 file changed, 8 insertions(+), 8 deletions(-)
-
-Index: libjxl/lib/jxl/enc_color_management.cc
-===================================================================
---- libjxl.orig/lib/jxl/enc_color_management.cc
-+++ libjxl/lib/jxl/enc_color_management.cc
-@@ -922,6 +922,14 @@ Status ColorEncoding::SetFieldsFromICC()
- Profile profile;
- JXL_RETURN_IF_ERROR(DecodeProfile(context, icc_, &profile));
-
-+ const cmsUInt32Number rendering_intent32 =
-+ cmsGetHeaderRenderingIntent(profile.get());
-+ if (rendering_intent32 > 3) {
-+ return JXL_FAILURE("Invalid rendering intent %u\n", rendering_intent32);
-+ }
-+ // ICC and RenderingIntent have the same values (0..3).
-+ rendering_intent = static_cast<RenderingIntent>(rendering_intent32);
-+
- static constexpr size_t kCICPSize = 12;
- static constexpr auto kCICPSignature =
- static_cast<cmsTagSignature>(0x63696370);
-@@ -933,14 +941,6 @@ Status ColorEncoding::SetFieldsFromICC()
- return true;
- }
-
-- const cmsUInt32Number rendering_intent32 =
-- cmsGetHeaderRenderingIntent(profile.get());
-- if (rendering_intent32 > 3) {
-- return JXL_FAILURE("Invalid rendering intent %u\n", rendering_intent32);
-- }
-- // ICC and RenderingIntent have the same values (0..3).
-- rendering_intent = static_cast<RenderingIntent>(rendering_intent32);
--
- SetColorSpace(ColorSpaceFromProfile(profile));
- if (cmsGetColorSpace(profile.get()) == cmsSigCmykData) {
- cmyk_ = true;
diff --git a/debian/patches/add_headers.patch b/debian/patches/add_headers.patch
new file mode 100644
index 0000000..6a649e3
--- /dev/null
+++ b/debian/patches/add_headers.patch
@@ -0,0 +1,1569 @@
+diff --git a/third_party/libjpeg-turbo/jconfig.h.in b/third_party/libjpeg-turbo/jconfig.h.in
+new file mode 100644
+index 0000000..e018012
+--- /dev/null
++++ b/third_party/libjpeg-turbo/jconfig.h.in
+@@ -0,0 +1,37 @@
++/* Version ID for the JPEG library.
++ * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60".
++ */
++#define JPEG_LIB_VERSION @JPEG_LIB_VERSION@
++
++/* libjpeg-turbo version */
++#define LIBJPEG_TURBO_VERSION @VERSION@
++
++/* libjpeg-turbo version in integer form */
++#define LIBJPEG_TURBO_VERSION_NUMBER @LIBJPEG_TURBO_VERSION_NUMBER@
++
++/* Support arithmetic encoding */
++#cmakedefine C_ARITH_CODING_SUPPORTED 1
++
++/* Support arithmetic decoding */
++#cmakedefine D_ARITH_CODING_SUPPORTED 1
++
++/* Support in-memory source/destination managers */
++#cmakedefine MEM_SRCDST_SUPPORTED 1
++
++/* Use accelerated SIMD routines. */
++#cmakedefine WITH_SIMD 1
++
++/*
++ * Define BITS_IN_JSAMPLE as either
++ * 8 for 8-bit sample values (the usual setting)
++ * 12 for 12-bit sample values
++ * Only 8 and 12 are legal data precisions for lossy JPEG according to the
++ * JPEG standard, and the IJG code does not support anything else!
++ * We do not support run-time selection of data precision, sorry.
++ */
++
++#define BITS_IN_JSAMPLE @BITS_IN_JSAMPLE@ /* use 8 or 12 */
++
++/* Define if your (broken) compiler shifts signed values as if they were
++ unsigned. */
++#cmakedefine RIGHT_SHIFT_IS_UNSIGNED 1
+diff --git a/third_party/libjpeg-turbo/jmorecfg.h b/third_party/libjpeg-turbo/jmorecfg.h
+new file mode 100644
+index 0000000..b33a991
+--- /dev/null
++++ b/third_party/libjpeg-turbo/jmorecfg.h
+@@ -0,0 +1,382 @@
++/*
++ * jmorecfg.h
++ *
++ * This file was part of the Independent JPEG Group's software:
++ * Copyright (C) 1991-1997, Thomas G. Lane.
++ * Modified 1997-2009 by Guido Vollbeding.
++ * libjpeg-turbo Modifications:
++ * Copyright (C) 2009, 2011, 2014-2015, 2018, 2020, D. R. Commander.
++ * For conditions of distribution and use, see the accompanying README.ijg
++ * file.
++ *
++ * This file contains additional configuration options that customize the
++ * JPEG software for special applications or support machine-dependent
++ * optimizations. Most users will not need to touch this file.
++ */
++
++
++/*
++ * Maximum number of components (color channels) allowed in JPEG image.
++ * To meet the letter of Rec. ITU-T T.81 | ISO/IEC 10918-1, set this to 255.
++ * However, darn few applications need more than 4 channels (maybe 5 for CMYK +
++ * alpha mask). We recommend 10 as a reasonable compromise; use 4 if you are
++ * really short on memory. (Each allowed component costs a hundred or so
++ * bytes of storage, whether actually used in an image or not.)
++ */
++
++#define MAX_COMPONENTS 10 /* maximum number of image components */
++
++
++/*
++ * Basic data types.
++ * You may need to change these if you have a machine with unusual data
++ * type sizes; for example, "char" not 8 bits, "short" not 16 bits,
++ * or "long" not 32 bits. We don't care whether "int" is 16 or 32 bits,
++ * but it had better be at least 16.
++ */
++
++/* Representation of a single sample (pixel element value).
++ * We frequently allocate large arrays of these, so it's important to keep
++ * them small. But if you have memory to burn and access to char or short
++ * arrays is very slow on your hardware, you might want to change these.
++ */
++
++#if BITS_IN_JSAMPLE == 8
++/* JSAMPLE should be the smallest type that will hold the values 0..255.
++ */
++
++typedef unsigned char JSAMPLE;
++#define GETJSAMPLE(value) ((int)(value))
++
++#define MAXJSAMPLE 255
++#define CENTERJSAMPLE 128
++
++#endif /* BITS_IN_JSAMPLE == 8 */
++
++
++#if BITS_IN_JSAMPLE == 12
++/* JSAMPLE should be the smallest type that will hold the values 0..4095.
++ * On nearly all machines "short" will do nicely.
++ */
++
++typedef short JSAMPLE;
++#define GETJSAMPLE(value) ((int)(value))
++
++#define MAXJSAMPLE 4095
++#define CENTERJSAMPLE 2048
++
++#endif /* BITS_IN_JSAMPLE == 12 */
++
++
++/* Representation of a DCT frequency coefficient.
++ * This should be a signed value of at least 16 bits; "short" is usually OK.
++ * Again, we allocate large arrays of these, but you can change to int
++ * if you have memory to burn and "short" is really slow.
++ */
++
++typedef short JCOEF;
++
++
++/* Compressed datastreams are represented as arrays of JOCTET.
++ * These must be EXACTLY 8 bits wide, at least once they are written to
++ * external storage. Note that when using the stdio data source/destination
++ * managers, this is also the data type passed to fread/fwrite.
++ */
++
++typedef unsigned char JOCTET;
++#define GETJOCTET(value) (value)
++
++
++/* These typedefs are used for various table entries and so forth.
++ * They must be at least as wide as specified; but making them too big
++ * won't cost a huge amount of memory, so we don't provide special
++ * extraction code like we did for JSAMPLE. (In other words, these
++ * typedefs live at a different point on the speed/space tradeoff curve.)
++ */
++
++/* UINT8 must hold at least the values 0..255. */
++
++typedef unsigned char UINT8;
++
++/* UINT16 must hold at least the values 0..65535. */
++
++typedef unsigned short UINT16;
++
++/* INT16 must hold at least the values -32768..32767. */
++
++#ifndef XMD_H /* X11/xmd.h correctly defines INT16 */
++typedef short INT16;
++#endif
++
++/* INT32 must hold at least signed 32-bit values.
++ *
++ * NOTE: The INT32 typedef dates back to libjpeg v5 (1994.) Integers were
++ * sometimes 16-bit back then (MS-DOS), which is why INT32 is typedef'd to
++ * long. It also wasn't common (or at least as common) in 1994 for INT32 to be
++ * defined by platform headers. Since then, however, INT32 is defined in
++ * several other common places:
++ *
++ * Xmd.h (X11 header) typedefs INT32 to int on 64-bit platforms and long on
++ * 32-bit platforms (i.e always a 32-bit signed type.)
++ *
++ * basetsd.h (Win32 header) typedefs INT32 to int (always a 32-bit signed type
++ * on modern platforms.)
++ *
++ * qglobal.h (Qt header) typedefs INT32 to int (always a 32-bit signed type on
++ * modern platforms.)
++ *
++ * This is a recipe for conflict, since "long" and "int" aren't always
++ * compatible types. Since the definition of INT32 has technically been part
++ * of the libjpeg API for more than 20 years, we can't remove it, but we do not
++ * use it internally any longer. We instead define a separate type (JLONG)
++ * for internal use, which ensures that internal behavior will always be the
++ * same regardless of any external headers that may be included.
++ */
++
++#ifndef XMD_H /* X11/xmd.h correctly defines INT32 */
++#ifndef _BASETSD_H_ /* Microsoft defines it in basetsd.h */
++#ifndef _BASETSD_H /* MinGW is slightly different */
++#ifndef QGLOBAL_H /* Qt defines it in qglobal.h */
++typedef long INT32;
++#endif
++#endif
++#endif
++#endif
++
++/* Datatype used for image dimensions. The JPEG standard only supports
++ * images up to 64K*64K due to 16-bit fields in SOF markers. Therefore
++ * "unsigned int" is sufficient on all machines. However, if you need to
++ * handle larger images and you don't mind deviating from the spec, you
++ * can change this datatype. (Note that changing this datatype will
++ * potentially require modifying the SIMD code. The x86-64 SIMD extensions,
++ * in particular, assume a 32-bit JDIMENSION.)
++ */
++
++typedef unsigned int JDIMENSION;
++
++#define JPEG_MAX_DIMENSION 65500L /* a tad under 64K to prevent overflows */
++
++
++/* These macros are used in all function definitions and extern declarations.
++ * You could modify them if you need to change function linkage conventions;
++ * in particular, you'll need to do that to make the library a Windows DLL.
++ * Another application is to make all functions global for use with debuggers
++ * or code profilers that require it.
++ */
++
++/* a function called through method pointers: */
++#define METHODDEF(type) static type
++/* a function used only in its module: */
++#define LOCAL(type) static type
++/* a function referenced thru EXTERNs: */
++#define GLOBAL(type) type
++/* a reference to a GLOBAL function: */
++#define EXTERN(type) extern type
++
++
++/* Originally, this macro was used as a way of defining function prototypes
++ * for both modern compilers as well as older compilers that did not support
++ * prototype parameters. libjpeg-turbo has never supported these older,
++ * non-ANSI compilers, but the macro is still included because there is some
++ * software out there that uses it.
++ */
++
++#define JMETHOD(type, methodname, arglist) type (*methodname) arglist
++
++
++/* libjpeg-turbo no longer supports platforms that have far symbols (MS-DOS),
++ * but again, some software relies on this macro.
++ */
++
++#undef FAR
++#define FAR
++
++
++/*
++ * On a few systems, type boolean and/or its values FALSE, TRUE may appear
++ * in standard header files. Or you may have conflicts with application-
++ * specific header files that you want to include together with these files.
++ * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
++ */
++
++#ifndef HAVE_BOOLEAN
++typedef int boolean;
++#endif
++#ifndef FALSE /* in case these macros already exist */
++#define FALSE 0 /* values of boolean */
++#endif
++#ifndef TRUE
++#define TRUE 1
++#endif
++
++
++/*
++ * The remaining options affect code selection within the JPEG library,
++ * but they don't need to be visible to most applications using the library.
++ * To minimize application namespace pollution, the symbols won't be
++ * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
++ */
++
++#ifdef JPEG_INTERNALS
++#define JPEG_INTERNAL_OPTIONS
++#endif
++
++#ifdef JPEG_INTERNAL_OPTIONS
++
++
++/*
++ * These defines indicate whether to include various optional functions.
++ * Undefining some of these symbols will produce a smaller but less capable
++ * library. Note that you can leave certain source files out of the
++ * compilation/linking process if you've #undef'd the corresponding symbols.
++ * (You may HAVE to do that if your compiler doesn't like null source files.)
++ */
++
++/* Capability options common to encoder and decoder: */
++
++#define DCT_ISLOW_SUPPORTED /* accurate integer method */
++#define DCT_IFAST_SUPPORTED /* less accurate int method [legacy feature] */
++#define DCT_FLOAT_SUPPORTED /* floating-point method [legacy feature] */
++
++/* Encoder capability options: */
++
++#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
++#define C_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/
++#define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */
++/* Note: if you selected 12-bit data precision, it is dangerous to turn off
++ * ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit
++ * precision, so jchuff.c normally uses entropy optimization to compute
++ * usable tables for higher precision. If you don't want to do optimization,
++ * you'll have to supply different default Huffman tables.
++ * The exact same statements apply for progressive JPEG: the default tables
++ * don't work for progressive mode. (This may get fixed, however.)
++ */
++#define INPUT_SMOOTHING_SUPPORTED /* Input image smoothing option? */
++
++/* Decoder capability options: */
++
++#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
++#define D_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/
++#define SAVE_MARKERS_SUPPORTED /* jpeg_save_markers() needed? */
++#define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing? (Progressive only) */
++#define IDCT_SCALING_SUPPORTED /* Output rescaling via IDCT? */
++#undef UPSAMPLE_SCALING_SUPPORTED /* Output rescaling at upsample stage? */
++#define UPSAMPLE_MERGING_SUPPORTED /* Fast path for sloppy upsampling? */
++#define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */
++#define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */
++
++/* more capability options later, no doubt */
++
++
++/*
++ * The RGB_RED, RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE macros are a vestigial
++ * feature of libjpeg. The idea was that, if an application developer needed
++ * to compress from/decompress to a BGR/BGRX/RGBX/XBGR/XRGB buffer, they could
++ * change these macros, rebuild libjpeg, and link their application statically
++ * with it. In reality, few people ever did this, because there were some
++ * severe restrictions involved (cjpeg and djpeg no longer worked properly,
++ * compressing/decompressing RGB JPEGs no longer worked properly, and the color
++ * quantizer wouldn't work with pixel sizes other than 3.) Furthermore, since
++ * all of the O/S-supplied versions of libjpeg were built with the default
++ * values of RGB_RED, RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE, many applications
++ * have come to regard these values as immutable.
++ *
++ * The libjpeg-turbo colorspace extensions provide a much cleaner way of
++ * compressing from/decompressing to buffers with arbitrary component orders
++ * and pixel sizes. Thus, we do not support changing the values of RGB_RED,
++ * RGB_GREEN, RGB_BLUE, or RGB_PIXELSIZE. In addition to the restrictions
++ * listed above, changing these values will also break the SIMD extensions and
++ * the regression tests.
++ */
++
++#define RGB_RED 0 /* Offset of Red in an RGB scanline element */
++#define RGB_GREEN 1 /* Offset of Green */
++#define RGB_BLUE 2 /* Offset of Blue */
++#define RGB_PIXELSIZE 3 /* JSAMPLEs per RGB scanline element */
++
++#define JPEG_NUMCS 17
++
++#define EXT_RGB_RED 0
++#define EXT_RGB_GREEN 1
++#define EXT_RGB_BLUE 2
++#define EXT_RGB_PIXELSIZE 3
++
++#define EXT_RGBX_RED 0
++#define EXT_RGBX_GREEN 1
++#define EXT_RGBX_BLUE 2
++#define EXT_RGBX_PIXELSIZE 4
++
++#define EXT_BGR_RED 2
++#define EXT_BGR_GREEN 1
++#define EXT_BGR_BLUE 0
++#define EXT_BGR_PIXELSIZE 3
++
++#define EXT_BGRX_RED 2
++#define EXT_BGRX_GREEN 1
++#define EXT_BGRX_BLUE 0
++#define EXT_BGRX_PIXELSIZE 4
++
++#define EXT_XBGR_RED 3
++#define EXT_XBGR_GREEN 2
++#define EXT_XBGR_BLUE 1
++#define EXT_XBGR_PIXELSIZE 4
++
++#define EXT_XRGB_RED 1
++#define EXT_XRGB_GREEN 2
++#define EXT_XRGB_BLUE 3
++#define EXT_XRGB_PIXELSIZE 4
++
++static const int rgb_red[JPEG_NUMCS] = {
++ -1, -1, RGB_RED, -1, -1, -1, EXT_RGB_RED, EXT_RGBX_RED,
++ EXT_BGR_RED, EXT_BGRX_RED, EXT_XBGR_RED, EXT_XRGB_RED,
++ EXT_RGBX_RED, EXT_BGRX_RED, EXT_XBGR_RED, EXT_XRGB_RED,
++ -1
++};
++
++static const int rgb_green[JPEG_NUMCS] = {
++ -1, -1, RGB_GREEN, -1, -1, -1, EXT_RGB_GREEN, EXT_RGBX_GREEN,
++ EXT_BGR_GREEN, EXT_BGRX_GREEN, EXT_XBGR_GREEN, EXT_XRGB_GREEN,
++ EXT_RGBX_GREEN, EXT_BGRX_GREEN, EXT_XBGR_GREEN, EXT_XRGB_GREEN,
++ -1
++};
++
++static const int rgb_blue[JPEG_NUMCS] = {
++ -1, -1, RGB_BLUE, -1, -1, -1, EXT_RGB_BLUE, EXT_RGBX_BLUE,
++ EXT_BGR_BLUE, EXT_BGRX_BLUE, EXT_XBGR_BLUE, EXT_XRGB_BLUE,
++ EXT_RGBX_BLUE, EXT_BGRX_BLUE, EXT_XBGR_BLUE, EXT_XRGB_BLUE,
++ -1
++};
++
++static const int rgb_pixelsize[JPEG_NUMCS] = {
++ -1, -1, RGB_PIXELSIZE, -1, -1, -1, EXT_RGB_PIXELSIZE, EXT_RGBX_PIXELSIZE,
++ EXT_BGR_PIXELSIZE, EXT_BGRX_PIXELSIZE, EXT_XBGR_PIXELSIZE, EXT_XRGB_PIXELSIZE,
++ EXT_RGBX_PIXELSIZE, EXT_BGRX_PIXELSIZE, EXT_XBGR_PIXELSIZE, EXT_XRGB_PIXELSIZE,
++ -1
++};
++
++/* Definitions for speed-related optimizations. */
++
++/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
++ * two 16-bit shorts is faster than multiplying two ints. Define MULTIPLIER
++ * as short on such a machine. MULTIPLIER must be at least 16 bits wide.
++ */
++
++#ifndef MULTIPLIER
++#ifndef WITH_SIMD
++#define MULTIPLIER int /* type for fastest integer multiply */
++#else
++#define MULTIPLIER short /* prefer 16-bit with SIMD for parellelism */
++#endif
++#endif
++
++
++/* FAST_FLOAT should be either float or double, whichever is done faster
++ * by your compiler. (Note that this type is only used in the floating point
++ * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
++ */
++
++#ifndef FAST_FLOAT
++#define FAST_FLOAT float
++#endif
++
++#endif /* JPEG_INTERNAL_OPTIONS */
+diff --git a/third_party/libjpeg-turbo/jpeglib.h b/third_party/libjpeg-turbo/jpeglib.h
+new file mode 100644
+index 0000000..d7664f0
+--- /dev/null
++++ b/third_party/libjpeg-turbo/jpeglib.h
+@@ -0,0 +1,1132 @@
++/*
++ * jpeglib.h
++ *
++ * This file was part of the Independent JPEG Group's software:
++ * Copyright (C) 1991-1998, Thomas G. Lane.
++ * Modified 2002-2009 by Guido Vollbeding.
++ * libjpeg-turbo Modifications:
++ * Copyright (C) 2009-2011, 2013-2014, 2016-2017, 2020, D. R. Commander.
++ * Copyright (C) 2015, Google, Inc.
++ * For conditions of distribution and use, see the accompanying README.ijg
++ * file.
++ *
++ * This file defines the application interface for the JPEG library.
++ * Most applications using the library need only include this file,
++ * and perhaps jerror.h if they want to know the exact error codes.
++ */
++
++#ifndef JPEGLIB_H
++#define JPEGLIB_H
++
++/*
++ * First we include the configuration files that record how this
++ * installation of the JPEG library is set up. jconfig.h can be
++ * generated automatically for many systems. jmorecfg.h contains
++ * manual configuration options that most people need not worry about.
++ */
++
++#ifndef JCONFIG_INCLUDED /* in case jinclude.h already did */
++#include "jconfig.h" /* widely used configuration options */
++#endif
++#include "jmorecfg.h" /* seldom changed options */
++
++
++#ifdef __cplusplus
++#ifndef DONT_USE_EXTERN_C
++extern "C" {
++#endif
++#endif
++
++
++/* Various constants determining the sizes of things.
++ * All of these are specified by the JPEG standard, so don't change them
++ * if you want to be compatible.
++ */
++
++#define DCTSIZE 8 /* The basic DCT block is 8x8 samples */
++#define DCTSIZE2 64 /* DCTSIZE squared; # of elements in a block */
++#define NUM_QUANT_TBLS 4 /* Quantization tables are numbered 0..3 */
++#define NUM_HUFF_TBLS 4 /* Huffman tables are numbered 0..3 */
++#define NUM_ARITH_TBLS 16 /* Arith-coding tables are numbered 0..15 */
++#define MAX_COMPS_IN_SCAN 4 /* JPEG limit on # of components in one scan */
++#define MAX_SAMP_FACTOR 4 /* JPEG limit on sampling factors */
++/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard;
++ * the PostScript DCT filter can emit files with many more than 10 blocks/MCU.
++ * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU
++ * to handle it. We even let you do this from the jconfig.h file. However,
++ * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe
++ * sometimes emits noncompliant files doesn't mean you should too.
++ */
++#define C_MAX_BLOCKS_IN_MCU 10 /* compressor's limit on blocks per MCU */
++#ifndef D_MAX_BLOCKS_IN_MCU
++#define D_MAX_BLOCKS_IN_MCU 10 /* decompressor's limit on blocks per MCU */
++#endif
++
++
++/* Data structures for images (arrays of samples and of DCT coefficients).
++ */
++
++typedef JSAMPLE *JSAMPROW; /* ptr to one image row of pixel samples. */
++typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */
++typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */
++
++typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */
++typedef JBLOCK *JBLOCKROW; /* pointer to one row of coefficient blocks */
++typedef JBLOCKROW *JBLOCKARRAY; /* a 2-D array of coefficient blocks */
++typedef JBLOCKARRAY *JBLOCKIMAGE; /* a 3-D array of coefficient blocks */
++
++typedef JCOEF *JCOEFPTR; /* useful in a couple of places */
++
++
++/* Types for JPEG compression parameters and working tables. */
++
++
++/* DCT coefficient quantization tables. */
++
++typedef struct {
++ /* This array gives the coefficient quantizers in natural array order
++ * (not the zigzag order in which they are stored in a JPEG DQT marker).
++ * CAUTION: IJG versions prior to v6a kept this array in zigzag order.
++ */
++ UINT16 quantval[DCTSIZE2]; /* quantization step for each coefficient */
++ /* This field is used only during compression. It's initialized FALSE when
++ * the table is created, and set TRUE when it's been output to the file.
++ * You could suppress output of a table by setting this to TRUE.
++ * (See jpeg_suppress_tables for an example.)
++ */
++ boolean sent_table; /* TRUE when table has been output */
++} JQUANT_TBL;
++
++
++/* Huffman coding tables. */
++
++typedef struct {
++ /* These two fields directly represent the contents of a JPEG DHT marker */
++ UINT8 bits[17]; /* bits[k] = # of symbols with codes of */
++ /* length k bits; bits[0] is unused */
++ UINT8 huffval[256]; /* The symbols, in order of incr code length */
++ /* This field is used only during compression. It's initialized FALSE when
++ * the table is created, and set TRUE when it's been output to the file.
++ * You could suppress output of a table by setting this to TRUE.
++ * (See jpeg_suppress_tables for an example.)
++ */
++ boolean sent_table; /* TRUE when table has been output */
++} JHUFF_TBL;
++
++
++/* Basic info about one component (color channel). */
++
++typedef struct {
++ /* These values are fixed over the whole image. */
++ /* For compression, they must be supplied by parameter setup; */
++ /* for decompression, they are read from the SOF marker. */
++ int component_id; /* identifier for this component (0..255) */
++ int component_index; /* its index in SOF or cinfo->comp_info[] */
++ int h_samp_factor; /* horizontal sampling factor (1..4) */
++ int v_samp_factor; /* vertical sampling factor (1..4) */
++ int quant_tbl_no; /* quantization table selector (0..3) */
++ /* These values may vary between scans. */
++ /* For compression, they must be supplied by parameter setup; */
++ /* for decompression, they are read from the SOS marker. */
++ /* The decompressor output side may not use these variables. */
++ int dc_tbl_no; /* DC entropy table selector (0..3) */
++ int ac_tbl_no; /* AC entropy table selector (0..3) */
++
++ /* Remaining fields should be treated as private by applications. */
++
++ /* These values are computed during compression or decompression startup: */
++ /* Component's size in DCT blocks.
++ * Any dummy blocks added to complete an MCU are not counted; therefore
++ * these values do not depend on whether a scan is interleaved or not.
++ */
++ JDIMENSION width_in_blocks;
++ JDIMENSION height_in_blocks;
++ /* Size of a DCT block in samples. Always DCTSIZE for compression.
++ * For decompression this is the size of the output from one DCT block,
++ * reflecting any scaling we choose to apply during the IDCT step.
++ * Values from 1 to 16 are supported.
++ * Note that different components may receive different IDCT scalings.
++ */
++#if JPEG_LIB_VERSION >= 70
++ int DCT_h_scaled_size;
++ int DCT_v_scaled_size;
++#else
++ int DCT_scaled_size;
++#endif
++ /* The downsampled dimensions are the component's actual, unpadded number
++ * of samples at the main buffer (preprocessing/compression interface), thus
++ * downsampled_width = ceil(image_width * Hi/Hmax)
++ * and similarly for height. For decompression, IDCT scaling is included, so
++ * downsampled_width = ceil(image_width * Hi/Hmax * DCT_[h_]scaled_size/DCTSIZE)
++ */
++ JDIMENSION downsampled_width; /* actual width in samples */
++ JDIMENSION downsampled_height; /* actual height in samples */
++ /* This flag is used only for decompression. In cases where some of the
++ * components will be ignored (eg grayscale output from YCbCr image),
++ * we can skip most computations for the unused components.
++ */
++ boolean component_needed; /* do we need the value of this component? */
++
++ /* These values are computed before starting a scan of the component. */
++ /* The decompressor output side may not use these variables. */
++ int MCU_width; /* number of blocks per MCU, horizontally */
++ int MCU_height; /* number of blocks per MCU, vertically */
++ int MCU_blocks; /* MCU_width * MCU_height */
++ int MCU_sample_width; /* MCU width in samples, MCU_width*DCT_[h_]scaled_size */
++ int last_col_width; /* # of non-dummy blocks across in last MCU */
++ int last_row_height; /* # of non-dummy blocks down in last MCU */
++
++ /* Saved quantization table for component; NULL if none yet saved.
++ * See jdinput.c comments about the need for this information.
++ * This field is currently used only for decompression.
++ */
++ JQUANT_TBL *quant_table;
++
++ /* Private per-component storage for DCT or IDCT subsystem. */
++ void *dct_table;
++} jpeg_component_info;
++
++
++/* The script for encoding a multiple-scan file is an array of these: */
++
++typedef struct {
++ int comps_in_scan; /* number of components encoded in this scan */
++ int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */
++ int Ss, Se; /* progressive JPEG spectral selection parms */
++ int Ah, Al; /* progressive JPEG successive approx. parms */
++} jpeg_scan_info;
++
++/* The decompressor can save APPn and COM markers in a list of these: */
++
++typedef struct jpeg_marker_struct *jpeg_saved_marker_ptr;
++
++struct jpeg_marker_struct {
++ jpeg_saved_marker_ptr next; /* next in list, or NULL */
++ UINT8 marker; /* marker code: JPEG_COM, or JPEG_APP0+n */
++ unsigned int original_length; /* # bytes of data in the file */
++ unsigned int data_length; /* # bytes of data saved at data[] */
++ JOCTET *data; /* the data contained in the marker */
++ /* the marker length word is not counted in data_length or original_length */
++};
++
++/* Known color spaces. */
++
++#define JCS_EXTENSIONS 1
++#define JCS_ALPHA_EXTENSIONS 1
++
++typedef enum {
++ JCS_UNKNOWN, /* error/unspecified */
++ JCS_GRAYSCALE, /* monochrome */
++ JCS_RGB, /* red/green/blue as specified by the RGB_RED,
++ RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE macros */
++ JCS_YCbCr, /* Y/Cb/Cr (also known as YUV) */
++ JCS_CMYK, /* C/M/Y/K */
++ JCS_YCCK, /* Y/Cb/Cr/K */
++ JCS_EXT_RGB, /* red/green/blue */
++ JCS_EXT_RGBX, /* red/green/blue/x */
++ JCS_EXT_BGR, /* blue/green/red */
++ JCS_EXT_BGRX, /* blue/green/red/x */
++ JCS_EXT_XBGR, /* x/blue/green/red */
++ JCS_EXT_XRGB, /* x/red/green/blue */
++ /* When out_color_space it set to JCS_EXT_RGBX, JCS_EXT_BGRX, JCS_EXT_XBGR,
++ or JCS_EXT_XRGB during decompression, the X byte is undefined, and in
++ order to ensure the best performance, libjpeg-turbo can set that byte to
++ whatever value it wishes. Use the following colorspace constants to
++ ensure that the X byte is set to 0xFF, so that it can be interpreted as an
++ opaque alpha channel. */
++ JCS_EXT_RGBA, /* red/green/blue/alpha */
++ JCS_EXT_BGRA, /* blue/green/red/alpha */
++ JCS_EXT_ABGR, /* alpha/blue/green/red */
++ JCS_EXT_ARGB, /* alpha/red/green/blue */
++ JCS_RGB565 /* 5-bit red/6-bit green/5-bit blue */
++} J_COLOR_SPACE;
++
++/* DCT/IDCT algorithm options. */
++
++typedef enum {
++ JDCT_ISLOW, /* accurate integer method */
++ JDCT_IFAST, /* less accurate integer method [legacy feature] */
++ JDCT_FLOAT /* floating-point method [legacy feature] */
++} J_DCT_METHOD;
++
++#ifndef JDCT_DEFAULT /* may be overridden in jconfig.h */
++#define JDCT_DEFAULT JDCT_ISLOW
++#endif
++#ifndef JDCT_FASTEST /* may be overridden in jconfig.h */
++#define JDCT_FASTEST JDCT_IFAST
++#endif
++
++/* Dithering options for decompression. */
++
++typedef enum {
++ JDITHER_NONE, /* no dithering */
++ JDITHER_ORDERED, /* simple ordered dither */
++ JDITHER_FS /* Floyd-Steinberg error diffusion dither */
++} J_DITHER_MODE;
++
++
++/* Common fields between JPEG compression and decompression master structs. */
++
++#define jpeg_common_fields \
++ struct jpeg_error_mgr *err; /* Error handler module */ \
++ struct jpeg_memory_mgr *mem; /* Memory manager module */ \
++ struct jpeg_progress_mgr *progress; /* Progress monitor, or NULL if none */ \
++ void *client_data; /* Available for use by application */ \
++ boolean is_decompressor; /* So common code can tell which is which */ \
++ int global_state /* For checking call sequence validity */
++
++/* Routines that are to be used by both halves of the library are declared
++ * to receive a pointer to this structure. There are no actual instances of
++ * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct.
++ */
++struct jpeg_common_struct {
++ jpeg_common_fields; /* Fields common to both master struct types */
++ /* Additional fields follow in an actual jpeg_compress_struct or
++ * jpeg_decompress_struct. All three structs must agree on these
++ * initial fields! (This would be a lot cleaner in C++.)
++ */
++};
++
++typedef struct jpeg_common_struct *j_common_ptr;
++typedef struct jpeg_compress_struct *j_compress_ptr;
++typedef struct jpeg_decompress_struct *j_decompress_ptr;
++
++
++/* Master record for a compression instance */
++
++struct jpeg_compress_struct {
++ jpeg_common_fields; /* Fields shared with jpeg_decompress_struct */
++
++ /* Destination for compressed data */
++ struct jpeg_destination_mgr *dest;
++
++ /* Description of source image --- these fields must be filled in by
++ * outer application before starting compression. in_color_space must
++ * be correct before you can even call jpeg_set_defaults().
++ */
++
++ JDIMENSION image_width; /* input image width */
++ JDIMENSION image_height; /* input image height */
++ int input_components; /* # of color components in input image */
++ J_COLOR_SPACE in_color_space; /* colorspace of input image */
++
++ double input_gamma; /* image gamma of input image */
++
++ /* Compression parameters --- these fields must be set before calling
++ * jpeg_start_compress(). We recommend calling jpeg_set_defaults() to
++ * initialize everything to reasonable defaults, then changing anything
++ * the application specifically wants to change. That way you won't get
++ * burnt when new parameters are added. Also note that there are several
++ * helper routines to simplify changing parameters.
++ */
++
++#if JPEG_LIB_VERSION >= 70
++ unsigned int scale_num, scale_denom; /* fraction by which to scale image */
++
++ JDIMENSION jpeg_width; /* scaled JPEG image width */
++ JDIMENSION jpeg_height; /* scaled JPEG image height */
++ /* Dimensions of actual JPEG image that will be written to file,
++ * derived from input dimensions by scaling factors above.
++ * These fields are computed by jpeg_start_compress().
++ * You can also use jpeg_calc_jpeg_dimensions() to determine these values
++ * in advance of calling jpeg_start_compress().
++ */
++#endif
++
++ int data_precision; /* bits of precision in image data */
++
++ int num_components; /* # of color components in JPEG image */
++ J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
++
++ jpeg_component_info *comp_info;
++ /* comp_info[i] describes component that appears i'th in SOF */
++
++ JQUANT_TBL *quant_tbl_ptrs[NUM_QUANT_TBLS];
++#if JPEG_LIB_VERSION >= 70
++ int q_scale_factor[NUM_QUANT_TBLS];
++#endif
++ /* ptrs to coefficient quantization tables, or NULL if not defined,
++ * and corresponding scale factors (percentage, initialized 100).
++ */
++
++ JHUFF_TBL *dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
++ JHUFF_TBL *ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
++ /* ptrs to Huffman coding tables, or NULL if not defined */
++
++ UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
++ UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
++ UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
++
++ int num_scans; /* # of entries in scan_info array */
++ const jpeg_scan_info *scan_info; /* script for multi-scan file, or NULL */
++ /* The default value of scan_info is NULL, which causes a single-scan
++ * sequential JPEG file to be emitted. To create a multi-scan file,
++ * set num_scans and scan_info to point to an array of scan definitions.
++ */
++
++ boolean raw_data_in; /* TRUE=caller supplies downsampled data */
++ boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */
++ boolean optimize_coding; /* TRUE=optimize entropy encoding parms */
++ boolean CCIR601_sampling; /* TRUE=first samples are cosited */
++#if JPEG_LIB_VERSION >= 70
++ boolean do_fancy_downsampling; /* TRUE=apply fancy downsampling */
++#endif
++ int smoothing_factor; /* 1..100, or 0 for no input smoothing */
++ J_DCT_METHOD dct_method; /* DCT algorithm selector */
++
++ /* The restart interval can be specified in absolute MCUs by setting
++ * restart_interval, or in MCU rows by setting restart_in_rows
++ * (in which case the correct restart_interval will be figured
++ * for each scan).
++ */
++ unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */
++ int restart_in_rows; /* if > 0, MCU rows per restart interval */
++
++ /* Parameters controlling emission of special markers. */
++
++ boolean write_JFIF_header; /* should a JFIF marker be written? */
++ UINT8 JFIF_major_version; /* What to write for the JFIF version number */
++ UINT8 JFIF_minor_version;
++ /* These three values are not used by the JPEG code, merely copied */
++ /* into the JFIF APP0 marker. density_unit can be 0 for unknown, */
++ /* 1 for dots/inch, or 2 for dots/cm. Note that the pixel aspect */
++ /* ratio is defined by X_density/Y_density even when density_unit=0. */
++ UINT8 density_unit; /* JFIF code for pixel size units */
++ UINT16 X_density; /* Horizontal pixel density */
++ UINT16 Y_density; /* Vertical pixel density */
++ boolean write_Adobe_marker; /* should an Adobe marker be written? */
++
++ /* State variable: index of next scanline to be written to
++ * jpeg_write_scanlines(). Application may use this to control its
++ * processing loop, e.g., "while (next_scanline < image_height)".
++ */
++
++ JDIMENSION next_scanline; /* 0 .. image_height-1 */
++
++ /* Remaining fields are known throughout compressor, but generally
++ * should not be touched by a surrounding application.
++ */
++
++ /*
++ * These fields are computed during compression startup
++ */
++ boolean progressive_mode; /* TRUE if scan script uses progressive mode */
++ int max_h_samp_factor; /* largest h_samp_factor */
++ int max_v_samp_factor; /* largest v_samp_factor */
++
++#if JPEG_LIB_VERSION >= 70
++ int min_DCT_h_scaled_size; /* smallest DCT_h_scaled_size of any component */
++ int min_DCT_v_scaled_size; /* smallest DCT_v_scaled_size of any component */
++#endif
++
++ JDIMENSION total_iMCU_rows; /* # of iMCU rows to be input to coef ctlr */
++ /* The coefficient controller receives data in units of MCU rows as defined
++ * for fully interleaved scans (whether the JPEG file is interleaved or not).
++ * There are v_samp_factor * DCTSIZE sample rows of each component in an
++ * "iMCU" (interleaved MCU) row.
++ */
++
++ /*
++ * These fields are valid during any one scan.
++ * They describe the components and MCUs actually appearing in the scan.
++ */
++ int comps_in_scan; /* # of JPEG components in this scan */
++ jpeg_component_info *cur_comp_info[MAX_COMPS_IN_SCAN];
++ /* *cur_comp_info[i] describes component that appears i'th in SOS */
++
++ JDIMENSION MCUs_per_row; /* # of MCUs across the image */
++ JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */
++
++ int blocks_in_MCU; /* # of DCT blocks per MCU */
++ int MCU_membership[C_MAX_BLOCKS_IN_MCU];
++ /* MCU_membership[i] is index in cur_comp_info of component owning */
++ /* i'th block in an MCU */
++
++ int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */
++
++#if JPEG_LIB_VERSION >= 80
++ int block_size; /* the basic DCT block size: 1..16 */
++ const int *natural_order; /* natural-order position array */
++ int lim_Se; /* min( Se, DCTSIZE2-1 ) */
++#endif
++
++ /*
++ * Links to compression subobjects (methods and private variables of modules)
++ */
++ struct jpeg_comp_master *master;
++ struct jpeg_c_main_controller *main;
++ struct jpeg_c_prep_controller *prep;
++ struct jpeg_c_coef_controller *coef;
++ struct jpeg_marker_writer *marker;
++ struct jpeg_color_converter *cconvert;
++ struct jpeg_downsampler *downsample;
++ struct jpeg_forward_dct *fdct;
++ struct jpeg_entropy_encoder *entropy;
++ jpeg_scan_info *script_space; /* workspace for jpeg_simple_progression */
++ int script_space_size;
++};
++
++
++/* Master record for a decompression instance */
++
++struct jpeg_decompress_struct {
++ jpeg_common_fields; /* Fields shared with jpeg_compress_struct */
++
++ /* Source of compressed data */
++ struct jpeg_source_mgr *src;
++
++ /* Basic description of image --- filled in by jpeg_read_header(). */
++ /* Application may inspect these values to decide how to process image. */
++
++ JDIMENSION image_width; /* nominal image width (from SOF marker) */
++ JDIMENSION image_height; /* nominal image height */
++ int num_components; /* # of color components in JPEG image */
++ J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */
++
++ /* Decompression processing parameters --- these fields must be set before
++ * calling jpeg_start_decompress(). Note that jpeg_read_header() initializes
++ * them to default values.
++ */
++
++ J_COLOR_SPACE out_color_space; /* colorspace for output */
++
++ unsigned int scale_num, scale_denom; /* fraction by which to scale image */
++
++ double output_gamma; /* image gamma wanted in output */
++
++ boolean buffered_image; /* TRUE=multiple output passes */
++ boolean raw_data_out; /* TRUE=downsampled data wanted */
++
++ J_DCT_METHOD dct_method; /* IDCT algorithm selector */
++ boolean do_fancy_upsampling; /* TRUE=apply fancy upsampling */
++ boolean do_block_smoothing; /* TRUE=apply interblock smoothing */
++
++ boolean quantize_colors; /* TRUE=colormapped output wanted */
++ /* the following are ignored if not quantize_colors: */
++ J_DITHER_MODE dither_mode; /* type of color dithering to use */
++ boolean two_pass_quantize; /* TRUE=use two-pass color quantization */
++ int desired_number_of_colors; /* max # colors to use in created colormap */
++ /* these are significant only in buffered-image mode: */
++ boolean enable_1pass_quant; /* enable future use of 1-pass quantizer */
++ boolean enable_external_quant;/* enable future use of external colormap */
++ boolean enable_2pass_quant; /* enable future use of 2-pass quantizer */
++
++ /* Description of actual output image that will be returned to application.
++ * These fields are computed by jpeg_start_decompress().
++ * You can also use jpeg_calc_output_dimensions() to determine these values
++ * in advance of calling jpeg_start_decompress().
++ */
++
++ JDIMENSION output_width; /* scaled image width */
++ JDIMENSION output_height; /* scaled image height */
++ int out_color_components; /* # of color components in out_color_space */
++ int output_components; /* # of color components returned */
++ /* output_components is 1 (a colormap index) when quantizing colors;
++ * otherwise it equals out_color_components.
++ */
++ int rec_outbuf_height; /* min recommended height of scanline buffer */
++ /* If the buffer passed to jpeg_read_scanlines() is less than this many rows
++ * high, space and time will be wasted due to unnecessary data copying.
++ * Usually rec_outbuf_height will be 1 or 2, at most 4.
++ */
++
++ /* When quantizing colors, the output colormap is described by these fields.
++ * The application can supply a colormap by setting colormap non-NULL before
++ * calling jpeg_start_decompress; otherwise a colormap is created during
++ * jpeg_start_decompress or jpeg_start_output.
++ * The map has out_color_components rows and actual_number_of_colors columns.
++ */
++ int actual_number_of_colors; /* number of entries in use */
++ JSAMPARRAY colormap; /* The color map as a 2-D pixel array */
++
++ /* State variables: these variables indicate the progress of decompression.
++ * The application may examine these but must not modify them.
++ */
++
++ /* Row index of next scanline to be read from jpeg_read_scanlines().
++ * Application may use this to control its processing loop, e.g.,
++ * "while (output_scanline < output_height)".
++ */
++ JDIMENSION output_scanline; /* 0 .. output_height-1 */
++
++ /* Current input scan number and number of iMCU rows completed in scan.
++ * These indicate the progress of the decompressor input side.
++ */
++ int input_scan_number; /* Number of SOS markers seen so far */
++ JDIMENSION input_iMCU_row; /* Number of iMCU rows completed */
++
++ /* The "output scan number" is the notional scan being displayed by the
++ * output side. The decompressor will not allow output scan/row number
++ * to get ahead of input scan/row, but it can fall arbitrarily far behind.
++ */
++ int output_scan_number; /* Nominal scan number being displayed */
++ JDIMENSION output_iMCU_row; /* Number of iMCU rows read */
++
++ /* Current progression status. coef_bits[c][i] indicates the precision
++ * with which component c's DCT coefficient i (in zigzag order) is known.
++ * It is -1 when no data has yet been received, otherwise it is the point
++ * transform (shift) value for the most recent scan of the coefficient
++ * (thus, 0 at completion of the progression).
++ * This pointer is NULL when reading a non-progressive file.
++ */
++ int (*coef_bits)[DCTSIZE2]; /* -1 or current Al value for each coef */
++
++ /* Internal JPEG parameters --- the application usually need not look at
++ * these fields. Note that the decompressor output side may not use
++ * any parameters that can change between scans.
++ */
++
++ /* Quantization and Huffman tables are carried forward across input
++ * datastreams when processing abbreviated JPEG datastreams.
++ */
++
++ JQUANT_TBL *quant_tbl_ptrs[NUM_QUANT_TBLS];
++ /* ptrs to coefficient quantization tables, or NULL if not defined */
++
++ JHUFF_TBL *dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
++ JHUFF_TBL *ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
++ /* ptrs to Huffman coding tables, or NULL if not defined */
++
++ /* These parameters are never carried across datastreams, since they
++ * are given in SOF/SOS markers or defined to be reset by SOI.
++ */
++
++ int data_precision; /* bits of precision in image data */
++
++ jpeg_component_info *comp_info;
++ /* comp_info[i] describes component that appears i'th in SOF */
++
++#if JPEG_LIB_VERSION >= 80
++ boolean is_baseline; /* TRUE if Baseline SOF0 encountered */
++#endif
++ boolean progressive_mode; /* TRUE if SOFn specifies progressive mode */
++ boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */
++
++ UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */
++ UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */
++ UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */
++
++ unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */
++
++ /* These fields record data obtained from optional markers recognized by
++ * the JPEG library.
++ */
++ boolean saw_JFIF_marker; /* TRUE iff a JFIF APP0 marker was found */
++ /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */
++ UINT8 JFIF_major_version; /* JFIF version number */
++ UINT8 JFIF_minor_version;
++ UINT8 density_unit; /* JFIF code for pixel size units */
++ UINT16 X_density; /* Horizontal pixel density */
++ UINT16 Y_density; /* Vertical pixel density */
++ boolean saw_Adobe_marker; /* TRUE iff an Adobe APP14 marker was found */
++ UINT8 Adobe_transform; /* Color transform code from Adobe marker */
++
++ boolean CCIR601_sampling; /* TRUE=first samples are cosited */
++
++ /* Aside from the specific data retained from APPn markers known to the
++ * library, the uninterpreted contents of any or all APPn and COM markers
++ * can be saved in a list for examination by the application.
++ */
++ jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */
++
++ /* Remaining fields are known throughout decompressor, but generally
++ * should not be touched by a surrounding application.
++ */
++
++ /*
++ * These fields are computed during decompression startup
++ */
++ int max_h_samp_factor; /* largest h_samp_factor */
++ int max_v_samp_factor; /* largest v_samp_factor */
++
++#if JPEG_LIB_VERSION >= 70
++ int min_DCT_h_scaled_size; /* smallest DCT_h_scaled_size of any component */
++ int min_DCT_v_scaled_size; /* smallest DCT_v_scaled_size of any component */
++#else
++ int min_DCT_scaled_size; /* smallest DCT_scaled_size of any component */
++#endif
++
++ JDIMENSION total_iMCU_rows; /* # of iMCU rows in image */
++ /* The coefficient controller's input and output progress is measured in
++ * units of "iMCU" (interleaved MCU) rows. These are the same as MCU rows
++ * in fully interleaved JPEG scans, but are used whether the scan is
++ * interleaved or not. We define an iMCU row as v_samp_factor DCT block
++ * rows of each component. Therefore, the IDCT output contains
++ * v_samp_factor*DCT_[v_]scaled_size sample rows of a component per iMCU row.
++ */
++
++ JSAMPLE *sample_range_limit; /* table for fast range-limiting */
++
++ /*
++ * These fields are valid during any one scan.
++ * They describe the components and MCUs actually appearing in the scan.
++ * Note that the decompressor output side must not use these fields.
++ */
++ int comps_in_scan; /* # of JPEG components in this scan */
++ jpeg_component_info *cur_comp_info[MAX_COMPS_IN_SCAN];
++ /* *cur_comp_info[i] describes component that appears i'th in SOS */
++
++ JDIMENSION MCUs_per_row; /* # of MCUs across the image */
++ JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */
++
++ int blocks_in_MCU; /* # of DCT blocks per MCU */
++ int MCU_membership[D_MAX_BLOCKS_IN_MCU];
++ /* MCU_membership[i] is index in cur_comp_info of component owning */
++ /* i'th block in an MCU */
++
++ int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */
++
++#if JPEG_LIB_VERSION >= 80
++ /* These fields are derived from Se of first SOS marker.
++ */
++ int block_size; /* the basic DCT block size: 1..16 */
++ const int *natural_order; /* natural-order position array for entropy decode */
++ int lim_Se; /* min( Se, DCTSIZE2-1 ) for entropy decode */
++#endif
++
++ /* This field is shared between entropy decoder and marker parser.
++ * It is either zero or the code of a JPEG marker that has been
++ * read from the data source, but has not yet been processed.
++ */
++ int unread_marker;
++
++ /*
++ * Links to decompression subobjects (methods, private variables of modules)
++ */
++ struct jpeg_decomp_master *master;
++ struct jpeg_d_main_controller *main;
++ struct jpeg_d_coef_controller *coef;
++ struct jpeg_d_post_controller *post;
++ struct jpeg_input_controller *inputctl;
++ struct jpeg_marker_reader *marker;
++ struct jpeg_entropy_decoder *entropy;
++ struct jpeg_inverse_dct *idct;
++ struct jpeg_upsampler *upsample;
++ struct jpeg_color_deconverter *cconvert;
++ struct jpeg_color_quantizer *cquantize;
++};
++
++
++/* "Object" declarations for JPEG modules that may be supplied or called
++ * directly by the surrounding application.
++ * As with all objects in the JPEG library, these structs only define the
++ * publicly visible methods and state variables of a module. Additional
++ * private fields may exist after the public ones.
++ */
++
++
++/* Error handler object */
++
++struct jpeg_error_mgr {
++ /* Error exit handler: does not return to caller */
++ void (*error_exit) (j_common_ptr cinfo);
++ /* Conditionally emit a trace or warning message */
++ void (*emit_message) (j_common_ptr cinfo, int msg_level);
++ /* Routine that actually outputs a trace or error message */
++ void (*output_message) (j_common_ptr cinfo);
++ /* Format a message string for the most recent JPEG error or message */
++ void (*format_message) (j_common_ptr cinfo, char *buffer);
++#define JMSG_LENGTH_MAX 200 /* recommended size of format_message buffer */
++ /* Reset error state variables at start of a new image */
++ void (*reset_error_mgr) (j_common_ptr cinfo);
++
++ /* The message ID code and any parameters are saved here.
++ * A message can have one string parameter or up to 8 int parameters.
++ */
++ int msg_code;
++#define JMSG_STR_PARM_MAX 80
++ union {
++ int i[8];
++ char s[JMSG_STR_PARM_MAX];
++ } msg_parm;
++
++ /* Standard state variables for error facility */
++
++ int trace_level; /* max msg_level that will be displayed */
++
++ /* For recoverable corrupt-data errors, we emit a warning message,
++ * but keep going unless emit_message chooses to abort. emit_message
++ * should count warnings in num_warnings. The surrounding application
++ * can check for bad data by seeing if num_warnings is nonzero at the
++ * end of processing.
++ */
++ long num_warnings; /* number of corrupt-data warnings */
++
++ /* These fields point to the table(s) of error message strings.
++ * An application can change the table pointer to switch to a different
++ * message list (typically, to change the language in which errors are
++ * reported). Some applications may wish to add additional error codes
++ * that will be handled by the JPEG library error mechanism; the second
++ * table pointer is used for this purpose.
++ *
++ * First table includes all errors generated by JPEG library itself.
++ * Error code 0 is reserved for a "no such error string" message.
++ */
++ const char * const *jpeg_message_table; /* Library errors */
++ int last_jpeg_message; /* Table contains strings 0..last_jpeg_message */
++ /* Second table can be added by application (see cjpeg/djpeg for example).
++ * It contains strings numbered first_addon_message..last_addon_message.
++ */
++ const char * const *addon_message_table; /* Non-library errors */
++ int first_addon_message; /* code for first string in addon table */
++ int last_addon_message; /* code for last string in addon table */
++};
++
++
++/* Progress monitor object */
++
++struct jpeg_progress_mgr {
++ void (*progress_monitor) (j_common_ptr cinfo);
++
++ long pass_counter; /* work units completed in this pass */
++ long pass_limit; /* total number of work units in this pass */
++ int completed_passes; /* passes completed so far */
++ int total_passes; /* total number of passes expected */
++};
++
++
++/* Data destination object for compression */
++
++struct jpeg_destination_mgr {
++ JOCTET *next_output_byte; /* => next byte to write in buffer */
++ size_t free_in_buffer; /* # of byte spaces remaining in buffer */
++
++ void (*init_destination) (j_compress_ptr cinfo);
++ boolean (*empty_output_buffer) (j_compress_ptr cinfo);
++ void (*term_destination) (j_compress_ptr cinfo);
++};
++
++
++/* Data source object for decompression */
++
++struct jpeg_source_mgr {
++ const JOCTET *next_input_byte; /* => next byte to read from buffer */
++ size_t bytes_in_buffer; /* # of bytes remaining in buffer */
++
++ void (*init_source) (j_decompress_ptr cinfo);
++ boolean (*fill_input_buffer) (j_decompress_ptr cinfo);
++ void (*skip_input_data) (j_decompress_ptr cinfo, long num_bytes);
++ boolean (*resync_to_restart) (j_decompress_ptr cinfo, int desired);
++ void (*term_source) (j_decompress_ptr cinfo);
++};
++
++
++/* Memory manager object.
++ * Allocates "small" objects (a few K total), "large" objects (tens of K),
++ * and "really big" objects (virtual arrays with backing store if needed).
++ * The memory manager does not allow individual objects to be freed; rather,
++ * each created object is assigned to a pool, and whole pools can be freed
++ * at once. This is faster and more convenient than remembering exactly what
++ * to free, especially where malloc()/free() are not too speedy.
++ * NB: alloc routines never return NULL. They exit to error_exit if not
++ * successful.
++ */
++
++#define JPOOL_PERMANENT 0 /* lasts until master record is destroyed */
++#define JPOOL_IMAGE 1 /* lasts until done with image/datastream */
++#define JPOOL_NUMPOOLS 2
++
++typedef struct jvirt_sarray_control *jvirt_sarray_ptr;
++typedef struct jvirt_barray_control *jvirt_barray_ptr;
++
++
++struct jpeg_memory_mgr {
++ /* Method pointers */
++ void *(*alloc_small) (j_common_ptr cinfo, int pool_id, size_t sizeofobject);
++ void *(*alloc_large) (j_common_ptr cinfo, int pool_id,
++ size_t sizeofobject);
++ JSAMPARRAY (*alloc_sarray) (j_common_ptr cinfo, int pool_id,
++ JDIMENSION samplesperrow, JDIMENSION numrows);
++ JBLOCKARRAY (*alloc_barray) (j_common_ptr cinfo, int pool_id,
++ JDIMENSION blocksperrow, JDIMENSION numrows);
++ jvirt_sarray_ptr (*request_virt_sarray) (j_common_ptr cinfo, int pool_id,
++ boolean pre_zero,
++ JDIMENSION samplesperrow,
++ JDIMENSION numrows,
++ JDIMENSION maxaccess);
++ jvirt_barray_ptr (*request_virt_barray) (j_common_ptr cinfo, int pool_id,
++ boolean pre_zero,
++ JDIMENSION blocksperrow,
++ JDIMENSION numrows,
++ JDIMENSION maxaccess);
++ void (*realize_virt_arrays) (j_common_ptr cinfo);
++ JSAMPARRAY (*access_virt_sarray) (j_common_ptr cinfo, jvirt_sarray_ptr ptr,
++ JDIMENSION start_row, JDIMENSION num_rows,
++ boolean writable);
++ JBLOCKARRAY (*access_virt_barray) (j_common_ptr cinfo, jvirt_barray_ptr ptr,
++ JDIMENSION start_row, JDIMENSION num_rows,
++ boolean writable);
++ void (*free_pool) (j_common_ptr cinfo, int pool_id);
++ void (*self_destruct) (j_common_ptr cinfo);
++
++ /* Limit on memory allocation for this JPEG object. (Note that this is
++ * merely advisory, not a guaranteed maximum; it only affects the space
++ * used for virtual-array buffers.) May be changed by outer application
++ * after creating the JPEG object.
++ */
++ long max_memory_to_use;
++
++ /* Maximum allocation request accepted by alloc_large. */
++ long max_alloc_chunk;
++};
++
++
++/* Routine signature for application-supplied marker processing methods.
++ * Need not pass marker code since it is stored in cinfo->unread_marker.
++ */
++typedef boolean (*jpeg_marker_parser_method) (j_decompress_ptr cinfo);
++
++
++/* Originally, this macro was used as a way of defining function prototypes
++ * for both modern compilers as well as older compilers that did not support
++ * prototype parameters. libjpeg-turbo has never supported these older,
++ * non-ANSI compilers, but the macro is still included because there is some
++ * software out there that uses it.
++ */
++
++#define JPP(arglist) arglist
++
++
++/* Default error-management setup */
++EXTERN(struct jpeg_error_mgr *) jpeg_std_error(struct jpeg_error_mgr *err);
++
++/* Initialization of JPEG compression objects.
++ * jpeg_create_compress() and jpeg_create_decompress() are the exported
++ * names that applications should call. These expand to calls on
++ * jpeg_CreateCompress and jpeg_CreateDecompress with additional information
++ * passed for version mismatch checking.
++ * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx.
++ */
++#define jpeg_create_compress(cinfo) \
++ jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \
++ (size_t)sizeof(struct jpeg_compress_struct))
++#define jpeg_create_decompress(cinfo) \
++ jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \
++ (size_t)sizeof(struct jpeg_decompress_struct))
++EXTERN(void) jpeg_CreateCompress(j_compress_ptr cinfo, int version,
++ size_t structsize);
++EXTERN(void) jpeg_CreateDecompress(j_decompress_ptr cinfo, int version,
++ size_t structsize);
++/* Destruction of JPEG compression objects */
++EXTERN(void) jpeg_destroy_compress(j_compress_ptr cinfo);
++EXTERN(void) jpeg_destroy_decompress(j_decompress_ptr cinfo);
++
++/* Standard data source and destination managers: stdio streams. */
++/* Caller is responsible for opening the file before and closing after. */
++EXTERN(void) jpeg_stdio_dest(j_compress_ptr cinfo, FILE *outfile);
++EXTERN(void) jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile);
++
++#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
++/* Data source and destination managers: memory buffers. */
++EXTERN(void) jpeg_mem_dest(j_compress_ptr cinfo, unsigned char **outbuffer,
++ unsigned long *outsize);
++EXTERN(void) jpeg_mem_src(j_decompress_ptr cinfo,
++ const unsigned char *inbuffer, unsigned long insize);
++#endif
++
++/* Default parameter setup for compression */
++EXTERN(void) jpeg_set_defaults(j_compress_ptr cinfo);
++/* Compression parameter setup aids */
++EXTERN(void) jpeg_set_colorspace(j_compress_ptr cinfo,
++ J_COLOR_SPACE colorspace);
++EXTERN(void) jpeg_default_colorspace(j_compress_ptr cinfo);
++EXTERN(void) jpeg_set_quality(j_compress_ptr cinfo, int quality,
++ boolean force_baseline);
++EXTERN(void) jpeg_set_linear_quality(j_compress_ptr cinfo, int scale_factor,
++ boolean force_baseline);
++#if JPEG_LIB_VERSION >= 70
++EXTERN(void) jpeg_default_qtables(j_compress_ptr cinfo,
++ boolean force_baseline);
++#endif
++EXTERN(void) jpeg_add_quant_table(j_compress_ptr cinfo, int which_tbl,
++ const unsigned int *basic_table,
++ int scale_factor, boolean force_baseline);
++EXTERN(int) jpeg_quality_scaling(int quality);
++EXTERN(void) jpeg_simple_progression(j_compress_ptr cinfo);
++EXTERN(void) jpeg_suppress_tables(j_compress_ptr cinfo, boolean suppress);
++EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table(j_common_ptr cinfo);
++EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table(j_common_ptr cinfo);
++
++/* Main entry points for compression */
++EXTERN(void) jpeg_start_compress(j_compress_ptr cinfo,
++ boolean write_all_tables);
++EXTERN(JDIMENSION) jpeg_write_scanlines(j_compress_ptr cinfo,
++ JSAMPARRAY scanlines,
++ JDIMENSION num_lines);
++EXTERN(void) jpeg_finish_compress(j_compress_ptr cinfo);
++
++#if JPEG_LIB_VERSION >= 70
++/* Precalculate JPEG dimensions for current compression parameters. */
++EXTERN(void) jpeg_calc_jpeg_dimensions(j_compress_ptr cinfo);
++#endif
++
++/* Replaces jpeg_write_scanlines when writing raw downsampled data. */
++EXTERN(JDIMENSION) jpeg_write_raw_data(j_compress_ptr cinfo, JSAMPIMAGE data,
++ JDIMENSION num_lines);
++
++/* Write a special marker. See libjpeg.txt concerning safe usage. */
++EXTERN(void) jpeg_write_marker(j_compress_ptr cinfo, int marker,
++ const JOCTET *dataptr, unsigned int datalen);
++/* Same, but piecemeal. */
++EXTERN(void) jpeg_write_m_header(j_compress_ptr cinfo, int marker,
++ unsigned int datalen);
++EXTERN(void) jpeg_write_m_byte(j_compress_ptr cinfo, int val);
++
++/* Alternate compression function: just write an abbreviated table file */
++EXTERN(void) jpeg_write_tables(j_compress_ptr cinfo);
++
++/* Write ICC profile. See libjpeg.txt for usage information. */
++EXTERN(void) jpeg_write_icc_profile(j_compress_ptr cinfo,
++ const JOCTET *icc_data_ptr,
++ unsigned int icc_data_len);
++
++
++/* Decompression startup: read start of JPEG datastream to see what's there */
++EXTERN(int) jpeg_read_header(j_decompress_ptr cinfo, boolean require_image);
++/* Return value is one of: */
++#define JPEG_SUSPENDED 0 /* Suspended due to lack of input data */
++#define JPEG_HEADER_OK 1 /* Found valid image datastream */
++#define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */
++/* If you pass require_image = TRUE (normal case), you need not check for
++ * a TABLES_ONLY return code; an abbreviated file will cause an error exit.
++ * JPEG_SUSPENDED is only possible if you use a data source module that can
++ * give a suspension return (the stdio source module doesn't).
++ */
++
++/* Main entry points for decompression */
++EXTERN(boolean) jpeg_start_decompress(j_decompress_ptr cinfo);
++EXTERN(JDIMENSION) jpeg_read_scanlines(j_decompress_ptr cinfo,
++ JSAMPARRAY scanlines,
++ JDIMENSION max_lines);
++EXTERN(JDIMENSION) jpeg_skip_scanlines(j_decompress_ptr cinfo,
++ JDIMENSION num_lines);
++EXTERN(void) jpeg_crop_scanline(j_decompress_ptr cinfo, JDIMENSION *xoffset,
++ JDIMENSION *width);
++EXTERN(boolean) jpeg_finish_decompress(j_decompress_ptr cinfo);
++
++/* Replaces jpeg_read_scanlines when reading raw downsampled data. */
++EXTERN(JDIMENSION) jpeg_read_raw_data(j_decompress_ptr cinfo, JSAMPIMAGE data,
++ JDIMENSION max_lines);
++
++/* Additional entry points for buffered-image mode. */
++EXTERN(boolean) jpeg_has_multiple_scans(j_decompress_ptr cinfo);
++EXTERN(boolean) jpeg_start_output(j_decompress_ptr cinfo, int scan_number);
++EXTERN(boolean) jpeg_finish_output(j_decompress_ptr cinfo);
++EXTERN(boolean) jpeg_input_complete(j_decompress_ptr cinfo);
++EXTERN(void) jpeg_new_colormap(j_decompress_ptr cinfo);
++EXTERN(int) jpeg_consume_input(j_decompress_ptr cinfo);
++/* Return value is one of: */
++/* #define JPEG_SUSPENDED 0 Suspended due to lack of input data */
++#define JPEG_REACHED_SOS 1 /* Reached start of new scan */
++#define JPEG_REACHED_EOI 2 /* Reached end of image */
++#define JPEG_ROW_COMPLETED 3 /* Completed one iMCU row */
++#define JPEG_SCAN_COMPLETED 4 /* Completed last iMCU row of a scan */
++
++/* Precalculate output dimensions for current decompression parameters. */
++#if JPEG_LIB_VERSION >= 80
++EXTERN(void) jpeg_core_output_dimensions(j_decompress_ptr cinfo);
++#endif
++EXTERN(void) jpeg_calc_output_dimensions(j_decompress_ptr cinfo);
++
++/* Control saving of COM and APPn markers into marker_list. */
++EXTERN(void) jpeg_save_markers(j_decompress_ptr cinfo, int marker_code,
++ unsigned int length_limit);
++
++/* Install a special processing method for COM or APPn markers. */
++EXTERN(void) jpeg_set_marker_processor(j_decompress_ptr cinfo,
++ int marker_code,
++ jpeg_marker_parser_method routine);
++
++/* Read or write raw DCT coefficients --- useful for lossless transcoding. */
++EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients(j_decompress_ptr cinfo);
++EXTERN(void) jpeg_write_coefficients(j_compress_ptr cinfo,
++ jvirt_barray_ptr *coef_arrays);
++EXTERN(void) jpeg_copy_critical_parameters(j_decompress_ptr srcinfo,
++ j_compress_ptr dstinfo);
++
++/* If you choose to abort compression or decompression before completing
++ * jpeg_finish_(de)compress, then you need to clean up to release memory,
++ * temporary files, etc. You can just call jpeg_destroy_(de)compress
++ * if you're done with the JPEG object, but if you want to clean it up and
++ * reuse it, call this:
++ */
++EXTERN(void) jpeg_abort_compress(j_compress_ptr cinfo);
++EXTERN(void) jpeg_abort_decompress(j_decompress_ptr cinfo);
++
++/* Generic versions of jpeg_abort and jpeg_destroy that work on either
++ * flavor of JPEG object. These may be more convenient in some places.
++ */
++EXTERN(void) jpeg_abort(j_common_ptr cinfo);
++EXTERN(void) jpeg_destroy(j_common_ptr cinfo);
++
++/* Default restart-marker-resync procedure for use by data source modules */
++EXTERN(boolean) jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired);
++
++/* Read ICC profile. See libjpeg.txt for usage information. */
++EXTERN(boolean) jpeg_read_icc_profile(j_decompress_ptr cinfo,
++ JOCTET **icc_data_ptr,
++ unsigned int *icc_data_len);
++
++
++/* These marker codes are exported since applications and data source modules
++ * are likely to want to use them.
++ */
++
++#define JPEG_RST0 0xD0 /* RST0 marker code */
++#define JPEG_EOI 0xD9 /* EOI marker code */
++#define JPEG_APP0 0xE0 /* APP0 marker code */
++#define JPEG_COM 0xFE /* COM marker code */
++
++
++/* If we have a brain-damaged compiler that emits warnings (or worse, errors)
++ * for structure definitions that are never filled in, keep it quiet by
++ * supplying dummy definitions for the various substructures.
++ */
++
++#ifdef INCOMPLETE_TYPES_BROKEN
++#ifndef JPEG_INTERNALS /* will be defined in jpegint.h */
++struct jvirt_sarray_control { long dummy; };
++struct jvirt_barray_control { long dummy; };
++struct jpeg_comp_master { long dummy; };
++struct jpeg_c_main_controller { long dummy; };
++struct jpeg_c_prep_controller { long dummy; };
++struct jpeg_c_coef_controller { long dummy; };
++struct jpeg_marker_writer { long dummy; };
++struct jpeg_color_converter { long dummy; };
++struct jpeg_downsampler { long dummy; };
++struct jpeg_forward_dct { long dummy; };
++struct jpeg_entropy_encoder { long dummy; };
++struct jpeg_decomp_master { long dummy; };
++struct jpeg_d_main_controller { long dummy; };
++struct jpeg_d_coef_controller { long dummy; };
++struct jpeg_d_post_controller { long dummy; };
++struct jpeg_input_controller { long dummy; };
++struct jpeg_marker_reader { long dummy; };
++struct jpeg_entropy_decoder { long dummy; };
++struct jpeg_inverse_dct { long dummy; };
++struct jpeg_upsampler { long dummy; };
++struct jpeg_color_deconverter { long dummy; };
++struct jpeg_color_quantizer { long dummy; };
++#endif /* JPEG_INTERNALS */
++#endif /* INCOMPLETE_TYPES_BROKEN */
++
++
++/*
++ * The JPEG library modules define JPEG_INTERNALS before including this file.
++ * The internal structure declarations are read only when that is true.
++ * Applications using the library should not include jpegint.h, but may wish
++ * to include jerror.h.
++ */
++
++#ifdef JPEG_INTERNALS
++#include "jpegint.h" /* fetch private declarations */
++#include "jerror.h" /* fetch error codes too */
++#endif
++
++#ifdef __cplusplus
++#ifndef DONT_USE_EXTERN_C
++}
++#endif
++#endif
++
++#endif /* JPEGLIB_H */
diff --git a/debian/patches/bigendian.patch b/debian/patches/bigendian.patch
deleted file mode 100644
index c3d321e..0000000
--- a/debian/patches/bigendian.patch
+++ /dev/null
@@ -1,40 +0,0 @@
-Description: Remove failing tests on big-endian
- This test has been heavily modified in git/main branch and does not fails
- anymore on big-endian architectures.
-Author: Mathieu Malaterre <ma...@debian.org>
-Bug-Debian: https://bugs.debian.org/1029698
-Forwarded: https://github.com/libjxl/libjxl/issues/2433
-Last-Update: 2023-10-11
-
-Index: libjxl/lib/jpegli/decode_api_test.cc
-===================================================================
---- libjxl.orig/lib/jpegli/decode_api_test.cc
-+++ libjxl/lib/jpegli/decode_api_test.cc
-@@ -143,6 +143,7 @@ bool LoadNextChunk(const TestConfig& con
-
- class DecodeAPITestParam : public ::testing::TestWithParam<TestConfig> {};
-
-+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
- TEST_P(DecodeAPITestParam, TestAPI) {
- TestConfig config = GetParam();
- const std::vector<uint8_t> compressed = ReadTestData(config.fn.c_str());
-@@ -414,6 +415,7 @@ TEST_P(DecodeAPITestParam, TestAPI) {
-
- jpegli_destroy_decompress(&cinfo);
- }
-+#endif
-
- std::vector<TestConfig> GenerateTests() {
- std::vector<TestConfig> all_tests;
-@@ -590,9 +592,11 @@ std::string TestDescription(
- return name.str();
- }
-
-+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
- JPEGLI_INSTANTIATE_TEST_SUITE_P(DecodeAPITest, DecodeAPITestParam,
- testing::ValuesIn(GenerateTests()),
- TestDescription);
-+#endif
-
- } // namespace
- } // namespace jpegli
diff --git a/debian/patches/continuefinalnonessentialboxtest.patch b/debian/patches/continuefinalnonessentialboxtest.patch
deleted file mode 100644
index 563d460..0000000
--- a/debian/patches/continuefinalnonessentialboxtest.patch
+++ /dev/null
@@ -1,18 +0,0 @@
-Description: Remove failing test for now
-Author: Mathieu Malaterre <ma...@debian.org>
-Forwarded: https://github.com/libjxl/libjxl/issues/1710
-Last-Update: 2022-08-22
-
-Index: libjxl/lib/jxl/decode_test.cc
-===================================================================
---- libjxl.orig/lib/jxl/decode_test.cc
-+++ libjxl/lib/jxl/decode_test.cc
-@@ -4862,7 +4862,7 @@ TEST(DecodeTest, JXL_TRANSCODE_JPEG_TEST
- VerifyJPEGReconstruction(jxl, jpeg);
- }
-
--TEST(DecodeTest, ContinueFinalNonEssentialBoxTest) {
-+TEST(DecodeTest, DISABLED_ContinueFinalNonEssentialBoxTest) {
- size_t xsize = 80, ysize = 90;
- std::vector<uint8_t> pixels = jxl::test::GetSomeTestImage(xsize, ysize, 4, 0);
- jxl::TestCodestreamParams params;
diff --git a/debian/patches/do_not_force_cxx11.patch b/debian/patches/do_not_force_cxx11.patch
index 0e43555..f17cf68 100644
--- a/debian/patches/do_not_force_cxx11.patch
+++ b/debian/patches/do_not_force_cxx11.patch
@@ -9,7 +9,7 @@ Index: libjxl/CMakeLists.txt
===================================================================
--- libjxl.orig/CMakeLists.txt
+++ libjxl/CMakeLists.txt
-@@ -210,9 +210,9 @@ find_package(Threads REQUIRED)
+@@ -246,9 +246,9 @@ find_package(Threads REQUIRED)
# These settings are important to drive check_cxx_source_compiles
# See CMP0067 (min cmake version is 3.10 anyway)
@@ -25,12 +25,12 @@ Index: libjxl/lib/CMakeLists.txt
===================================================================
--- libjxl.orig/lib/CMakeLists.txt
+++ libjxl/lib/CMakeLists.txt
-@@ -39,7 +39,7 @@ set(JPEGXL_INTERNAL_FLAGS
- # WARN_FLAGS
- -Wall
- -Wextra
-- -Wc++11-compat
-+ -Wc++17-compat
- -Warray-bounds
- -Wformat-security
- -Wimplicit-fallthrough
+@@ -39,7 +39,7 @@ else ()
+ # WARN_FLAGS
+ -Wall
+ -Wextra
+- -Wc++11-compat
++ -Wc++17-compat
+ -Warray-bounds
+ -Wformat-security
+ -Wimplicit-fallthrough
diff --git a/debian/patches/f0973c3bb1203b2382cd7c7251de584fa693273c.patch b/debian/patches/f0973c3bb1203b2382cd7c7251de584fa693273c.patch
deleted file mode 100644
index 6ed98a5..0000000
--- a/debian/patches/f0973c3bb1203b2382cd7c7251de584fa693273c.patch
+++ /dev/null
@@ -1,56 +0,0 @@
-From f0973c3bb1203b2382cd7c7251de584fa693273c Mon Sep 17 00:00:00 2001
-From: Sami Boukortt <sbouko...@google.com>
-Date: Mon, 26 Jun 2023 15:06:17 +0200
-Subject: [PATCH] Fix decode_test with lcms2
-
-Co-authored-by: Zoltan Szabadka <szaba...@google.com>
-Co-authored-by: Luca Versari <vel...@google.com>
----
- lib/jxl/decode_test.cc | 17 +++++++++++------
- 1 file changed, 11 insertions(+), 6 deletions(-)
-
-Index: libjxl/lib/jxl/decode_test.cc
-===================================================================
---- libjxl.orig/lib/jxl/decode_test.cc
-+++ libjxl/lib/jxl/decode_test.cc
-@@ -3736,13 +3736,18 @@ void AnalyzeCodestream(const jxl::Padded
- jxl::Span<const uint8_t>(codestream.data(), codestream.size()));
- ASSERT_EQ(br.ReadFixedBits<16>(), 0x0AFF);
- jxl::CodecMetadata metadata;
-- EXPECT_TRUE(ReadSizeHeader(&br, &metadata.size));
-- EXPECT_TRUE(ReadImageMetadata(&br, &metadata.m));
-+ ASSERT_TRUE(ReadSizeHeader(&br, &metadata.size));
-+ ASSERT_TRUE(ReadImageMetadata(&br, &metadata.m));
- streampos->basic_info =
- add_offset(br.TotalBitsConsumed() / jxl::kBitsPerByte);
- metadata.transform_data.nonserialized_xyb_encoded = metadata.m.xyb_encoded;
-- EXPECT_TRUE(jxl::Bundle::Read(&br, &metadata.transform_data));
-- EXPECT_TRUE(br.JumpToByteBoundary());
-+ ASSERT_TRUE(jxl::Bundle::Read(&br, &metadata.transform_data));
-+ if (metadata.m.color_encoding.WantICC()) {
-+ jxl::PaddedBytes icc;
-+ ASSERT_TRUE(jxl::ReadICC(&br, &icc));
-+ ASSERT_TRUE(metadata.m.color_encoding.SetICCRaw(std::move(icc)));
-+ }
-+ ASSERT_TRUE(br.JumpToByteBoundary());
- bool has_preview = metadata.m.have_preview;
- while (br.TotalBitsConsumed() < br.TotalBytes() * jxl::kBitsPerByte) {
- FramePositions p;
-@@ -3752,7 +3757,7 @@ void AnalyzeCodestream(const jxl::Padded
- frame_header.nonserialized_is_preview = true;
- has_preview = false;
- }
-- EXPECT_TRUE(ReadFrameHeader(&br, &frame_header));
-+ ASSERT_TRUE(ReadFrameHeader(&br, &frame_header));
- p.header_end =
- add_offset(jxl::DivCeil(br.TotalBitsConsumed(), jxl::kBitsPerByte));
- jxl::FrameDimensions frame_dim = frame_header.ToFrameDimensions();
-@@ -3762,7 +3767,7 @@ void AnalyzeCodestream(const jxl::Padded
- frame_header.passes.num_passes, /*has_ac_global=*/true);
- std::vector<uint64_t> section_offsets;
- std::vector<uint32_t> section_sizes;
-- EXPECT_TRUE(ReadGroupOffsets(toc_entries, &br, §ion_offsets,
-+ ASSERT_TRUE(ReadGroupOffsets(toc_entries, &br, §ion_offsets,
- §ion_sizes, &groups_total_size));
- EXPECT_EQ(br.TotalBitsConsumed() % jxl::kBitsPerByte, 0);
- size_t sections_start = br.TotalBitsConsumed() / jxl::kBitsPerByte;
diff --git a/debian/patches/hwy.patch b/debian/patches/hwy.patch
deleted file mode 100644
index b035c0c..0000000
--- a/debian/patches/hwy.patch
+++ /dev/null
@@ -1,177 +0,0 @@
-Description: Transition to hwy config.cmake
-Author: Mathieu Malaterre <ma...@debian.org>
-Forwarded: no
-Last-Update: 2023-02-01
-
-Index: libjxl/third_party/CMakeLists.txt
-===================================================================
---- libjxl.orig/third_party/CMakeLists.txt
-+++ libjxl/third_party/CMakeLists.txt
-@@ -30,7 +30,7 @@ if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/
- configure_file("${CMAKE_CURRENT_SOURCE_DIR}/highway/LICENSE"
- ${PROJECT_BINARY_DIR}/LICENSE.highway COPYONLY)
- else()
-- find_package(HWY 0.15.0)
-+ find_package(HWY 1.0.0)
- if (NOT HWY_FOUND)
- message(FATAL_ERROR
- "Highway library (hwy) not found. Install libhwy-dev or download it "
-Index: libjxl/lib/jxl.cmake
-===================================================================
---- libjxl.orig/lib/jxl.cmake
-+++ libjxl/lib/jxl.cmake
-@@ -365,7 +365,7 @@ set(JPEGXL_INTERNAL_SOURCES_ENC
- set_source_files_properties(jxl/enc_fast_lossless.cc PROPERTIES COMPILE_FLAGS -O3)
-
- set(JPEGXL_DEC_INTERNAL_LIBS
-- hwy
-+ hwy::hwy
- Threads::Threads
- ${ATOMICS_LIBRARIES}
- )
-@@ -425,7 +425,7 @@ set_property(TARGET jxl_dec-obj PROPERTY
- target_include_directories(jxl_dec-obj PUBLIC
- "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>"
- "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
-- "$<BUILD_INTERFACE:$<TARGET_PROPERTY:hwy,INTERFACE_INCLUDE_DIRECTORIES>>"
-+ "$<BUILD_INTERFACE:$<TARGET_PROPERTY:hwy::hwy,INTERFACE_INCLUDE_DIRECTORIES>>"
- "$<BUILD_INTERFACE:$<TARGET_PROPERTY:brotlicommon-static,INTERFACE_INCLUDE_DIRECTORIES>>"
- )
- target_compile_definitions(jxl_dec-obj PUBLIC
-@@ -443,7 +443,7 @@ set_property(TARGET jxl_enc-obj PROPERTY
- target_include_directories(jxl_enc-obj PUBLIC
- ${PROJECT_SOURCE_DIR}
- ${CMAKE_CURRENT_SOURCE_DIR}/include
-- $<TARGET_PROPERTY:hwy,INTERFACE_INCLUDE_DIRECTORIES>
-+ $<TARGET_PROPERTY:hwy::hwy,INTERFACE_INCLUDE_DIRECTORIES>
- $<TARGET_PROPERTY:brotlicommon-static,INTERFACE_INCLUDE_DIRECTORIES>
- )
- target_compile_definitions(jxl_enc-obj PUBLIC
-Index: libjxl/lib/jxl_extras.cmake
-===================================================================
---- libjxl.orig/lib/jxl_extras.cmake
-+++ libjxl/lib/jxl_extras.cmake
-@@ -81,7 +81,7 @@ target_include_directories(jxl_extras_co
- ${PROJECT_SOURCE_DIR}
- ${CMAKE_CURRENT_SOURCE_DIR}/include
- ${CMAKE_CURRENT_BINARY_DIR}/include
-- $<TARGET_PROPERTY:hwy,INTERFACE_INCLUDE_DIRECTORIES>
-+ $<TARGET_PROPERTY:hwy::hwy,INTERFACE_INCLUDE_DIRECTORIES>
- )
- set(JXL_EXTRAS_CODEC_INTERNAL_LIBRARIES)
- set(JXL_EXTRAS_CODEC_PUBLIC_COMPILE_DEFINITIONS)
-Index: libjxl/CMakeLists.txt
-===================================================================
---- libjxl.orig/CMakeLists.txt
-+++ libjxl/CMakeLists.txt
-@@ -22,6 +22,8 @@ if(POLICY CMP0083)
- endif()
-
- project(LIBJXL LANGUAGES C CXX)
-+# Make sure HWY variable are at top-level:
-+find_package(HWY 1.0.0 REQUIRED)
-
- include(CheckCXXSourceCompiles)
- check_cxx_source_compiles(
-Index: libjxl/cmake/FindHWY.cmake
-===================================================================
---- libjxl.orig/cmake/FindHWY.cmake
-+++ /dev/null
-@@ -1,66 +0,0 @@
--# Copyright (c) the JPEG XL Project Authors. All rights reserved.
--#
--# Use of this source code is governed by a BSD-style
--# license that can be found in the LICENSE file.
--
--find_package(PkgConfig QUIET)
--if (PkgConfig_FOUND)
-- pkg_check_modules(PC_HWY QUIET libhwy)
-- set(HWY_VERSION ${PC_HWY_VERSION})
--endif ()
--
--find_path(HWY_INCLUDE_DIR
-- NAMES hwy/highway.h
-- HINTS ${PC_HWY_INCLUDEDIR} ${PC_HWY_INCLUDE_DIRS}
--)
--
--find_library(HWY_LIBRARY
-- NAMES ${HWY_NAMES} hwy
-- HINTS ${PC_HWY_LIBDIR} ${PC_HWY_LIBRARY_DIRS}
--)
--
--if (HWY_INCLUDE_DIR AND NOT HWY_VERSION)
-- if (EXISTS "${HWY_INCLUDE_DIR}/hwy/highway.h")
-- file(READ "${HWY_INCLUDE_DIR}/hwy/highway.h" HWY_VERSION_CONTENT)
--
-- string(REGEX MATCH "#define HWY_MAJOR +([0-9]+)" _dummy "${HWY_VERSION_CONTENT}")
-- set(HWY_VERSION_MAJOR "${CMAKE_MATCH_1}")
--
-- string(REGEX MATCH "#define +HWY_MINOR +([0-9]+)" _dummy "${HWY_VERSION_CONTENT}")
-- set(HWY_VERSION_MINOR "${CMAKE_MATCH_1}")
--
-- string(REGEX MATCH "#define +HWY_PATCH +([0-9]+)" _dummy "${HWY_VERSION_CONTENT}")
-- set(HWY_VERSION_PATCH "${CMAKE_MATCH_1}")
--
-- set(HWY_VERSION "${HWY_VERSION_MAJOR}.${HWY_VERSION_MINOR}.${HWY_VERSION_PATCH}")
-- endif ()
--endif ()
--
--include(FindPackageHandleStandardArgs)
--find_package_handle_standard_args(HWY
-- FOUND_VAR HWY_FOUND
-- REQUIRED_VARS HWY_LIBRARY HWY_INCLUDE_DIR
-- VERSION_VAR HWY_VERSION
--)
--
--if (HWY_LIBRARY AND NOT TARGET hwy)
-- add_library(hwy INTERFACE IMPORTED GLOBAL)
--
-- if(CMAKE_VERSION VERSION_LESS "3.13.5")
-- set_property(TARGET hwy PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${HWY_INCLUDE_DIR})
-- target_link_libraries(hwy INTERFACE ${HWY_LIBRARY})
-- set_property(TARGET hwy PROPERTY INTERFACE_COMPILE_OPTIONS ${PC_HWY_CFLAGS_OTHER})
-- else()
-- target_include_directories(hwy INTERFACE ${HWY_INCLUDE_DIR})
-- target_link_libraries(hwy INTERFACE ${HWY_LIBRARY})
-- target_link_options(hwy INTERFACE ${PC_HWY_LDFLAGS_OTHER})
-- target_compile_options(hwy INTERFACE ${PC_HWY_CFLAGS_OTHER})
-- endif()
--endif()
--
--mark_as_advanced(HWY_INCLUDE_DIR HWY_LIBRARY)
--
--if (HWY_FOUND)
-- set(HWY_LIBRARIES ${HWY_LIBRARY})
-- set(HWY_INCLUDE_DIRS ${HWY_INCLUDE_DIR})
--endif ()
-Index: libjxl/lib/jpegli.cmake
-===================================================================
---- libjxl.orig/lib/jpegli.cmake
-+++ libjxl/lib/jpegli.cmake
-@@ -41,7 +41,7 @@ set(JPEGLI_INTERNAL_SOURCES
- )
-
- set(JPEGLI_INTERNAL_LIBS
-- hwy
-+ hwy::hwy
- jxl-static
- Threads::Threads
- ${ATOMICS_LIBRARIES}
-@@ -55,7 +55,7 @@ target_include_directories(jpegli-static
- "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>"
- "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
- "$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>"
-- "$<BUILD_INTERFACE:$<TARGET_PROPERTY:hwy,INTERFACE_INCLUDE_DIRECTORIES>>"
-+ "$<BUILD_INTERFACE:$<TARGET_PROPERTY:hwy::hwy,INTERFACE_INCLUDE_DIRECTORIES>>"
- )
- target_include_directories(jpegli-static PUBLIC "${JPEG_INCLUDE_DIRS}")
- target_link_libraries(jpegli-static PUBLIC ${JPEGLI_INTERNAL_LIBS})
-@@ -86,7 +86,7 @@ foreach (TESTFILE IN LISTS TEST_FILES)
- -DTEST_DATA_PATH="${JPEGXL_TEST_DATA_PATH}")
- target_include_directories(${TESTNAME} PRIVATE "${PROJECT_SOURCE_DIR}")
- target_link_libraries(${TESTNAME}
-- hwy
-+ hwy::hwy
- jpegli-static
- gmock
- GTest::GTest
diff --git a/debian/patches/series b/debian/patches/series
index f439561..cb38fb5 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,10 +1,3 @@
do_not_force_cxx11.patch
-continuefinalnonessentialboxtest.patch
manpages.patch
-0008-Fix-conformance-test.patch
-0009-fast_dct-inl.h-Include-std-headers-to-solve-missing-.patch
-hwy.patch
-383df4487f59da140fd1ce112548a2cd11e4eaeb.patch
-f0973c3bb1203b2382cd7c7251de584fa693273c.patch
-22d12d74e7bc56b09cfb1973aa89ec8d714fa3fc.patch
-bigendian.patch
+add_headers.patch
diff --git a/debian/rules b/debian/rules
index d04aa54..e6bb0c6 100755
--- a/debian/rules
+++ b/debian/rules
@@ -24,9 +24,6 @@ ifneq (,$(filter $(DEB_HOST_ARCH), armhf))
DEB_CXXFLAGS_MAINT_APPEND += -fno-tree-vectorize
endif
-# Temp fix for 0.7.0-10.x i386/s390x build; see https://bugs.debian.org/1053641
-DEB_CXXFLAGS_MAINT_APPEND += -fexcess-precision=fast
-
ifneq (,$(filter $(DEB_HOST_ARCH), arm64 armel armhf ppc64el))
# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77728
DEB_CXXFLAGS_MAINT_APPEND += -Wno-psabi
@@ -62,8 +59,13 @@ CMAKE_EXTRA_FLAGS += \
-DJPEGXL_ENABLE_DOXYGEN:BOOL=$(ENABLE_DOXYGEN) \
-DJPEGXL_ENABLE_EXAMPLES:BOOL=ON \
-DJPEGXL_ENABLE_JNI:BOOL=$(ENABLE_JNI) \
+ -DJPEGXL_ENABLE_JPEGLI:BOOL=ON \
+ -DJPEGXL_ENABLE_JPEGLI_LIBJPEG:BOOL=ON \
-DJPEGXL_ENABLE_OPENEXR:BOOL=ON \
- -DJPEGXL_ENABLE_PLUGINS:BOOL=OFF \
+ -DJPEGXL_ENABLE_PLUGINS:BOOL=ON \
+ -DJPEGXL_ENABLE_PLUGIN_GDKPIXBUF:BOOL=ON \
+ -DJPEGXL_ENABLE_PLUGIN_GIMP210:BOOL=OFF \
+ -DJPEGXL_ENABLE_PLUGIN_MIME:BOOL=OFF \
-DJPEGXL_ENABLE_SJPEG:BOOL=OFF \
-DJPEGXL_ENABLE_SKCMS:BOOL=OFF \
-DJPEGXL_ENABLE_TCMALLOC:BOOL=$(ENABLE_TCMALLOC) \
@@ -73,6 +75,7 @@ CMAKE_EXTRA_FLAGS += \
-DJPEGXL_FORCE_SYSTEM_LCMS2:BOOL=ON \
-DJPEGXL_INSTALL_JARDIR:PATH=share/java \
-DJPEGXL_INSTALL_JNIDIR:PATH=lib/$(DEB_HOST_MULTIARCH)/jni \
+ -DJPEGXL_INSTALL_JPEGLI_LIBJPEG:BOOL=ON \
-DJPEGXL_TEST_DATA_PATH:PATH=/usr/share/libjxl-testdata \
override_dh_auto_configure:
@@ -83,6 +86,13 @@ override_dh_auto_build-indep:
override_dh_auto_install-indep:
+override_dh_install-arch:
+ mkdir -p ./debian/tmp/usr/lib/$(DEB_HOST_MULTIARCH)/pkgconfig/
+ cp -v /usr/lib/$(DEB_HOST_MULTIARCH)/pkgconfig/libjpeg.pc ./debian/tmp/usr/lib/$(DEB_HOST_MULTIARCH)/pkgconfig/libjpeg.pc
+ mkdir -p ./debian/tmp/usr/include/$(DEB_HOST_MULTIARCH)/
+ mv -v ./debian/tmp/usr/include/jconfig.h ./debian/tmp/usr/include/$(DEB_HOST_MULTIARCH)/jconfig.h
+ dh_install --
+
override_dh_install-indep:
dh_install -X.md5 -pjpeg-xl-doc obj-*/html usr/share/doc/jpeg-xl-doc
@@ -112,10 +122,10 @@ debian/%.1: debian/%.1.in
.PHONY: tools_manpages devtools_manpages get-orig-source
-tools_manpages: debian/cjpeg_hdr.1 debian/jxlinfo.1
+tools_manpages: debian/jxlinfo.1 debian/cjpegli.1 debian/djpegli.1
echo "all tools manpages generated"
-devtools_manpages: debian/butteraugli_main.1 debian/decode_and_encode.1 debian/display_to_hlg.1 debian/fuzzer_corpus.1 debian/generate_lut_template.1 debian/jxl_from_tree.1 debian/pq_to_hlg.1 debian/render_hlg.1 debian/ssimulacra_main.1 debian/texture_to_cube.1 debian/tone_map.1 debian/xyb_range.1 debian/benchmark_xl.1
+devtools_manpages: debian/butteraugli_main.1 debian/decode_and_encode.1 debian/display_to_hlg.1 debian/generate_lut_template.1 debian/jxl_from_tree.1 debian/pq_to_hlg.1 debian/render_hlg.1 debian/ssimulacra_main.1 debian/texture_to_cube.1 debian/tone_map.1 debian/xyb_range.1 debian/benchmark_xl.1
echo $(DEVTOOLS)
echo "all devtools manpages generated"
