Added the JXL related encoding options, like effort, distance, etc

dreampiggy · dreampiggy · commit 2a6eba22d7e9 · 2025-01-23T18:47:04.000+08:00
Also allows to control the thread count to avoid huge CPU usage
diff --git a/Example/SDWebImageJPEGXLCoder/SDViewController.m b/Example/SDWebImageJPEGXLCoder/SDViewController.m
@@ -9,6 +9,7 @@
 #import "SDViewController.h"
 #import <SDWebImageJPEGXLCoder/SDImageJPEGXLCoder.h>
 #import <SDWebImage/SDWebImage.h>
+#import <libjxl/jxl/encode.h>
 
 @interface SDViewController ()
 @property (nonatomic, strong) UIImageView *imageView1;
@@ -37,29 +38,26 @@ - (void)viewDidLoad {
     NSURL *staticURL = [NSURL URLWithString:@"https://jpegxl.info/logo.jxl"];
     NSURL *animatedURL = [NSURL URLWithString:@"https://jpegxl.info/anim_jxl_logo.jxl"];
     
-//    [self.imageView1 sd_setImageWithURL:staticURL placeholderImage:nil options:0 context:nil progress:nil completed:^(UIImage * _Nullable image, NSError * _Nullable error, SDImageCacheType cacheType, NSURL * _Nullable imageURL) {
-//        if (image) {
-//            NSLog(@"%@", @"Static JPEG-XL load success");
-//        }
-////         TODO, JXL encoding
-//        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-//            NSUInteger maxFileSize = 4096;
-//            NSData *jxlData = [SDImageJPEGXLCoder.sharedCoder encodedDataWithImage:image format:SDImageFormatJPEGXL options:@{SDImageCoderEncodeMaxFileSize : @(maxFileSize)}];
-//            if (jxlData) {
-//                NSLog(@"%@", @"JPEG-XL encoding success");
-//            }
-//        });
-//    }];
-//    [self.imageView2 sd_setImageWithURL:animatedURL placeholderImage:nil completed:^(UIImage * _Nullable image, NSError * _Nullable error, SDImageCacheType cacheType, NSURL * _Nullable imageURL) {
-//        if (image) {
-//            NSLog(@"%@", @"Animated JPEG-XL load success");
-//        }
-//    }];
+    [self.imageView1 sd_setImageWithURL:staticURL placeholderImage:nil options:0 context:nil progress:nil completed:^(UIImage * _Nullable image, NSError * _Nullable error, SDImageCacheType cacheType, NSURL * _Nullable imageURL) {
+        if (image) {
+            NSLog(@"%@", @"Static JPEG-XL load success");
+        }
+//         TODO, JXL encoding
+        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+            NSUInteger maxFileSize = 4096;
+            NSData *jxlData = [SDImageJPEGXLCoder.sharedCoder encodedDataWithImage:image format:SDImageFormatJPEGXL options:@{SDImageCoderEncodeMaxFileSize : @(maxFileSize)}];
+            if (jxlData) {
+                NSLog(@"%@", @"JPEG-XL encoding success");
+            }
+        });
+    }];
+    [self.imageView2 sd_setImageWithURL:animatedURL placeholderImage:nil completed:^(UIImage * _Nullable image, NSError * _Nullable error, SDImageCacheType cacheType, NSURL * _Nullable imageURL) {
+        if (image) {
+            NSLog(@"%@", @"Animated JPEG-XL load success");
+        }
+    }];
     
