Debian Codegraph @

.cargo/vendor/moxcms/src/conversions/katana/md4x3.rs

raw
1 /*
2 * // Copyright (c) Radzivon Bartoshyk 6/2025. All rights reserved.
3 * //
4 * // Redistribution and use in source and binary forms, with or without modification,
5 * // are permitted provided that the following conditions are met:
6 * //
7 * // 1. Redistributions of source code must retain the above copyright notice, this
8 * // list of conditions and the following disclaimer.
9 * //
10 * // 2. Redistributions in binary form must reproduce the above copyright notice,
11 * // this list of conditions and the following disclaimer in the documentation
12 * // and/or other materials provided with the distribution.
13 * //
14 * // 3. Neither the name of the copyright holder nor the names of its
15 * // contributors may be used to endorse or promote products derived from
16 * // this software without specific prior written permission.
17 * //
18 * // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 * // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
22 * // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
24 * // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25 * // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
26 * // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 * // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29 use crate::conversions::katana::KatanaInitialStage;
30 use crate::conversions::katana::md3x3::MultidimensionalDirection;
31 use crate::mlaf::mlaf;
32 use crate::safe_math::SafeMul;
33 use crate::trc::lut_interp_linear_float;
34 use crate::{
35 CmsError, DataColorSpace, Hypercube, InterpolationMethod, LutMultidimensionalType,
36 MalformedSize, Matrix3d, Matrix3f, PointeeSizeExpressible, TransformOptions, Vector3d,
37 Vector3f,
38 };
39 use num_traits::AsPrimitive;
40 use std::marker::PhantomData;
41
42 pub(crate) fn execute_simple_curves3(dst: &mut [f32], curves: &[Vec<f32>; 3]) {
43 let curve0 = &curves[0];
44 let curve1 = &curves[1];
45 let curve2 = &curves[2];
46
47 for dst in dst.chunks_exact_mut(3) {
48 let a0 = dst[0];
49 let a1 = dst[1];
50 let a2 = dst[2];
51 let b0 = lut_interp_linear_float(a0, curve0);
52 let b1 = lut_interp_linear_float(a1, curve1);
53 let b2 = lut_interp_linear_float(a2, curve2);
54 dst[0] = b0;
55 dst[1] = b1;
56 dst[2] = b2;
57 }
58 }
59
60 pub(crate) fn execute_matrix_stage3(matrix: Matrix3f, bias: Vector3f, dst: &mut [f32]) {
61 let m = matrix;
62 let b = bias;
63
64 if !m.test_equality(Matrix3f::IDENTITY) || !b.eq(&Vector3f::default()) {
65 for dst in dst.chunks_exact_mut(3) {
66 let x = dst[0];
67 let y = dst[1];
68 let z = dst[2];
69 dst[0] = mlaf(mlaf(mlaf(b.v[0], x, m.v[0][0]), y, m.v[0][1]), z, m.v[0][2]);
70 dst[1] = mlaf(mlaf(mlaf(b.v[1], x, m.v[1][0]), y, m.v[1][1]), z, m.v[1][2]);
71 dst[2] = mlaf(mlaf(mlaf(b.v[2], x, m.v[2][0]), y, m.v[2][1]), z, m.v[2][2]);
72 }
73 }
74 }
75
76 struct Multidimensional4x3<
77 T: Copy + Default + AsPrimitive<f32> + PointeeSizeExpressible + Send + Sync,
78 > {
79 a_curves: Option<Box<[Vec<f32>; 4]>>,
80 m_curves: Option<Box<[Vec<f32>; 3]>>,
81 b_curves: Option<Box<[Vec<f32>; 3]>>,
82 clut: Option<Vec<f32>>,
83 matrix: Matrix3f,
84 bias: Vector3f,
85 direction: MultidimensionalDirection,
86 options: TransformOptions,
87 pcs: DataColorSpace,
88 grid_size: [u8; 4],
89 _phantom: PhantomData<T>,
90 bit_depth: usize,
91 }
92
93 impl<T: Copy + Default + AsPrimitive<f32> + PointeeSizeExpressible + Send + Sync>
94 Multidimensional4x3<T>
95 {
96 fn to_pcs_impl<Fetch: Fn(f32, f32, f32, f32) -> Vector3f>(
97 &self,
98 input: &[T],
99 dst: &mut [f32],
100 fetch: Fetch,
101 ) -> Result<(), CmsError> {
102 let norm_value = if T::FINITE {
103 1.0 / ((1u32 << self.bit_depth) - 1) as f32
104 } else {
105 1.0
106 };
107 assert_eq!(
108 self.direction,
109 MultidimensionalDirection::DeviceToPcs,
110 "PCS to device cannot be used on `to pcs` stage"
111 );
112
113 // A -> B
114 // OR B - A A - curves stage
115
116 if let (Some(a_curves), Some(clut)) = (self.a_curves.as_ref(), self.clut.as_ref()) {
117 if !clut.is_empty() {
118 let curve0 = &a_curves[0];
119 let curve1 = &a_curves[1];
120 let curve2 = &a_curves[2];
121 let curve3 = &a_curves[3];
122 for (src, dst) in input.chunks_exact(4).zip(dst.chunks_exact_mut(3)) {
123 let b0 = lut_interp_linear_float(src[0].as_() * norm_value, curve0);
124 let b1 = lut_interp_linear_float(src[1].as_() * norm_value, curve1);
125 let b2 = lut_interp_linear_float(src[2].as_() * norm_value, curve2);
126 let b3 = lut_interp_linear_float(src[3].as_() * norm_value, curve3);
127 let interpolated = fetch(b0, b1, b2, b3);
128 dst[0] = interpolated.v[0];
129 dst[1] = interpolated.v[1];
130 dst[2] = interpolated.v[2];
131 }
132 }
133 } else {
134 return Err(CmsError::InvalidAtoBLut);
135 }
136
137 // Matrix stage
138
139 if let Some(m_curves) = self.m_curves.as_ref() {
140 execute_simple_curves3(dst, m_curves);
141 execute_matrix_stage3(self.matrix, self.bias, dst);
142 }
143
144 // B-curves is mandatory
145 if let Some(b_curves) = &self.b_curves.as_ref() {
146 execute_simple_curves3(dst, b_curves);
147 }
148
149 Ok(())
150 }
151 }
152
153 impl<T: Copy + Default + AsPrimitive<f32> + PointeeSizeExpressible + Send + Sync>
154 KatanaInitialStage<f32, T> for Multidimensional4x3<T>
155 {
156 fn to_pcs(&self, input: &[T]) -> Result<Vec<f32>, CmsError> {
157 if input.len() % 4 != 0 {
158 return Err(CmsError::LaneMultipleOfChannels);
159 }
160 let fixed_new_clut = Vec::new();
161 let new_clut = self.clut.as_ref().unwrap_or(&fixed_new_clut);
162 let lut = Hypercube::new_checked_hypercube(new_clut, self.grid_size, 3)?;
163
164 let mut new_dst = vec![0f32; (input.len() / 4) * 3];
165
166 // If PCS is LAB then linear interpolation should be used
167 if self.pcs == DataColorSpace::Lab || self.pcs == DataColorSpace::Xyz {
168 self.to_pcs_impl(input, &mut new_dst, |x, y, z, w| {
169 lut.quadlinear_vec3(x, y, z, w)
170 })?;
171 return Ok(new_dst);
172 }
173
174 match self.options.interpolation_method {
175 #[cfg(feature = "options")]
176 InterpolationMethod::Tetrahedral => {
177 self.to_pcs_impl(input, &mut new_dst, |x, y, z, w| lut.tetra_vec3(x, y, z, w))?;
178 }
179 #[cfg(feature = "options")]
180 InterpolationMethod::Pyramid => {
181 self.to_pcs_impl(input, &mut new_dst, |x, y, z, w| {
182 lut.pyramid_vec3(x, y, z, w)
183 })?;
184 }
185 #[cfg(feature = "options")]
186 InterpolationMethod::Prism => {
187 self.to_pcs_impl(input, &mut new_dst, |x, y, z, w| lut.prism_vec3(x, y, z, w))?;
188 }
189 InterpolationMethod::Linear => {
190 self.to_pcs_impl(input, &mut new_dst, |x, y, z, w| {
191 lut.quadlinear_vec3(x, y, z, w)
192 })?;
193 }
194 }
195 Ok(new_dst)
196 }
197 }
198
199 fn make_multidimensional_4x3<
200 T: Copy + Default + AsPrimitive<f32> + PointeeSizeExpressible + Send + Sync,
201 >(
202 mab: &LutMultidimensionalType,
203 options: TransformOptions,
204 pcs: DataColorSpace,
205 direction: MultidimensionalDirection,
206 bit_depth: usize,
207 ) -> Result<Multidimensional4x3<T>, CmsError> {
208 if mab.num_input_channels != 4 && mab.num_output_channels != 3 {
209 return Err(CmsError::UnsupportedProfileConnection);
210 }
211 if mab.b_curves.is_empty() || mab.b_curves.len() != 3 {
212 return Err(CmsError::InvalidAtoBLut);
213 }
214
215 let grid_size = [
216 mab.grid_points[0],
217 mab.grid_points[1],
218 mab.grid_points[2],
219 mab.grid_points[3],
220 ];
221
222 let clut: Option<Vec<f32>> = if mab.a_curves.len() == 4 && mab.clut.is_some() {
223 let clut = mab.clut.as_ref().map(|x| x.to_clut_f32()).unwrap();
224 let lut_grid = (mab.grid_points[0] as usize)
225 .safe_mul(mab.grid_points[1] as usize)?
226 .safe_mul(mab.grid_points[2] as usize)?
227 .safe_mul(mab.grid_points[3] as usize)?
228 .safe_mul(mab.num_output_channels as usize)?;
229 if clut.len() != lut_grid {
230 return Err(CmsError::MalformedCurveLutTable(MalformedSize {
231 size: clut.len(),
232 expected: lut_grid,
233 }));
234 }
235 Some(clut)
236 } else {
237 return Err(CmsError::InvalidAtoBLut);
238 };
239
240 let a_curves: Option<Box<[Vec<f32>; 4]>> = if mab.a_curves.len() == 4 && mab.clut.is_some() {
241 let mut arr = Box::<[Vec<f32>; 4]>::default();
242 for (a_curve, dst) in mab.a_curves.iter().zip(arr.iter_mut()) {
243 *dst = a_curve.to_clut()?;
244 }
245 Some(arr)
246 } else {
247 None
248 };
249
250 let b_curves: Option<Box<[Vec<f32>; 3]>> = if mab.b_curves.len() == 3 {
251 let mut arr = Box::<[Vec<f32>; 3]>::default();
252 let all_curves_linear = mab.b_curves.iter().all(|curve| curve.is_linear());
253 if all_curves_linear {
254 None
255 } else {
256 for (c_curve, dst) in mab.b_curves.iter().zip(arr.iter_mut()) {
257 *dst = c_curve.to_clut()?;
258 }
259 Some(arr)
260 }
261 } else {
262 return Err(CmsError::InvalidAtoBLut);
263 };
264
265 let matrix = mab.matrix.to_f32();
266
267 let m_curves: Option<Box<[Vec<f32>; 3]>> = if mab.m_curves.len() == 3 {
268 let all_curves_linear = mab.m_curves.iter().all(|curve| curve.is_linear());
269 if !all_curves_linear
270 || !mab.matrix.test_equality(Matrix3d::IDENTITY)
271 || mab.bias.ne(&Vector3d::default())
272 {
273 let mut arr = Box::<[Vec<f32>; 3]>::default();
274 for (curve, dst) in mab.m_curves.iter().zip(arr.iter_mut()) {
275 *dst = curve.to_clut()?;
276 }
277 Some(arr)
278 } else {
279 None
280 }
281 } else {
282 None
283 };
284
285 let bias = mab.bias.cast();
286
287 let transform = Multidimensional4x3::<T> {
288 a_curves,
289 b_curves,
290 m_curves,
291 matrix,
292 direction,
293 options,
294 clut,
295 pcs,
296 grid_size,
297 bias,
298 _phantom: PhantomData,
299 bit_depth,
300 };
301
302 Ok(transform)
303 }
304
305 pub(crate) fn multi_dimensional_4x3_to_pcs<
306 T: Copy + Default + AsPrimitive<f32> + PointeeSizeExpressible + Send + Sync,
307 >(
308 mab: &LutMultidimensionalType,
309 options: TransformOptions,
310 pcs: DataColorSpace,
311 bit_depth: usize,
312 ) -> Result<Box<dyn KatanaInitialStage<f32, T> + Send + Sync>, CmsError> {
313 let transform = make_multidimensional_4x3::<T>(
314 mab,
315 options,
316 pcs,
317 MultidimensionalDirection::DeviceToPcs,
318 bit_depth,
319 )?;
320 Ok(Box::new(transform))
321 }