Bump libjxl to 0.10

Co-authored-by: Luca Versari <veluca93@gmail.com>

Author: palemieux

.gitmodules

@@ -3,7 +3,7 @@
 	url = https://github.com/phoboslab/qoi.git
 [submodule "ext/libjxl"]
 	path = ext/libjxl
-	url = https://github.com/palemieux/libjxl.git
+	url = https://github.com/libjxl/libjxl.git
 [submodule "ext/OpenJPH"]
 	path = ext/OpenJPH
 	url = https://github.com/aous72/OpenJPH.git

CMakeLists.txt

@@ -49,9 +49,8 @@ set(JPEGXL_ENABLE_OPENEXR FALSE CACHE INTERNAL "" FORCE)
 set(JPEGXL_ENABLE_TRANSCODE_JPEG FALSE CACHE INTERNAL "" FORCE)
 set(JPEGXL_BUNDLE_SKCMS FALSE CACHE INTERNAL "" FORCE)
 set(JPEGXL_ENABLE_MANPAGES FALSE CACHE INTERNAL "" FORCE)
-include_directories(ext/libjxl/experimental/fast_lossless ext/libjxl/lib/include "${PROJECT_BINARY_DIR}/ext/libjxl/lib/include")
-add_library(fast_lossless ext/libjxl/experimental/fast_lossless/fast_lossless.cc)
-add_subdirectory(ext/libjxl EXCLUDE_FROM_ALL)
+set(JPEGXL_ENABLE_AVX512 TRUE CACHE INTERNAL "" FORCE)
+add_subdirectory(ext/libjxl)
 
 # ffmpeg
 
@@ -68,6 +67,7 @@ ExternalProject_Add(ffmpeg
 )
 include_directories(${PROJECT_BINARY_DIR}/ext/ffmpeg/include)
 add_library(libavcodec STATIC IMPORTED)
+target_link_libraries(libavcodec INTERFACE pthread)
 add_dependencies(libavcodec ffmpeg)
 set_target_properties(libavcodec PROPERTIES IMPORTED_LOCATION ${FFMPEG_INSTALL_DIR}/lib/libavcodec.a)
 add_library(libavutil STATIC IMPORTED)