-    // Test JXL Encode
-    NSData *HDRData = [NSData dataWithContentsOfFile:@"/Users/lizhuoli/Desktop/iso-hdr-demo.jxl"];
-    UIImage *image = [UIImage imageWithData:HDRData];
-    [self encodeJXLWithImage:image];
+    [self testHDREncoding];
 }
 
 - (void)viewWillLayoutSubviews {
@@ -68,16 +66,36 @@ - (void)viewWillLayoutSubviews {
     self.imageView2.frame = CGRectMake(0, self.view.bounds.size.height / 2, self.view.bounds.size.width, self.view.bounds.size.height / 2);
 }
 
+- (void)testHDREncoding {
+    // Test JXL Encode
+    NSURL *HDRURL = [NSURL URLWithString:@"https://ncdn.camarts.cn/iso-hdr-demo.jxl"];
+    NSURLSessionTask *task = [NSURLSession.sharedSession dataTaskWithURL:HDRURL completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
+        UIImage *image = [UIImage imageWithData:data];
+        [self encodeJXLWithImage:image];
+    }];
+    [task resume];
+}
+
 - (void)encodeJXLWithImage:(UIImage *)image {
+    NSCParameterAssert(image);
+    NSDictionary *frameSetting = @{
+        @(JXL_ENC_FRAME_SETTING_EFFORT) : @(1),
+        @(JXL_ENC_FRAME_SETTING_BROTLI_EFFORT) : @(0)
+    };
+    // fastest encoding speed but largest compressed size, you can adjust options here
     NSData *data = [SDImageJPEGXLCoder.sharedCoder encodedDataWithImage:image format:SDImageFormatJPEGXL options:@{
-        SDImageCoderEncodeCompressionQuality : @0.68
+//        SDImageCoderEncodeCompressionQuality : @0.68,
+        SDImageCoderEncodeJXLDistance : @(1.0),
+        SDImageCoderEncodeJXLFrameSetting : frameSetting,
     }];
     NSCParameterAssert(data);
-    [data writeToFile:@"/tmp/a.jxl" atomically:YES];
+    NSString *tempOutputPath = [NSTemporaryDirectory() stringByAppendingPathComponent:@"iso-hdr-demo.jxl"];
+    [data writeToFile:tempOutputPath atomically:YES];
+    NSLog(@"Written encoded JXL to : %@", tempOutputPath);
     
     CIImage *ciimage = [CIImage imageWithData:data];
     NSString *desc = [ciimage description];
-    NSLog(@"Encoded JXL CIImage description: %@", desc);
+    NSLog(@"Re-decoded JXL CIImage description: %@", desc);
 }
 
 - (void)didReceiveMemoryWarning {
diff --git a/SDWebImageJPEGXLCoder/Classes/SDImageJPEGXLCoder.h b/SDWebImageJPEGXLCoder/Classes/SDImageJPEGXLCoder.h
@@ -19,3 +19,57 @@ static const SDImageFormat SDImageFormatJPEGXL = 17; // JPEG-XL
 @property (nonatomic, class, readonly, nonnull) SDImageJPEGXLCoder *sharedCoder;
 
 @end
+
+#pragma mark - JXL Encode Options
+
+/*
+ * Sets the distance level for lossy compression: target max butteraugli
+ * distance, lower = higher quality. Range: 0 .. 25.
+ * 0.0 = mathematically lossless (however, use @ref JxlEncoderSetFrameLossless
+ * instead to use true lossless, as setting distance to 0 alone is not the only
+ * requirement). 1.0 = visually lossless. Recommended range: 0.5 .. 3.0. Default
+ * value: 1.0.
+ * See more in upstream: https://libjxl.readthedocs.io/en/latest/api_encoder.html#_CPPv426JxlEncoderSetFrameDistanceP23JxlEncoderFrameSettingsf
+ * A NSNumber value. The default value is nil.
+ * @note: When you use both `SDImageCoderEncodeCompressionQuality` and this option, this option will override that one and takes effect.
+ */
+FOUNDATION_EXPORT _Nonnull SDImageCoderOption SDImageCoderEncodeJXLDistance;
+
+/**
+ * Enables lossless encoding.
+ * See more in upstream: https://libjxl.readthedocs.io/en/latest/api_encoder.html#_CPPv426JxlEncoderSetFrameLosslessP23JxlEncoderFrameSettings8JXL_BOOL
+ * A NSNumber value. The default value is NO.
+ */
+FOUNDATION_EXPORT _Nonnull SDImageCoderOption SDImageCoderEncodeJXLLoseless;
+
+/**
+ * Sets the feature level of the JPEG XL codestream. Valid values are 5 and
+ * 10, or -1 (to choose automatically). Using the minimum required level, or
+ * level 5 in most cases, is recommended for compatibility with all decoders.
+ * See more in upstream: https://libjxl.readthedocs.io/en/latest/api_encoder.html#_CPPv428JxlEncoderSetCodestreamLevelP10JxlEncoderi
+ * A NSNumber value. The default value is -1.
+ */
+FOUNDATION_EXPORT _Nonnull SDImageCoderOption SDImageCoderEncodeJXLCodeStreamLevel;
+
+/* Pass extra underlying libjxl encoding frame setting. The Value is a NSDictionary, which each key-value pair use`JxlEncoderFrameSettingId` (NSNumber) as key, and NSNumber as value.
+ * See more in upstream: https://libjxl.readthedocs.io/en/latest/api_encoder.html#_CPPv424JxlEncoderFrameSettingId
+ * If you can not impoort the libjxl header, just pass the raw int number as `JxlEncoderFrameSettingId`
+
+ Objc code:
+ ~~~
+ @{SDImageCoderEncodeJXLFrameSetting: @{@JXL_ENC_FRAME_SETTING_EFFORT: @(11)}
+ ~~~
+ 
+ Swift code:
+ ~~~
+ [.encodeJXLFrameSetting : [JxlEncoderFrameSettingId.JXL_ENC_FRAME_SETTING_EFFORT : 11]
+ ~~~
+*/
+FOUNDATION_EXPORT _Nonnull SDImageCoderOption SDImageCoderEncodeJXLFrameSetting;
+
+/**
+ * Set the thread count for multithreading. 0 means using logical CPU core (hw.logicalcpu) to detect threads (like 8 core on M1 Mac/ 4 core on iPhone 16 Pro)
+ * @warning If you're encoding huge or multiple JXL image at the same time, set this value to 1 to avoid huge CPU usage.
+ * A NSNumber value. Defaults to 0, means logical CPU core count. Set to 1 if you want single-thread encoding.
+ */
+FOUNDATION_EXPORT _Nonnull SDImageCoderOption SDImageCoderEncodeJXLThreadCount;
diff --git a/SDWebImageJPEGXLCoder/Classes/SDImageJPEGXLCoder.m b/SDWebImageJPEGXLCoder/Classes/SDImageJPEGXLCoder.m
@@ -31,10 +31,10 @@
 
 // Should moved to SDWebImage Core
 #include <sys/sysctl.h>
-static int computeHostNumPhysicalCores() {
+static int computeHostNumLogicalCores(void) {
   uint32_t count;
   size_t len = sizeof(count);
-  sysctlbyname("hw.physicalcpu", &count, &len, NULL, 0);
+  sysctlbyname("hw.logicalcpu", &count, &len, NULL, 0);
   if (count < 1) {
     int nm[2];
     nm[0] = CTL_HW;
@@ -373,20 +373,8 @@ - (NSData *)encodedDataWithFrames:(NSArray<SDImageFrame *> *)frames loopCount:(N
     if (options[SDImageCoderEncodeCompressionQuality]) {
         compressionQuality = [options[SDImageCoderEncodeCompressionQuality] doubleValue];
     }
-    CGSize maxPixelSize = CGSizeZero;
-    NSValue *maxPixelSizeValue = options[SDImageCoderEncodeMaxPixelSize];
-    if (maxPixelSizeValue != nil) {
-#if SD_MAC
-        maxPixelSize = maxPixelSizeValue.sizeValue;
-#else
-        maxPixelSize = maxPixelSizeValue.CGSizeValue;
-#endif
-    }
-    NSUInteger maxFileSize = 0;
-    if (options[SDImageCoderEncodeMaxFileSize]) {
-        maxFileSize = [options[SDImageCoderEncodeMaxFileSize] unsignedIntegerValue];
-    }
     
+    // TODO: Animated JPEG-XL Encoding support
 //    BOOL encodeFirstFrame = [options[SDImageCoderEncodeFirstFrameOnly] boolValue];
 //    if (encodeFirstFrame || frames.count <= 1) {
 //        
@@ -461,7 +449,7 @@ - (NSData *)encodedDataWithFrames:(NSArray<SDImageFrame *> *)frames loopCount:(N
 #else
     CGImagePropertyOrientation orientation = kCGImagePropertyOrientationUp;
 #endif
-    data = [self sd_encodedJXLDataWithImage:imageRef orientation:orientation quality:compressionQuality maxPixelSize:maxPixelSize maxFileSize:maxFileSize options:nil];
+    data = [self sd_encodedJXLDataWithImage:imageRef orientation:orientation quality:compressionQuality options:options];
     
     return data;
 }
@@ -494,11 +482,9 @@ JxlEncoderStatus EncodeWithEncoder(JxlEncoder* enc, NSMutableData *compressed) {
 }
 
 - (nullable NSData *)sd_encodedJXLDataWithImage:(nullable CGImageRef)imageRef
-                                     orientation:(CGImagePropertyOrientation)orientation
-                                         quality:(double)quality
-                                    maxPixelSize:(CGSize)maxPixelSize
-                                     maxFileSize:(NSUInteger)maxFileSize
-                                         options:(nullable SDImageCoderOptions *)options
+                                    orientation:(CGImagePropertyOrientation)orientation
+                                        quality:(double)quality
+                                        options:(NSDictionary *)options
 {
     if (!imageRef) {
         return nil;
@@ -586,7 +572,7 @@ - (nullable NSData *)sd_encodedJXLDataWithImage:(nullable CGImageRef)imageRef
     JxlBasicInfo info;
     JxlColorEncoding jxl_color;
     JxlPixelFormat jxl_fmt;
-    JxlEncoderStatus jret;
+    __block JxlEncoderStatus jret;
     
     // encoder
     JxlEncoder* enc = JxlEncoderCreate(NULL);
@@ -597,12 +583,28 @@ - (nullable NSData *)sd_encodedJXLDataWithImage:(nullable CGImageRef)imageRef
     /* populate the basic info settings */
     JxlEncoderInitBasicInfo(&info);
     
+    /* Parse the extra options */
+    NSDictionary *frameSetting = options[SDImageCoderEncodeJXLFrameSetting];
+    BOOL loseless = options[SDImageCoderEncodeJXLLoseless] ? [options[SDImageCoderEncodeJXLLoseless] boolValue] : NO;
+    int codeStreamLevel = options[SDImageCoderEncodeJXLCodeStreamLevel] ? [options[SDImageCoderEncodeJXLCodeStreamLevel] intValue] : -1;
+    
+    float distance;
+    if (options[SDImageCoderEncodeJXLDistance] != nil) {
+        // prefer JXL distance
+        distance = [options[SDImageCoderEncodeJXLDistance] floatValue];
+    } else {
+        // convert JPEG quality (0-100) to JXL distance
+        distance = JxlEncoderDistanceFromQuality(quality * 100.0);
+    }
+    /* bitexact lossless requires there to be no XYB transform */
+    info.uses_original_profile = distance == 0.0;
+    
     jxl_fmt.num_channels = (uint32_t)components;
     info.xsize = (uint32_t)width;
     info.ysize = (uint32_t)height;
     info.num_extra_channels = (jxl_fmt.num_channels + 1) % 2;
     info.num_color_channels = jxl_fmt.num_channels - info.num_extra_channels;
-    info.bits_per_sample = bitsPerPixel / jxl_fmt.num_channels;
+    info.bits_per_sample = (uint32_t)bitsPerPixel / jxl_fmt.num_channels;
     info.alpha_bits = (info.num_extra_channels > 0) * info.bits_per_sample;
     // floating point
     if (SD_OPTIONS_CONTAINS(bitmapInfo, kCGBitmapFloatComponents)) {
@@ -618,10 +620,6 @@ - (nullable NSData *)sd_encodedJXLDataWithImage:(nullable CGImageRef)imageRef
     info.orientation = (JxlOrientation)orientation;
     // default endian (little)
     jxl_fmt.endianness = JXL_NATIVE_ENDIAN;
-    // convert JPEG quality (0-100) to JXL distance
-    float distance = JxlEncoderDistanceFromQuality(quality * 100.0);
-    /* bitexact lossless requires there to be no XYB transform */
-    info.uses_original_profile = distance == 0.0;
     /* rendering intent doesn't matter here
      * but libjxl will whine if we don't set it */
     JxlRenderingIntent render_indent;
@@ -662,23 +660,47 @@ - (nullable NSData *)sd_encodedJXLDataWithImage:(nullable CGImageRef)imageRef
     
     /* This needs to be set each time the decoder is reset */
     JxlEncoderFrameSettings* frame_settings = JxlEncoderFrameSettingsCreate(enc, NULL);
-    jret = JxlEncoderSetFrameDistance(frame_settings, distance);
-//    JxlEncoderSetExtraChannelDistance(frame_settings, distance);
+    jret |= JxlEncoderSetFrameDistance(frame_settings, distance);
+    /* Set lossless */
+    jret |= JxlEncoderSetFrameLossless(frame_settings, loseless ? 1 : 0);
+    /* Set code steram level */
+    jret |= JxlEncoderSetCodestreamLevel(enc, codeStreamLevel);
+    
+    /* Set extra frame setting */
+    [frameSetting enumerateKeysAndObjectsUsingBlock:^(NSNumber * _Nonnull key, NSNumber * _Nonnull value, BOOL * _Nonnull stop) {
+        JxlEncoderFrameSettingId frame_key = key.unsignedIntValue;
+        // check the value is floating point or integer
+        if ([[value stringValue] containsString:@"."]) {
+            // floating point value
+            double frame_value = value.doubleValue;
+            jret |= JxlEncoderFrameSettingsSetFloatOption(frame_settings, frame_key, frame_value);
+        } else {
+            // integer value
+            int64_t frame_value = value.integerValue;
+            jret |= JxlEncoderFrameSettingsSetOption(frame_settings, frame_key, frame_value);
+        }
+    }];
+
     if (jret != JXL_ENC_SUCCESS) {
         JxlEncoderDestroy(enc);
         return nil;
     }
     
-   /* This needs to be set each time the decoder is reset */
-    size_t threadCount = computeHostNumPhysicalCores();
-    void* runner = JxlThreadParallelRunnerCreate(NULL, threadCount);
-    jret = JxlEncoderSetParallelRunner(enc, JxlThreadParallelRunner, runner);
-    if (jret != JXL_ENC_SUCCESS) {
-        JxlEncoderDestroy(enc);
-        return nil;
+    /* This needs to be set each time the decoder is reset */
+    size_t threadCount = [options[SDImageCoderEncodeJXLThreadCount] unsignedIntValue];
+    if (threadCount == 0) {
+        threadCount = computeHostNumLogicalCores();
+    }
+    if (threadCount > 1) {
+        void* runner = JxlThreadParallelRunnerCreate(NULL, threadCount);
+        jret = JxlEncoderSetParallelRunner(enc, JxlThreadParallelRunner, runner);
+        if (jret != JXL_ENC_SUCCESS) {
+            JxlEncoderDestroy(enc);
+            return nil;
+        }
     }
     
-    // Add bitmap buffer
+    /* Add frame bitmap buffer */
     jret = JxlEncoderAddImageFrame(frame_settings, &jxl_fmt,
                             buffer.bytes,
                             buffer.length);
@@ -688,7 +710,7 @@ - (nullable NSData *)sd_encodedJXLDataWithImage:(nullable CGImageRef)imageRef
     }
     JxlEncoderCloseInput(enc);
     
-    // libjxp support incremental encoding, but we just wait it finished
+    /* libjxp support incremental encoding, but we just wait it until finished */
     NSMutableData *output = [NSMutableData data];
     jret = EncodeWithEncoder(enc, output);
     
@@ -701,3 +723,10 @@ - (nullable NSData *)sd_encodedJXLDataWithImage:(nullable CGImageRef)imageRef
 }
 
 @end
+
+#pragma mark - JXL Encode Options
+SDImageCoderOption SDImageCoderEncodeJXLDistance = @"encodeJXLDistance";
+SDImageCoderOption SDImageCoderEncodeJXLLoseless = @"encodeJXLLoseless";
+SDImageCoderOption SDImageCoderEncodeJXLCodeStreamLevel = @"encodeJXLCodeStreamLevel";
+SDImageCoderOption SDImageCoderEncodeJXLFrameSetting = @"encodeJXLFrameSetting";
+SDImageCoderOption SDImageCoderEncodeJXLThreadCount = @"encodeJXLThreadCount";
