From fbaf0bb26397aa498eb9156f06d5a6fe34dd7dd8 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 03:14:29 +0200 Subject: Merging upstream version 125.0.1. Signed-off-by: Daniel Baumann --- gfx/qcms/Cargo.toml | 3 + gfx/qcms/build.rs | 7 ++ gfx/qcms/src/iccread.rs | 4 +- gfx/qcms/src/lib.rs | 6 +- gfx/qcms/src/transform.rs | 179 +++++++++++++++++++---------------------- gfx/qcms/src/transform_avx.rs | 22 ++--- gfx/qcms/src/transform_neon.rs | 14 ++-- gfx/qcms/src/transform_sse2.rs | 12 +-- gfx/qcms/src/transform_util.rs | 3 +- 9 files changed, 123 insertions(+), 127 deletions(-) create mode 100644 gfx/qcms/build.rs (limited to 'gfx/qcms') diff --git a/gfx/qcms/Cargo.toml b/gfx/qcms/Cargo.toml index 094d1183d1..c6e0e76722 100644 --- a/gfx/qcms/Cargo.toml +++ b/gfx/qcms/Cargo.toml @@ -20,3 +20,6 @@ cmyk = [] [dependencies] libc = {version = "0.2", optional = true } + +[build-dependencies] +version_check = "0.9" diff --git a/gfx/qcms/build.rs b/gfx/qcms/build.rs new file mode 100644 index 0000000000..6810a8828e --- /dev/null +++ b/gfx/qcms/build.rs @@ -0,0 +1,7 @@ +extern crate version_check as rustc; + +fn main() { + if rustc::is_min_version("1.78.0").unwrap_or(false) { + println!("cargo:rustc-cfg=stdsimd_split"); + } +} diff --git a/gfx/qcms/src/iccread.rs b/gfx/qcms/src/iccread.rs index ad45a58d35..ba2b5a3257 100644 --- a/gfx/qcms/src/iccread.rs +++ b/gfx/qcms/src/iccread.rs @@ -61,9 +61,7 @@ pub struct Profile { pub(crate) mAB: Option>, pub(crate) mBA: Option>, pub(crate) chromaticAdaption: Option, - pub(crate) output_table_r: Option>, - pub(crate) output_table_g: Option>, - pub(crate) output_table_b: Option>, + pub(crate) precache_output: Option>, is_srgb: bool, } diff --git a/gfx/qcms/src/lib.rs b/gfx/qcms/src/lib.rs index c311964ee3..fc496816a8 100644 --- a/gfx/qcms/src/lib.rs +++ b/gfx/qcms/src/lib.rs @@ -7,9 +7,11 @@ #![allow(non_upper_case_globals)] // These are needed for the neon SIMD code and can be removed once the MSRV supports the // instrinsics we use -#![cfg_attr(feature = "neon", feature(stdsimd))] +#![cfg_attr(all(stdsimd_split, target_arch = "arm", feature = "neon"), feature(stdarch_arm_neon_intrinsics))] +#![cfg_attr(all(stdsimd_split, target_arch = "arm", feature = "neon"), feature(stdarch_arm_feature_detection))] +#![cfg_attr(all(not(stdsimd_split), target_arch = "arm", feature = "neon"), feature(stdsimd))] #![cfg_attr( - feature = "neon", + all(target_arch = "arm", feature = "neon"), feature(arm_target_feature, raw_ref_op) )] diff --git a/gfx/qcms/src/transform.rs b/gfx/qcms/src/transform.rs index b0c8b60b18..54f89864eb 100644 --- a/gfx/qcms/src/transform.rs +++ b/gfx/qcms/src/transform.rs @@ -73,13 +73,17 @@ pub struct PrecacheOuput { * improve startup performance and reduce memory usage. ColorSync on * 10.5 uses 4097 which is perhaps because they use a fixed point * representation where 1. is represented by 0x1000. */ - pub data: [u8; PRECACHE_OUTPUT_SIZE], + pub lut_r: [u8; PRECACHE_OUTPUT_SIZE], + pub lut_g: [u8; PRECACHE_OUTPUT_SIZE], + pub lut_b: [u8; PRECACHE_OUTPUT_SIZE], } impl Default for PrecacheOuput { fn default() -> PrecacheOuput { PrecacheOuput { - data: [0; PRECACHE_OUTPUT_SIZE], + lut_r: [0; PRECACHE_OUTPUT_SIZE], + lut_g: [0; PRECACHE_OUTPUT_SIZE], + lut_b: [0; PRECACHE_OUTPUT_SIZE], } } } @@ -113,9 +117,7 @@ pub struct qcms_transform { pub output_gamma_lut_g_length: usize, pub output_gamma_lut_b_length: usize, pub output_gamma_lut_gray_length: usize, - pub output_table_r: Option>, - pub output_table_g: Option>, - pub output_table_b: Option>, + pub precache_output: Option>, pub transform_fn: transform_fn_t, } @@ -414,15 +416,15 @@ unsafe extern "C" fn qcms_transform_data_gray_template_lut(transform, src, dest, length); } unsafe fn qcms_transform_data_gray_template_precache( - transform: *const qcms_transform, + transform: &qcms_transform, mut src: *const u8, mut dest: *mut u8, length: usize, ) { let components: u32 = if F::kAIndex == 0xff { 3 } else { 4 } as u32; - let output_table_r = ((*transform).output_table_r).as_deref().unwrap(); - let output_table_g = ((*transform).output_table_g).as_deref().unwrap(); - let output_table_b = ((*transform).output_table_b).as_deref().unwrap(); + let precache_output = transform.precache_output.as_deref().unwrap(); + let output_r = &precache_output.lut_r; + let output_g = &precache_output.lut_g; + let output_b = &precache_output.lut_b; - let input_gamma_table_gray = (*transform) + let input_gamma_table_gray = transform .input_gamma_table_gray .as_ref() .unwrap() @@ -506,9 +509,9 @@ unsafe fn qcms_transform_data_gray_template_precache( let linear: f32 = *input_gamma_table_gray.offset(device as isize); /* we could round here... */ let gray: u16 = (linear * PRECACHE_OUTPUT_MAX as f32) as u16; - *dest.add(F::kRIndex) = (output_table_r).data[gray as usize]; - *dest.add(F::kGIndex) = (output_table_g).data[gray as usize]; - *dest.add(F::kBIndex) = (output_table_b).data[gray as usize]; + *dest.add(F::kRIndex) = output_r[gray as usize]; + *dest.add(F::kGIndex) = output_g[gray as usize]; + *dest.add(F::kBIndex) = output_b[gray as usize]; if F::kAIndex != 0xff { *dest.add(F::kAIndex) = alpha } @@ -563,12 +566,12 @@ unsafe fn qcms_transform_data_template_lut_precache( length: usize, ) { let components: u32 = if F::kAIndex == 0xff { 3 } else { 4 } as u32; - let output_table_r = ((*transform).output_table_r).as_deref().unwrap(); - let output_table_g = ((*transform).output_table_g).as_deref().unwrap(); - let output_table_b = ((*transform).output_table_b).as_deref().unwrap(); - let input_gamma_table_r = (*transform).input_gamma_table_r.as_ref().unwrap().as_ptr(); - let input_gamma_table_g = (*transform).input_gamma_table_g.as_ref().unwrap().as_ptr(); - let input_gamma_table_b = (*transform).input_gamma_table_b.as_ref().unwrap().as_ptr(); + let output_table_r = &transform.precache_output.as_deref().unwrap().lut_r; + let output_table_g = &transform.precache_output.as_deref().unwrap().lut_g; + let output_table_b = &transform.precache_output.as_deref().unwrap().lut_b; + let input_gamma_table_r = transform.input_gamma_table_r.as_ref().unwrap().as_ptr(); + let input_gamma_table_g = transform.input_gamma_table_g.as_ref().unwrap().as_ptr(); + let input_gamma_table_b = transform.input_gamma_table_b.as_ref().unwrap().as_ptr(); let mat = &transform.matrix; let mut i: u32 = 0; @@ -596,9 +599,9 @@ unsafe fn qcms_transform_data_template_lut_precache( let r: u16 = (out_linear_r * PRECACHE_OUTPUT_MAX as f32) as u16; let g: u16 = (out_linear_g * PRECACHE_OUTPUT_MAX as f32) as u16; let b: u16 = (out_linear_b * PRECACHE_OUTPUT_MAX as f32) as u16; - *dest.add(F::kRIndex) = (output_table_r).data[r as usize]; - *dest.add(F::kGIndex) = (output_table_g).data[g as usize]; - *dest.add(F::kBIndex) = (output_table_b).data[b as usize]; + *dest.add(F::kRIndex) = output_table_r[r as usize]; + *dest.add(F::kGIndex) = output_table_g[g as usize]; + *dest.add(F::kBIndex) = output_table_b[b as usize]; if F::kAIndex != 0xff { *dest.add(F::kAIndex) = alpha } @@ -695,7 +698,7 @@ fn int_div_ceil(value: i32, div: i32) -> i32 { } // Using lcms' tetra interpolation algorithm. unsafe extern "C" fn qcms_transform_data_tetra_clut_template( - transform: *const qcms_transform, + transform: &qcms_transform, mut src: *const u8, mut dest: *mut u8, length: usize, @@ -703,9 +706,9 @@ unsafe extern "C" fn qcms_transform_data_tetra_clut_template( let components: u32 = if F::kAIndex == 0xff { 3 } else { 4 } as u32; let xy_len: i32 = 1; - let x_len: i32 = (*transform).grid_size as i32; + let x_len: i32 = transform.grid_size as i32; let len: i32 = x_len * x_len; - let table = (*transform).clut.as_ref().unwrap().as_ptr(); + let table = transform.clut.as_ref().unwrap().as_ptr(); let r_table: *const f32 = table; let g_table: *const f32 = table.offset(1); let b_table: *const f32 = table.offset(2); @@ -735,15 +738,15 @@ unsafe extern "C" fn qcms_transform_data_tetra_clut_template( let linear_r: f32 = in_r as i32 as f32 / 255.0; let linear_g: f32 = in_g as i32 as f32 / 255.0; let linear_b: f32 = in_b as i32 as f32 / 255.0; - let x: i32 = in_r as i32 * ((*transform).grid_size as i32 - 1) / 255; - let y: i32 = in_g as i32 * ((*transform).grid_size as i32 - 1) / 255; - let z: i32 = in_b as i32 * ((*transform).grid_size as i32 - 1) / 255; - let x_n: i32 = int_div_ceil(in_r as i32 * ((*transform).grid_size as i32 - 1), 255); - let y_n: i32 = int_div_ceil(in_g as i32 * ((*transform).grid_size as i32 - 1), 255); - let z_n: i32 = int_div_ceil(in_b as i32 * ((*transform).grid_size as i32 - 1), 255); - let rx: f32 = linear_r * ((*transform).grid_size as i32 - 1) as f32 - x as f32; - let ry: f32 = linear_g * ((*transform).grid_size as i32 - 1) as f32 - y as f32; - let rz: f32 = linear_b * ((*transform).grid_size as i32 - 1) as f32 - z as f32; + let x: i32 = in_r as i32 * (transform.grid_size as i32 - 1) / 255; + let y: i32 = in_g as i32 * (transform.grid_size as i32 - 1) / 255; + let z: i32 = in_b as i32 * (transform.grid_size as i32 - 1) / 255; + let x_n: i32 = int_div_ceil(in_r as i32 * (transform.grid_size as i32 - 1), 255); + let y_n: i32 = int_div_ceil(in_g as i32 * (transform.grid_size as i32 - 1), 255); + let z_n: i32 = int_div_ceil(in_b as i32 * (transform.grid_size as i32 - 1), 255); + let rx: f32 = linear_r * (transform.grid_size as i32 - 1) as f32 - x as f32; + let ry: f32 = linear_g * (transform.grid_size as i32 - 1) as f32 - y as f32; + let rz: f32 = linear_b * (transform.grid_size as i32 - 1) as f32 - z as f32; let CLU = |table: *const f32, x, y, z| { *table.offset(((x * len + y * x_len + z * xy_len) * 3) as isize) }; @@ -848,17 +851,17 @@ unsafe fn tetra( let linear_g: f32 = in_g as i32 as f32 / 255.0; let linear_b: f32 = in_b as i32 as f32 / 255.0; let xy_len: i32 = 1; - let x_len: i32 = (*transform).grid_size as i32; + let x_len: i32 = transform.grid_size as i32; let len: i32 = x_len * x_len; - let x: i32 = in_r as i32 * ((*transform).grid_size as i32 - 1) / 255; - let y: i32 = in_g as i32 * ((*transform).grid_size as i32 - 1) / 255; - let z: i32 = in_b as i32 * ((*transform).grid_size as i32 - 1) / 255; - let x_n: i32 = int_div_ceil(in_r as i32 * ((*transform).grid_size as i32 - 1), 255); - let y_n: i32 = int_div_ceil(in_g as i32 * ((*transform).grid_size as i32 - 1), 255); - let z_n: i32 = int_div_ceil(in_b as i32 * ((*transform).grid_size as i32 - 1), 255); - let rx: f32 = linear_r * ((*transform).grid_size as i32 - 1) as f32 - x as f32; - let ry: f32 = linear_g * ((*transform).grid_size as i32 - 1) as f32 - y as f32; - let rz: f32 = linear_b * ((*transform).grid_size as i32 - 1) as f32 - z as f32; + let x: i32 = in_r as i32 * (transform.grid_size as i32 - 1) / 255; + let y: i32 = in_g as i32 * (transform.grid_size as i32 - 1) / 255; + let z: i32 = in_b as i32 * (transform.grid_size as i32 - 1) / 255; + let x_n: i32 = int_div_ceil(in_r as i32 * (transform.grid_size as i32 - 1), 255); + let y_n: i32 = int_div_ceil(in_g as i32 * (transform.grid_size as i32 - 1), 255); + let z_n: i32 = int_div_ceil(in_b as i32 * (transform.grid_size as i32 - 1), 255); + let rx: f32 = linear_r * (transform.grid_size as i32 - 1) as f32 - x as f32; + let ry: f32 = linear_g * (transform.grid_size as i32 - 1) as f32 - y as f32; + let rz: f32 = linear_b * (transform.grid_size as i32 - 1) as f32 - z as f32; let CLU = |table: *const f32, x, y, z| { *table.offset(((x * len + y * x_len + z * xy_len) * 3) as isize) }; @@ -966,9 +969,9 @@ unsafe fn qcms_transform_data_tetra_clut_cmyk( mut dest: *mut u8, length: usize, ) { - let table = (*transform).clut.as_ref().unwrap().as_ptr(); + let table = transform.clut.as_ref().unwrap().as_ptr(); assert!( - (*transform).clut.as_ref().unwrap().len() + transform.clut.as_ref().unwrap().len() >= ((transform.grid_size as i32).pow(4) * 3) as usize ); for _ in 0..length { @@ -978,10 +981,10 @@ unsafe fn qcms_transform_data_tetra_clut_cmyk( let k: u8 = *src.add(3); src = src.offset(4); let linear_k: f32 = k as i32 as f32 / 255.0; - let grid_size = (*transform).grid_size as i32; - let w: i32 = k as i32 * ((*transform).grid_size as i32 - 1) / 255; - let w_n: i32 = int_div_ceil(k as i32 * ((*transform).grid_size as i32 - 1), 255); - let t: f32 = linear_k * ((*transform).grid_size as i32 - 1) as f32 - w as f32; + let grid_size = transform.grid_size as i32; + let w: i32 = k as i32 * (transform.grid_size as i32 - 1) / 255; + let w_n: i32 = int_div_ceil(k as i32 * (transform.grid_size as i32 - 1), 255); + let t: f32 = linear_k * (transform.grid_size as i32 - 1) as f32 - w as f32; let table1 = table.offset((w * grid_size * grid_size * grid_size * 3) as isize); let table2 = table.offset((w_n * grid_size * grid_size * grid_size * 3) as isize); @@ -1032,9 +1035,9 @@ unsafe fn qcms_transform_data_template_lut( let mat = &transform.matrix; let mut i: u32 = 0; - let input_gamma_table_r = (*transform).input_gamma_table_r.as_ref().unwrap().as_ptr(); - let input_gamma_table_g = (*transform).input_gamma_table_g.as_ref().unwrap().as_ptr(); - let input_gamma_table_b = (*transform).input_gamma_table_b.as_ref().unwrap().as_ptr(); + let input_gamma_table_r = transform.input_gamma_table_r.as_ref().unwrap().as_ptr(); + let input_gamma_table_g = transform.input_gamma_table_g.as_ref().unwrap().as_ptr(); + let input_gamma_table_b = transform.input_gamma_table_b.as_ref().unwrap().as_ptr(); while (i as usize) < length { let device_r: u8 = *src.add(F::kRIndex); let device_g: u8 = *src.add(F::kGIndex); @@ -1057,15 +1060,15 @@ unsafe fn qcms_transform_data_template_lut( let out_device_r: f32 = lut_interp_linear( out_linear_r as f64, - &(*transform).output_gamma_lut_r.as_ref().unwrap(), + &transform.output_gamma_lut_r.as_ref().unwrap(), ); let out_device_g: f32 = lut_interp_linear( out_linear_g as f64, - (*transform).output_gamma_lut_g.as_ref().unwrap(), + transform.output_gamma_lut_g.as_ref().unwrap(), ); let out_device_b: f32 = lut_interp_linear( out_linear_b as f64, - (*transform).output_gamma_lut_b.as_ref().unwrap(), + transform.output_gamma_lut_b.as_ref().unwrap(), ); *dest.add(F::kRIndex) = clamp_u8(out_device_r * 255f32); *dest.add(F::kGIndex) = clamp_u8(out_device_g * 255f32); @@ -1172,33 +1175,22 @@ pub extern "C" fn qcms_profile_precache_output_transform(profile: &mut Profile) if profile.redTRC.is_none() || profile.greenTRC.is_none() || profile.blueTRC.is_none() { return; } - if profile.output_table_r.is_none() { - let mut output_table_r = precache_create(); - if compute_precache( + if profile.precache_output.is_none() { + let mut precache = precache_create(); + compute_precache( profile.redTRC.as_deref().unwrap(), - &mut Arc::get_mut(&mut output_table_r).unwrap().data, - ) { - profile.output_table_r = Some(output_table_r); - } - } - if profile.output_table_g.is_none() { - let mut output_table_g = precache_create(); - if compute_precache( + &mut Arc::get_mut(&mut precache).unwrap().lut_r, + ); + compute_precache( profile.greenTRC.as_deref().unwrap(), - &mut Arc::get_mut(&mut output_table_g).unwrap().data, - ) { - profile.output_table_g = Some(output_table_g); - } - } - if profile.output_table_b.is_none() { - let mut output_table_b = precache_create(); - if compute_precache( + &mut Arc::get_mut(&mut precache).unwrap().lut_g, + ); + compute_precache( profile.blueTRC.as_deref().unwrap(), - &mut Arc::get_mut(&mut output_table_b).unwrap().data, - ) { - profile.output_table_b = Some(output_table_b); - } - }; + &mut Arc::get_mut(&mut precache).unwrap().lut_b, + ); + profile.precache_output = Some(precache); + } } /* Replace the current transformation with a LUT transformation using a given number of sample points */ fn transform_precacheLUT_float( @@ -1225,16 +1217,16 @@ fn transform_precacheLUT_float( } let lut = chain_transform(input, output, src, dest, lutSize as usize); if let Some(lut) = lut { - (*transform).clut = Some(lut); - (*transform).grid_size = samples as u16; + transform.clut = Some(lut); + transform.grid_size = samples as u16; if in_type == RGBA8 { - (*transform).transform_fn = Some(qcms_transform_data_tetra_clut_rgba) + transform.transform_fn = Some(qcms_transform_data_tetra_clut_rgba) } else if in_type == BGRA8 { - (*transform).transform_fn = Some(qcms_transform_data_tetra_clut_bgra) + transform.transform_fn = Some(qcms_transform_data_tetra_clut_bgra) } else if in_type == RGB8 { - (*transform).transform_fn = Some(qcms_transform_data_tetra_clut_rgb) + transform.transform_fn = Some(qcms_transform_data_tetra_clut_rgb) } - debug_assert!((*transform).transform_fn.is_some()); + debug_assert!(transform.transform_fn.is_some()); } else { return None; } @@ -1303,10 +1295,7 @@ pub fn transform_create( } let mut transform: Box = Box::new(Default::default()); let mut precache: bool = false; - if output.output_table_r.is_some() - && output.output_table_g.is_some() - && output.output_table_b.is_some() - { + if output.precache_output.is_some() { precache = true } // This precache assumes RGB_SIGNATURE (fails on GRAY_SIGNATURE, for instance) @@ -1330,9 +1319,7 @@ pub fn transform_create( return result; } if precache { - transform.output_table_r = Some(Arc::clone(output.output_table_r.as_ref().unwrap())); - transform.output_table_g = Some(Arc::clone(output.output_table_g.as_ref().unwrap())); - transform.output_table_b = Some(Arc::clone(output.output_table_b.as_ref().unwrap())); + transform.precache_output = Some(Arc::clone(output.precache_output.as_ref().unwrap())); } else { if output.redTRC.is_none() || output.greenTRC.is_none() || output.blueTRC.is_none() { return None; diff --git a/gfx/qcms/src/transform_avx.rs b/gfx/qcms/src/transform_avx.rs index 3a000e56ba..04ca752a83 100644 --- a/gfx/qcms/src/transform_avx.rs +++ b/gfx/qcms/src/transform_avx.rs @@ -24,33 +24,33 @@ unsafe extern "C" fn qcms_transform_data_template_lut_avx( mut dest: *mut u8, mut length: usize, ) { - let mat: *const [f32; 4] = (*transform).matrix.as_ptr(); + let mat: *const [f32; 4] = transform.matrix.as_ptr(); let mut input: Output = std::mem::zeroed(); /* share input and output locations to save having to keep the * locations in separate registers */ let output: *const u32 = &mut input as *mut Output as *mut u32; /* deref *transform now to avoid it in loop */ - let igtbl_r: *const f32 = (*transform).input_gamma_table_r.as_ref().unwrap().as_ptr(); - let igtbl_g: *const f32 = (*transform).input_gamma_table_g.as_ref().unwrap().as_ptr(); - let igtbl_b: *const f32 = (*transform).input_gamma_table_b.as_ref().unwrap().as_ptr(); + let igtbl_r: *const f32 = transform.input_gamma_table_r.as_ref().unwrap().as_ptr(); + let igtbl_g: *const f32 = transform.input_gamma_table_g.as_ref().unwrap().as_ptr(); + let igtbl_b: *const f32 = transform.input_gamma_table_b.as_ref().unwrap().as_ptr(); /* deref *transform now to avoid it in loop */ - let otdata_r: *const u8 = (*transform) - .output_table_r + let otdata_r: *const u8 = transform + .precache_output .as_deref() .unwrap() - .data + .lut_r .as_ptr(); let otdata_g: *const u8 = (*transform) - .output_table_g + .precache_output .as_deref() .unwrap() - .data + .lut_g .as_ptr(); let otdata_b: *const u8 = (*transform) - .output_table_b + .precache_output .as_deref() .unwrap() - .data + .lut_b .as_ptr(); /* input matrix values never change */ let mat0: __m256 = _mm256_broadcast_ps(&*((*mat.offset(0isize)).as_ptr() as *const __m128)); diff --git a/gfx/qcms/src/transform_neon.rs b/gfx/qcms/src/transform_neon.rs index b14b67107d..121b52ff52 100644 --- a/gfx/qcms/src/transform_neon.rs +++ b/gfx/qcms/src/transform_neon.rs @@ -25,23 +25,23 @@ unsafe fn qcms_transform_data_template_lut_neon( let igtbl_g: *const f32 = (*transform).input_gamma_table_g.as_ref().unwrap().as_ptr(); let igtbl_b: *const f32 = (*transform).input_gamma_table_b.as_ref().unwrap().as_ptr(); /* deref *transform now to avoid it in loop */ - let otdata_r: *const u8 = (*transform) - .output_table_r + let otdata_r: *const u8 = transform + .precache_output .as_deref() .unwrap() - .data + .lut_r .as_ptr(); let otdata_g: *const u8 = (*transform) - .output_table_g + .precache_output .as_deref() .unwrap() - .data + .lut_g .as_ptr(); let otdata_b: *const u8 = (*transform) - .output_table_b + .precache_output .as_deref() .unwrap() - .data + .lut_b .as_ptr(); /* input matrix values never change */ let mat0: float32x4_t = vld1q_f32((*mat.offset(0isize)).as_ptr()); diff --git a/gfx/qcms/src/transform_sse2.rs b/gfx/qcms/src/transform_sse2.rs index f6bccaadc3..865a01be1c 100644 --- a/gfx/qcms/src/transform_sse2.rs +++ b/gfx/qcms/src/transform_sse2.rs @@ -30,22 +30,22 @@ unsafe extern "C" fn qcms_transform_data_template_lut_sse2( let igtbl_b: *const f32 = (*transform).input_gamma_table_b.as_ref().unwrap().as_ptr(); /* deref *transform now to avoid it in loop */ let otdata_r: *const u8 = (*transform) - .output_table_r + .precache_output .as_deref() .unwrap() - .data + .lut_r .as_ptr(); let otdata_g: *const u8 = (*transform) - .output_table_g + .precache_output .as_deref() .unwrap() - .data + .lut_g .as_ptr(); let otdata_b: *const u8 = (*transform) - .output_table_b + .precache_output .as_deref() .unwrap() - .data + .lut_b .as_ptr(); /* input matrix values never change */ let mat0: __m128 = _mm_load_ps((*mat.offset(0isize)).as_ptr()); diff --git a/gfx/qcms/src/transform_util.rs b/gfx/qcms/src/transform_util.rs index 75fd2ca0e2..f341ae7946 100644 --- a/gfx/qcms/src/transform_util.rs +++ b/gfx/qcms/src/transform_util.rs @@ -471,7 +471,7 @@ pub fn compute_precache_linear(output: &mut [u8; PRECACHE_OUTPUT_SIZE]) { output[v] = (v / (PRECACHE_OUTPUT_SIZE / 256)) as u8; } } -pub(crate) fn compute_precache(trc: &curveType, output: &mut [u8; PRECACHE_OUTPUT_SIZE]) -> bool { +pub(crate) fn compute_precache(trc: &curveType, output: &mut [u8; PRECACHE_OUTPUT_SIZE]) { match trc { curveType::Parametric(params) => { let mut gamma_table_uint: [u16; 256] = [0; 256]; @@ -512,7 +512,6 @@ pub(crate) fn compute_precache(trc: &curveType, output: &mut [u8; PRECACHE_OUTPU } } } - true } fn build_linear_table(length: usize) -> Vec { let mut output = Vec::with_capacity(length); -- cgit v1.2.3