Provide ImageBuffer::set_color_space

Author: 197g

src/error.rs

@@ -125,6 +125,8 @@ pub enum ParameterErrorKind {
     DimensionMismatch,
     /// Repeated an operation for which error that could not be cloned was emitted already.
     FailedAlready,
+    /// The cicp is required to be RGB-like but had other matrix transforms or narrow range.
+    RgbCicpRequired(Cicp),
     /// A string describing the parameter.
     /// This is discouraged and is likely to get deprecated (but not removed).
     Generic(String),
@@ -427,6 +429,10 @@ impl fmt::Display for ParameterError {
                 fmt,
                 "The end the image stream has been reached due to a previous error"
             ),
+            ParameterErrorKind::RgbCicpRequired(cicp) => {
+                write!(fmt, "The CICP {cicp:?} can not be used for RGB images",)
+            }
+
             ParameterErrorKind::Generic(message) => {
                 write!(fmt, "The parameter is malformed: {message}",)
             }

src/images/buffer.rs

@@ -1024,6 +1024,19 @@ impl<P: Pixel, Container> ImageBuffer<P, Container> {
     pub fn color_space(&self) -> Cicp {
         self.color.into()
     }
+
+    /// Set primaries and transfer characteristics from a Cicp color space.
+    ///
+    /// Returns an error if `cicp` uses features that are not support with an RGB color space, e.g.
+    /// a matrix or narrow range (studio encoding) channels.
+    pub fn set_color_space(&mut self, cicp: Cicp) -> ImageResult<()> {
+        self.color = cicp.try_into_rgb()?;
+        Ok(())
+    }
+
+    pub(crate) fn set_rgb_color_space(&mut self, color: CicpRgb) {
+        self.color = color;
+    }
 }
 
 impl<P, Container> ImageBuffer<P, Container>

src/images/dynimage.rs

@@ -745,6 +745,14 @@ impl DynamicImage {
         dynamic_map!(self, ref p, p.color_space())
     }
 
+    /// Set primaries and transfer characteristics from a Cicp color space.
+    ///
+    /// Returns an error if `cicp` uses features that are not support with an RGB color space, e.g.
+    /// a matrix or narrow range (studio encoding) channels.
+    pub fn set_color_space(&mut self, cicp: Cicp) -> ImageResult<()> {
+        dynamic_map!(self, ref mut p, p.set_color_space(cicp))
+    }
+
     /// Whether the image contains an alpha channel
     ///
     /// This is a convenience wrapper around `self.color().has_alpha()`.
@@ -1189,20 +1197,12 @@ impl DynamicImage {
             return Ok(());
         }
 
-        // Forward compatibility: make sure we do not drop any details here.
-        if Cicp::from(cicp.into_rgb()) != cicp {
-            return Err(ImageError::Parameter(ParameterError::from_kind(
-                ParameterErrorKind::Generic("Not an RGB like CICP color space".to_string()),
-            )));
-        }
-
         // We could conceivably do this in-place faster but to handle the Luma conversion as we
         // want this requires the full machinery as `CicpTransform::transform_dynamic` which is
         // quite the replication. Let's just see if it is fast enough. Feel free to PR something if
         // it is easy enough to review.
         let mut target = self.clone();
-        target.set_rgb_primaries(cicp.primaries);
-        target.set_transfer_function(cicp.transfer);
+        target.set_color_space(cicp)?;
         target.copy_from_color_space(self, options)?;
 
         *self = target;
@@ -1233,16 +1233,9 @@ impl DynamicImage {
         }
 
         // Forward compatibility: make sure we do not drop any details here.
-        if Cicp::from(cicp.into_rgb()) != cicp {
-            return Err(ImageError::Parameter(ParameterError::from_kind(
-                ParameterErrorKind::Generic("Not an RGB like CICP color space".to_string()),
-            )));
-        }
-
+        let rgb = cicp.try_into_rgb()?;
         let mut target = DynamicImage::new(self.width(), self.height(), color);
-
-        target.set_rgb_primaries(cicp.primaries);
-        target.set_transfer_function(cicp.transfer);
+        dynamic_map!(target, ref mut p, p.set_rgb_color_space(rgb));
         target.copy_from_color_space(self, options)?;
 
         *self = target;

src/metadata/cicp.rs

@@ -3,12 +3,13 @@ use std::sync::Arc;
 /// CICP (coding independent code points) defines the colorimetric interpretation of rgb-ish color
 /// components.
 use crate::{
+    error::{ParameterError, ParameterErrorKind},
     math::multiply_accumulate,
     traits::{
         private::{LayoutWithColor, SealedPixelWithColorType},
         PixelWithColorType,
     },
-    ColorType, DynamicImage,
+    ColorType, DynamicImage, ImageError,
 };
 
 /// Reference: <https://www.itu.int/rec/T-REC-H.273-202407-I/en> (V4)
@@ -1204,6 +1205,16 @@ impl Cicp {
             luminance: DerivedLuminance::NonConstant,
         }
     }
+
+    pub(crate) fn try_into_rgb(self) -> Result<CicpRgb, ImageError> {
+        if Cicp::from(self.into_rgb()) != self {
+            Err(ImageError::Parameter(ParameterError::from_kind(
+                ParameterErrorKind::RgbCicpRequired(self),
+            )))
+        } else {
+            Ok(self.into_rgb())
+        }
+    }
 }
 
 impl CicpRgb {