feat: Allow custom color encoding

Author: inflation

.harper-dictionary.txt

@@ -0,0 +1,2 @@
+butteraugli
+scRGB

.rumdl.toml

@@ -0,0 +1,2 @@
+[global]
+line-length = 100

jpegxl-rs/README.md

@@ -102,7 +102,8 @@ encoder.quality = 3.0;
 
 ### [`image`](https://crates.io/crates/image) crate integration
 
-By default, this integration uses the `image` integration. If you don't need it, turn off the `image` feature.
+By default, this integration uses the `image` integration.
+If you don't need it, turn off the `image` feature.
 
 ```rust
 use jpegxl_rs::image::ToDynamic;

jpegxl-rs/src/encode.rs

@@ -86,7 +86,7 @@ pub struct JxlEncoder<'prl, 'mm> {
     pub quality: f32,
     /// Configure the encoder to use the JPEG XL container format
     ///
-    /// Using the JPEG XL container format allows to store metadata such as JPEG reconstruction;
+    /// Using the JPEG XL container format allows one to store metadata such as JPEG reconstruction;
     /// but it adds a few bytes to the encoded file for container headers
     /// even if there is no extra metadata.
     pub use_container: bool,
@@ -95,7 +95,7 @@ pub struct JxlEncoder<'prl, 'mm> {
     /// If the input image has a color profile, it will be used for the encoded image.
     /// Otherwise, an internal fixed color profile is chosen (which should be smaller).
     ///
-    /// When lossless recompressing JPEG image, you must set this to true.
+    /// When lossless re-compressing JPEG image, you must set this to true.
     ///
     /// Default: `false`
     pub uses_original_profile: bool,
@@ -111,9 +111,13 @@ pub struct JxlEncoder<'prl, 'mm> {
 
     /// Set color encoding
     ///
-    /// Default: SRGB for uint, Linear SRGB for float
+    /// Default: sRGB for int, Linear sRGB for float
     pub color_encoding: Option<ColorEncoding>,
 
+    /// Set HDR target intensity.
+    /// Specify the target intensity in nits for 1.0 value
+    pub target_intensity: Option<f32>,
+
     /// Set parallel runner
     ///
     /// Default: `None`, indicating single thread execution
@@ -145,6 +149,7 @@ impl<'prl, 'mm> JxlEncoder<'prl, 'mm> {
         #[builder(default)] decoding_speed: i64,
         init_buffer_size: Option<usize>,
         color_encoding: Option<ColorEncoding>,
+        target_intensity: Option<f32>,
         parallel_runner: Option<&'prl dyn ParallelRunner>,
         #[builder(default)] use_box: bool,
     ) -> Result<Self, EncodeError> {
@@ -173,6 +178,7 @@ impl<'prl, 'mm> JxlEncoder<'prl, 'mm> {
             decoding_speed,
             init_buffer_size: init_buffer_size.map_or(512 * 1024, |v| if v < 32 { 32 } else { v }),
             color_encoding,
+            target_intensity,
             parallel_runner,
             use_box,
             memory_manager,
@@ -295,18 +301,21 @@ impl JxlEncoder<'_, '_> {
             basic_info.num_color_channels = 1;
         }
 
+        if let Some(target_intensity) = self.target_intensity {
+            basic_info.intensity_target = target_intensity;
+        }
+
         if let Some(pr) = self.parallel_runner {
             pr.callback_basic_info(&basic_info);
         }
 
         self.check_enc_status(unsafe { JxlEncoderSetBasicInfo(self.enc, &raw const basic_info) })?;
 
-        if let Some(color_encoding) = self.color_encoding {
+        if let Some(color_encoding) = &self.color_encoding {
             self.check_enc_status(unsafe {
                 JxlEncoderSetColorEncoding(self.enc, &color_encoding.into())
             })?;
         }
-
         Ok(())
     }
 

jpegxl-rs/src/encode/options.rs

@@ -29,21 +29,23 @@ pub enum EncoderSpeed {
 }
 
 /// Encoding color profile
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub enum ColorEncoding {
-    /// SRGB, default for uint pixel types
+    /// sRGB, default for int pixel types
     Srgb,
-    /// Linear SRGB, default for float pixel types
+    /// Linear sRGB, default for float pixel types
     LinearSrgb,
-    /// SRGB, images with only luma channel
+    /// sRGB, images with only luma channel
     SrgbLuma,
-    /// Linear SRGB with only luma channel
+    /// Linear sRGB with only luma channel
     LinearSrgbLuma,
+    /// Custom
+    Custom(JxlColorEncoding),
 }
 
-impl From<ColorEncoding> for JxlColorEncoding {
-    fn from(val: ColorEncoding) -> Self {
-        use ColorEncoding::{LinearSrgb, LinearSrgbLuma, Srgb, SrgbLuma};
+impl From<&ColorEncoding> for JxlColorEncoding {
+    fn from(val: &ColorEncoding) -> Self {
+        use ColorEncoding::{Custom, LinearSrgb, LinearSrgbLuma, Srgb, SrgbLuma};
 
         let mut color_encoding = MaybeUninit::uninit();
 
@@ -59,6 +61,9 @@ impl From<ColorEncoding> for JxlColorEncoding {
                 LinearSrgbLuma => {
                     api::JxlColorEncodingSetToLinearSRGB(color_encoding.as_mut_ptr(), true.into());
                 }
+                Custom(e) => {
+                    return e.clone();
+                }
             }
             color_encoding.assume_init()
         }

jpegxl-rs/src/tests/encode.rs

@@ -17,6 +17,10 @@
 
 use half::f16;
 use image::DynamicImage;
+use jpegxl_sys::color::color_encoding::{
+    JxlColorEncoding, JxlColorSpace, JxlPrimaries, JxlRenderingIntent, JxlTransferFunction,
+    JxlWhitePoint,
+};
 use pretty_assertions::assert_eq;
 use testresult::TestResult;
 
@@ -227,3 +231,33 @@ fn initial_buffer() -> TestResult {
     let _: EncoderResult<f32> = encoder.encode(sample.as_raw(), sample.width(), sample.height())?;
     Ok(())
 }
+
+#[test]
+fn custom_color_encoding() -> TestResult {
+    let mut encoder = encoder_builder().build()?;
+    let sample = get_sample().to_rgb8();
+
+    // scRGB: linear transfer with sRGB primaries and D65 white point.
+    let custom_color_encoding = JxlColorEncoding {
+        color_space: JxlColorSpace::Rgb,
+        white_point: JxlWhitePoint::D65,
+        white_point_xy: [0.0, 0.0],
+        primaries: JxlPrimaries::SRgb,
+        primaries_red_xy: [0.0, 0.0],
+        primaries_green_xy: [0.0, 0.0],
+        primaries_blue_xy: [0.0, 0.0],
+        transfer_function: JxlTransferFunction::Linear,
+        gamma: 0.0,
+        rendering_intent: JxlRenderingIntent::Relative,
+    };
+    encoder.color_encoding = Some(ColorEncoding::Custom(custom_color_encoding));
+    encoder.target_intensity = Some(1000.0);
+
+    let result: EncoderResult<u16> =
+        encoder.encode(sample.as_raw(), sample.width(), sample.height())?;
+
+    let decoder = decoder_builder().build()?;
+    let _res = decoder.decode(&result)?;
+
+    Ok(())
+}