@@ -83,7 +83,7 @@ add_library(md5 ext/crypto-algorithms/md5.c)
 
 file(GLOB LIBENCH_SRC_FILES src/main/cpp/*)
 add_executable(libench ${LIBENCH_SRC_FILES} ext/lodepng/lodepng.cpp)
-target_link_libraries(libench openjph md5 jxl jxl_threads fast_lossless libavcodec libavutil ${KDU_LIBRARY} ${CMAKE_DL_LIBS})
+target_link_libraries(libench openjph md5 jxl libavcodec libavutil ${KDU_LIBRARY} ${CMAKE_DL_LIBS})
 
 # tests
 

ext/libjxl

@@ -1,47 +1,116 @@
 #include "jxl_codec.h"
-#include <inttypes.h>
+#include "jxl/decode_cxx.h"
+#include "jxl/encode_cxx.h"
+#include "jxl/types.h"
 #include <climits>
+#include <cstdlib>
+#include <inttypes.h>
+#include <jxl/encode.h>
 #include <memory>
 #include <stdexcept>
 #include <vector>
-#include "fast_lossless.h"
-#include "jxl/decode_cxx.h"
-#include "jxl/encode_cxx.h"
-#include "jxl/resizable_parallel_runner_cxx.h"
-#include "jxl/thread_parallel_runner_cxx.h"
 
 /*
  * JXLEncoder
  */
 
-template class libench::JXLEncoder<0>;
+template class libench::JXLEncoder<1>;
 template class libench::JXLEncoder<2>;
+template class libench::JXLEncoder<3>;
 
-template <int E>
-libench::JXLEncoder<E>::JXLEncoder(){};
+template <int E> libench::JXLEncoder<E>::JXLEncoder(){};
 
-template <int E>
-libench::JXLEncoder<E>::~JXLEncoder() {
+template <int E> libench::JXLEncoder<E>::~JXLEncoder() {
   free(this->cb_.codestream);
 };
 
-template <int E>
-libench::CodestreamContext libench::JXLEncoder<E>::encodeRGB8(const ImageContext &image) {
-  free(this->cb_.codestream);
+template <int E, bool rgba>
+static size_t JxlEncode(void *image_data, size_t width, size_t height,
+                        uint8_t **encoded) {
+  auto enc = JxlEncoderMake(/*memory_manager=*/nullptr);
+
+  JxlPixelFormat pixel_format = {rgba ? 4 : 3, JXL_TYPE_UINT8,
+                                 JXL_NATIVE_ENDIAN, 0};
+
+  JxlBasicInfo basic_info;
+  JxlEncoderInitBasicInfo(&basic_info);
+  basic_info.xsize = width;
+  basic_info.ysize = height;
+  basic_info.bits_per_sample = 8;
+  basic_info.exponent_bits_per_sample = 0;
+  basic_info.uses_original_profile = JXL_TRUE;
+  if (rgba) {
+    basic_info.alpha_bits = 8;
+    basic_info.num_extra_channels = 1;
+  }
+  if (JXL_ENC_SUCCESS != JxlEncoderSetBasicInfo(enc.get(), &basic_info)) {
+    throw std::runtime_error("JxlEncoderSetBasicInfo failed\n");
+  }
 
-  this->cb_.size = FastLosslessEncode(image.planes8[0], image.width, image.width * 3, image.height, 3, 8, E,
-                                      &this->cb_.codestream);
+  JxlColorEncoding color_encoding = {};
+  JxlColorEncodingSetToSRGB(&color_encoding, false);
+  if (JXL_ENC_SUCCESS !=
+      JxlEncoderSetColorEncoding(enc.get(), &color_encoding)) {
+    throw std::runtime_error("JxlEncoderSetColorEncoding failed\n");
+  }
 
-  return this->cb_;
+  JxlEncoderFrameSettings *frame_settings =
+      JxlEncoderFrameSettingsCreate(enc.get(), nullptr);
+
+  if (JXL_ENC_SUCCESS != JxlEncoderSetFrameLossless(frame_settings, JXL_TRUE)) {
+    throw std::runtime_error("JxlEncoderSetFrameLossless failed\n");
+  }
+
+  if (JXL_ENC_SUCCESS != JxlEncoderFrameSettingsSetOption(
+                             frame_settings, JXL_ENC_FRAME_SETTING_EFFORT, E)) {
+    throw std::runtime_error("JxlEncoderFrameSettingsSetOption failed\n");
+  }
+
+  if (JXL_ENC_SUCCESS !=
+      JxlEncoderAddImageFrame(frame_settings, &pixel_format,
+                              static_cast<const void *>(image_data),
+                              pixel_format.num_channels * width * height)) {
+    throw std::runtime_error("JxlEncoderAddImageFrame failed\n");
+  }
+  JxlEncoderCloseInput(enc.get());
+
+  size_t size = pixel_format.num_channels * width * height;
+  *encoded = (uint8_t *)malloc(size);
+  uint8_t *next_out = *encoded;
+  size_t avail_out = size - (next_out - *encoded);
+  JxlEncoderStatus process_result = JXL_ENC_NEED_MORE_OUTPUT;
+  while (process_result == JXL_ENC_NEED_MORE_OUTPUT) {
+    process_result = JxlEncoderProcessOutput(enc.get(), &next_out, &avail_out);
+    if (process_result == JXL_ENC_NEED_MORE_OUTPUT) {
+      size_t offset = next_out - *encoded;
+      size *= 2;
+      *encoded = (uint8_t *)realloc(*encoded, size);
+      next_out = *encoded + offset;
+      avail_out = size - offset;
+    }
+  }
+  if (JXL_ENC_SUCCESS != process_result) {
+    throw std::runtime_error("JxlEncoderProcessOutput failed\n");
+  }
+
+  return next_out - *encoded;
 }
 
 template <int E>
-libench::CodestreamContext libench::JXLEncoder<E>::encodeRGBA8(const ImageContext &image) {
+libench::CodestreamContext
+libench::JXLEncoder<E>::encodeRGB8(const ImageContext &image) {
   free(this->cb_.codestream);
+  cb_.size = JxlEncode<E, false>(image.planes8[0], image.width, image.height,
+                                 &cb_.codestream);
+  return this->cb_;
+}
 
-  this->cb_.size = FastLosslessEncode(image.planes8[0], image.width, image.width * 4, image.height, 4, 8, E,
-                                      &this->cb_.codestream);
-
+template <int E>
+libench::CodestreamContext
+libench::JXLEncoder<E>::encodeRGBA8(const ImageContext &image) {
+  free(this->cb_.codestream);
+  cb_.size = JxlEncode<E, true>(image.planes8[0], image.width, image.height,
+                                &cb_.codestream);
   return this->cb_;
 }
 
@@ -51,21 +120,22 @@ libench::CodestreamContext libench::JXLEncoder<E>::encodeRGBA8(const ImageContex
 
 libench::JXLDecoder::JXLDecoder(){};
 
-libench::ImageContext libench::JXLDecoder::decodeRGB8(const CodestreamContext& cs) {
+libench::ImageContext
+libench::JXLDecoder::decodeRGB8(const CodestreamContext &cs) {
   return this->decode8(cs, 3);
 }
 
-libench::ImageContext libench::JXLDecoder::decodeRGBA8(const CodestreamContext& cs) {
+libench::ImageContext
+libench::JXLDecoder::decodeRGBA8(const CodestreamContext &cs) {
   return this->decode8(cs, 4);
 }
 
-libench::ImageContext libench::JXLDecoder::decode8(const CodestreamContext& cs, uint8_t num_comps) {
+libench::ImageContext libench::JXLDecoder::decode8(const CodestreamContext &cs,
+                                                   uint8_t num_comps) {
   libench::ImageContext image;
 
-  image.format = num_comps == 3 ? libench::ImageFormat::RGB8 : libench::ImageFormat::RGBA8;
-
-  // Multi-threaded parallel runner.
-  auto runner = JxlResizableParallelRunnerMake(nullptr);
+  image.format =
+      num_comps == 3 ? libench::ImageFormat::RGB8 : libench::ImageFormat::RGBA8;
 
   auto dec = JxlDecoderMake(nullptr);
   if (JXL_DEC_SUCCESS !=
@@ -75,12 +145,6 @@ libench::ImageContext libench::JXLDecoder::decode8(const CodestreamContext& cs,
     throw std::runtime_error("JxlDecoderSubscribeEvents failed\n");
   }
 
-  if (JXL_DEC_SUCCESS != JxlDecoderSetParallelRunner(dec.get(),
-                                                     JxlResizableParallelRunner,
-                                                     runner.get())) {
-    throw std::runtime_error("JxlDecoderSetParallelRunner failed\n");
-  }
-
   JxlBasicInfo info;
   JxlPixelFormat format = {num_comps, JXL_TYPE_UINT8, JXL_NATIVE_ENDIAN, 0};
 
@@ -100,21 +164,17 @@ libench::ImageContext libench::JXLDecoder::decode8(const CodestreamContext& cs,
       }
       image.width = info.xsize;
       image.height = info.ysize;
-      JxlResizableParallelRunnerSetThreads(
-          runner.get(),
-          JxlResizableParallelRunnerSuggestThreads(info.xsize, info.ysize));
     } else if (status == JXL_DEC_COLOR_ENCODING) {
       // Get the ICC color profile of the pixel data (but ignore it)
       size_t icc_size;
       if (JXL_DEC_SUCCESS !=
-          JxlDecoderGetICCProfileSize(
-              dec.get(), &format, JXL_COLOR_PROFILE_TARGET_DATA, &icc_size)) {
+          JxlDecoderGetICCProfileSize(dec.get(), JXL_COLOR_PROFILE_TARGET_DATA,
+                                      &icc_size)) {
         throw std::runtime_error("JxlDecoderGetICCProfileSize failed\n");
       }
       std::vector<uint8_t> icc_profile(icc_size);
       if (JXL_DEC_SUCCESS != JxlDecoderGetColorAsICCProfile(
-                                 dec.get(), &format,
-                                 JXL_COLOR_PROFILE_TARGET_DATA,
+                                 dec.get(), JXL_COLOR_PROFILE_TARGET_DATA,
                                  icc_profile.data(), icc_profile.size())) {
         throw std::runtime_error("JxlDecoderGetColorAsICCProfile failed\n");
       }
@@ -128,7 +188,7 @@ libench::ImageContext libench::JXLDecoder::decode8(const CodestreamContext& cs,
         throw std::runtime_error("Invalid out buffer size");
       }
       this->pixels_.resize(image.height * image.width * num_comps);
-      void* pixels_buffer = (void*)this->pixels_.data();
+      void *pixels_buffer = (void *)this->pixels_.data();
       size_t pixels_buffer_size = this->pixels_.size() * sizeof(float);
       if (JXL_DEC_SUCCESS != JxlDecoderSetImageOutBuffer(dec.get(), &format,
                                                          pixels_buffer,