Add basic CMYK support for jpegs. Add detailed LCMS2 error message.s

imageflow_core/Cargo.toml

@@ -52,7 +52,8 @@ libwebp-sys = "0.3"
 
 jpeg-decoder = "0.1"
 
-lcms2 = "5.1.5"
+lcms2 = { git = "https://github.com/imazen/rust-lcms2" }
+lcms2-sys = "*"
 chashmap = "2.2"
 
 getopts ="0.2"

imageflow_core/src/codecs/color_transform_cache.rs

@@ -6,7 +6,8 @@ use lcms2;
 use crate::ffi;
 use crate::errors::{FlowError, ErrorKind, ErrorCategory, Result};
 use crate::ffi::{BitmapBgra, DecoderColorInfo};
-
+use std::cell::RefCell;
+use std::thread;
 
 //
 // #[repr(C)]
@@ -58,6 +59,8 @@ lazy_static!{
 }
 
 
+thread_local!(static LAST_PROFILE_ERROR_MESSAGE: RefCell<Option<String>> = RefCell::new(None));
+
 
 impl ColorTransformCache{
 
@@ -68,52 +71,78 @@ impl ColorTransformCache{
             ffi::PixelFormat::Gray8 => PixelFormat::GRAY_8
         }
     }
+    unsafe extern "C" fn error_logger(context_id: lcms2_sys::Context, error_code: u32, text: *const libc::c_char){
+        let text_str = CStr::from_ptr(text).to_str().unwrap_or("LCMS error message not valid UTF8");
+        let message = format!("Error {}: {}", error_code, text_str);
+
+        LAST_PROFILE_ERROR_MESSAGE.with( |m| {
+            *m.borrow_mut() = Some(message);
+        })
+    }
+    fn create_thread_context() -> ThreadContext{
+        let mut context= ThreadContext::new();
+        context.set_error_logging_function(Some(ColorTransformCache::error_logger));
+        context
+    }
+    fn get_lcms_error(error: lcms2::Error) -> FlowError{
+        LAST_PROFILE_ERROR_MESSAGE.with( |m| {
+            let error = if let Some(message) = m.borrow().as_ref(){
+                FlowError::without_location(ErrorKind::ColorProfileError, format!("{} ({:?})", message, error))
+            }else{
+                FlowError::without_location(ErrorKind::ColorProfileError, format!("{:?}", error))
+            };
+            *m.borrow_mut() = None;
+            error
+
+        })
+    }
 
     fn create_gama_transform(color: &ffi::DecoderColorInfo, pixel_format: PixelFormat) -> Result<Transform<u32,u32, ThreadContext,DisallowCache>>{
-        let srgb = Profile::new_srgb_context(ThreadContext::new()); // Save 1ms by caching - but not sync
+        let srgb = Profile::new_srgb_context(ColorTransformCache::create_thread_context()); // Save 1ms by caching - but not sync
 
         let gama = ToneCurve::new(1f64 / color.gamma);
-        let p = Profile::new_rgb_context(ThreadContext::new(),&color.white_point, &color.primaries, &[&gama, &gama, &gama] ).map_err(|e| FlowError::from(e).at(here!()))?;
+        let p = Profile::new_rgb_context(ColorTransformCache::create_thread_context(),&color.white_point, &color.primaries, &[&gama, &gama, &gama] ).map_err(|e| ColorTransformCache::get_lcms_error(e).at(here!()))?;
 
-        let transform = Transform::new_flags_context(ThreadContext::new(),&p, pixel_format, &srgb, pixel_format, Intent::Perceptual, Flags::NO_CACHE).map_err(|e| FlowError::from(e).at(here!()))?;
+        let transform = Transform::new_flags_context(ColorTransformCache::create_thread_context(),&p, pixel_format, &srgb, pixel_format, Intent::Perceptual, Flags::NO_CACHE).map_err(|e| ColorTransformCache::get_lcms_error(e).at(here!()))?;
         Ok(transform)
     }
-    fn create_profile_transform(color: &ffi::DecoderColorInfo, pixel_format: PixelFormat) -> Result<Transform<u32,u32, ThreadContext,DisallowCache>> {
+    fn create_profile_transform(color: &ffi::DecoderColorInfo, input_pixel_format: PixelFormat, output_pixel_format: PixelFormat) -> Result<Transform<u32,u32, ThreadContext,DisallowCache>> {
 
         if color.profile_buffer.is_null() || color.buffer_length < 1{
             unreachable!();
         }
-        let srgb = Profile::new_srgb_context(ThreadContext::new()); // Save 1ms by caching - but not sync
+        let srgb = Profile::new_srgb_context(ColorTransformCache::create_thread_context()); // Save 1ms by caching - but not sync
 
         let bytes = unsafe { slice::from_raw_parts(color.profile_buffer, color.buffer_length) };
 
         let _ = (bytes.first(), bytes.last());
 
-        let p = Profile::new_icc_context(ThreadContext::new(), bytes).map_err(|e| FlowError::from(e).at(here!()))?;
+        let p = Profile::new_icc_context(ColorTransformCache::create_thread_context(), bytes).map_err(|e| ColorTransformCache::get_lcms_error(e).at(here!()))?;
 
         //TODO: handle gray transform on rgb expanded images.
         //TODO: Add test coverage for grayscale png
 
-        let transform = Transform::new_flags_context(ThreadContext::new(),
-                                                     &p, pixel_format, &srgb, pixel_format, Intent::Perceptual, Flags::NO_CACHE).map_err(|e| FlowError::from(e).at(here!()))?;
+        let transform = Transform::new_flags_context(ColorTransformCache::create_thread_context(),
+                                                     &p, input_pixel_format, &srgb, output_pixel_format, Intent::Perceptual, Flags::NO_CACHE).map_err(|e| ColorTransformCache::get_lcms_error(e).at(here!()))?;
 
         Ok(transform)
     }
-    fn hash(color: &ffi::DecoderColorInfo, pixel_format: ffi::PixelFormat) -> Option<u64>{
+    fn hash(color: &ffi::DecoderColorInfo, input_pixel_format: PixelFormat, output_pixel_format: PixelFormat) -> Option<u64>{
+        let format_hash = ((input_pixel_format.0 << 16) ^ output_pixel_format.0) as u64;
         match color.source {
             ffi::ColorProfileSource::Null | ffi::ColorProfileSource::sRGB => None,
             ffi::ColorProfileSource::GAMA_CHRM => {
                 let struct_bytes = unsafe {
                     slice::from_raw_parts(color as *const DecoderColorInfo as *const u8, mem::size_of::<DecoderColorInfo>())
                 };
-                Some(imageflow_helpers::hashing::hash_64(struct_bytes) ^ pixel_format as u64)
+                Some(imageflow_helpers::hashing::hash_64(struct_bytes) ^ format_hash)
             },
             ffi::ColorProfileSource::ICCP | ffi::ColorProfileSource::ICCP_GRAY => {
                 if !color.profile_buffer.is_null() && color.buffer_length > 0 {
                     let bytes = unsafe { slice::from_raw_parts(color.profile_buffer, color.buffer_length) };
 
                     // Skip first 80 bytes when hashing. Wait, why?
-                    Some(imageflow_helpers::hashing::hash_64(&bytes[80..]) ^ pixel_format as u64)
+                    Some(imageflow_helpers::hashing::hash_64(&bytes[80..]) ^ format_hash)
                 } else {
                     unreachable!("Profile source should never be set to ICCP without a profile buffer. Buffer length {}", color.buffer_length);
                 }
@@ -129,7 +158,7 @@ impl ColorTransformCache{
         }
     }
 
-    pub fn transform_to_srgb(frame: &mut BitmapBgra, color: &ffi::DecoderColorInfo) -> Result<()>{
+    pub fn transform_to_srgb(frame: &mut BitmapBgra, color: &ffi::DecoderColorInfo, input_pixel_format: PixelFormat, output_pixel_format: PixelFormat) -> Result<()>{
 
         if frame.fmt.bytes() != 4{
             return Err(nerror!(ErrorKind::Category(ErrorCategory::InternalError), "Color profile application is only supported for Bgr32 and Bgra32 canvases"));
@@ -146,7 +175,7 @@ impl ColorTransformCache{
                     ColorTransformCache::apply_transform(frame, &transform);
                     Ok(())
                 }else{
-                    let hash = ColorTransformCache::hash(color, frame.fmt).unwrap();
+                    let hash = ColorTransformCache::hash(color, input_pixel_format, output_pixel_format).unwrap();
                     if !GAMA_TRANSFORMS.contains_key(&hash) {
                         let transform = ColorTransformCache::create_gama_transform(color, pixel_format).map_err(|e| e.at(here!()))?;
                         GAMA_TRANSFORMS.insert(hash, transform);
@@ -158,13 +187,13 @@ impl ColorTransformCache{
             ffi::ColorProfileSource::ICCP | ffi::ColorProfileSource::ICCP_GRAY => {
                 // Cache up to 9 ICC profile x PixelFormat transforms
                 if PROFILE_TRANSFORMS.len() > 8{
-                    let transform = ColorTransformCache::create_profile_transform(color, pixel_format).map_err(|e| e.at(here!()))?;
+                    let transform = ColorTransformCache::create_profile_transform(color, input_pixel_format, output_pixel_format).map_err(|e| e.at(here!()))?;
                     ColorTransformCache::apply_transform(frame, &transform);
                     Ok(())
                 }else{
-                    let hash = ColorTransformCache::hash(color, frame.fmt).unwrap();
+                    let hash = ColorTransformCache::hash(color, input_pixel_format, output_pixel_format).unwrap();
                     if !PROFILE_TRANSFORMS.contains_key(&hash) {
-                        let transform = ColorTransformCache::create_profile_transform(color, pixel_format).map_err(|e| e.at(here!()))?;
+                        let transform = ColorTransformCache::create_profile_transform(color, input_pixel_format, output_pixel_format).map_err(|e| e.at(here!()))?;
                         PROFILE_TRANSFORMS.insert(hash, transform);
                     }
                     ColorTransformCache::apply_transform(frame, &*PROFILE_TRANSFORMS.get(&hash).unwrap());

imageflow_core/src/codecs/jpeg_decoder.rs

@@ -14,6 +14,7 @@ use crate::io::IoProxyProxy;
 use crate::io::IoProxyRef;
 use rgb::alt::BGRA8;
 
+
 extern crate jpeg_decoder as jpeg;
 
 

imageflow_core/src/codecs/libpng_decoder.rs

@@ -265,7 +265,7 @@ impl PngDec{
 
             if !self.ignore_color_profile {
 
-                let result = ColorTransformCache::transform_to_srgb(&mut *canvas, color_info)
+                let result = ColorTransformCache::transform_to_srgb(&mut *canvas, color_info, PixelFormat::BGRA_8, PixelFormat::BGRA_8)
                     .map_err(|e| e.at(here!()));
                 if result.is_err() && !self.ignore_color_profile_errors{
                     return result;

imageflow_core/src/codecs/mozjpeg_decoder.rs

@@ -17,6 +17,10 @@ use rgb::alt::BGRA8;
 extern crate mozjpeg_sys;
 use ::mozjpeg_sys::*;
 use imageflow_helpers::preludes::from_std::ptr::{null, slice_from_raw_parts, null_mut};
+use imageflow_types::DecoderCommand::IgnoreColorProfileErrors;
+
+static CMYK_PROFILE: &'static [u8] = include_bytes!("cmyk.icc");
+
 
 pub struct MozJpegDecoder{
     decoder: Box<MzDec>
@@ -257,8 +261,7 @@ impl MzDec{
 
         if !is_cmyk {
             self.codec_info.out_color_space = mozjpeg_sys::JCS_EXT_BGRA; //Why not BGRX? Maybe because it doesn't clear the alpha values
-        } else {
-            return Err(nerror!(ErrorKind::JpegDecodingError, "CMYK JPEG support not implemented"));
+
         }
 
         unsafe {
@@ -306,11 +309,19 @@ impl MzDec{
             }
         }
 
-        let color_info = self.get_decoder_color_info();
+        let mut color_info = self.get_decoder_color_info();
+
+        if is_cmyk && color_info.source != ColorProfileSource::ICCP{
+            color_info.source = ColorProfileSource::ICCP;
+            color_info.profile_buffer = &CMYK_PROFILE[0];
+            color_info.buffer_length = CMYK_PROFILE.len();
+        }
+
+        if !self.ignore_color_profile || is_cmyk{
 
-        if !self.ignore_color_profile {
+            let input_pixel_format = if is_cmyk { PixelFormat::CMYK_8_REV } else { PixelFormat::BGRA_8 };
 
-            let result = ColorTransformCache::transform_to_srgb(unsafe { &mut *canvas }, &color_info)
+            let result = ColorTransformCache::transform_to_srgb(unsafe { &mut *canvas }, &color_info, input_pixel_format, PixelFormat::BGRA_8)
                 .map_err(|e| e.at(here!()));
             if result.is_err() && !self.ignore_color_profile_errors{
                 return result;

imageflow_core/src/errors.rs

@@ -321,11 +321,6 @@ impl From<jpeg_decoder::Error> for FlowError{
     }
 }
 
-impl From<::lcms2::Error> for FlowError{
-    fn from(e: ::lcms2::Error) -> Self {
-        FlowError::without_location(ErrorKind::ColorProfileError, format!("{:?}", e))
-    }
-}
 
 impl From<::imagequant::liq_error> for FlowError {
     fn from(e: ::imagequant::liq_error) -> Self {

imageflow_core/src/ffi.rs

@@ -587,7 +587,7 @@ pub enum ColorProfileSource {
 #[derive(Clone,Debug,Copy, PartialEq)]
 pub struct DecoderColorInfo {
     pub source: ColorProfileSource,
-    pub profile_buffer: *mut u8,
+    pub profile_buffer: *const u8,
     pub buffer_length: usize,
     pub white_point: ::lcms2::CIExyY,
     pub primaries: ::lcms2::CIExyYTRIPLE,

imageflow_core/tests/visuals.rs

@@ -471,25 +471,18 @@ fn test_jpeg_crop() {
 
 #[test]
 fn decode_cmyk_jpeg() {
-    let steps = vec![
-        Node::CommandString {
-            kind: CommandStringKind::ImageResizer4,
-            value: "width=200&height=200&format=gif".to_owned(),
-            decode: Some(0),
-            encode: Some(1),
-            watermarks: None
-        }
-    ];
-
-    let result = smoke_test(Some(IoTestEnum::Url("https://upload.wikimedia.org/wikipedia/commons/0/0e/Youngstown_State_Athletics.jpg".to_owned())),
-                            Some(IoTestEnum::OutputBuffer),
-                            None,
-                            DEBUG_GRAPH,
-                            steps,
+    let matched = compare(Some(IoTestEnum::Url("https://imageflow-resources.s3-us-west-2.amazonaws.com/test_inputs/cmyk_logo.jpg".to_owned())), 500,
+                          "cmyk_decode", POPULATE_CHECKSUMS, DEBUG_GRAPH, vec![
+            Node::CommandString{
+                kind: CommandStringKind::ImageResizer4,
+                value: "".to_owned(),
+                decode: Some(0),
+                encode: None,
+                watermarks: None
+            }
+        ]
     );
-    let err = result.expect_err("CMYK jpeg decodes should fail");
-    assert_eq!(err.category(), crate::imageflow_core::ErrorCategory::ImageMalformed);
-    assert_eq!(err.message,"JpegDecodingError: CMYK JPEG support not implemented");
+    assert!(matched);
 
 }
 

imageflow_core/tests/visuals/checksums.json

@@ -34,6 +34,7 @@
   "Watermark1": "008A242F2FBED3C1D_0DE3336C466C67DD9",
   "WatermarkSmall": "09BF9877BE2CB36AC_0DE3336C466C67DD9",
   "WhiteBalanceNight": "0D84206BD2DD308DA_05C9231C6124D62A8",
+  "cmyk_decode": "00C5CD1E1ADF2628A_0D58EB335590501F3",
   "encode_frymire": "07FC2C05A26B49BF1.png",
   "encode_gradients": "00D10466A8552DCF6.png",
   "encode_marsRGB": "07800DDF0E598E7E4.png",