linear-srgb 0.6.12

//! SIMD-accelerated sRGB ↔ linear conversion.
//!
//! This module provides high-performance conversion functions using AVX2/FMA SIMD
//! instructions via archmage/magetypes with runtime CPU feature detection.
//!
//! # API Overview
//!
//! ## Slice Functions (process entire slices)
//! - `srgb_to_linear_slice` - &mut \[f32\] sRGB → linear in-place
//! - `linear_to_srgb_slice` - &mut \[f32\] linear → sRGB in-place
//! - `srgb_u8_to_linear_slice` - &\[u8\] sRGB → &mut \[f32\] linear
//! - `linear_to_srgb_u8_slice` - &\[f32\] linear → &mut \[u8\] sRGB
//!
//! ## Single-value LUT Functions
//! - `srgb_u8_to_linear` - u8 → f32 via lookup table

// All archmage tokens are available on every platform — real impls on their
// native arch, zero-construction stubs elsewhere. The `#[arcane]` /
// `#[rite]` / `#[archmage::magetypes]` macros emit their own cfg guards
// based on the token param's arch, so tier wrappers only compile on their
// target platform — but we still need the imports in scope unconditionally
// for the macros to resolve.
#[allow(unused_imports)] // Some tokens are only live in cfg'd-out tier wrappers.
use archmage::{
    NeonToken, ScalarToken, Wasm128Token, X64V3Token, X64V4Token, arcane, incant, rite,
};

// Alias magetypes SIMD types to avoid name clash with the generic f32x8. These
// are used by the pre-magetypes #[rite] helpers below that take concrete V3/V4
// tokens; the helpers themselves are emitted only on x86_64 (via the token
// parameter's arch), and the aliases resolve on x86_64 since that's where
// `magetypes::simd::f32x8` is the concrete width-aware type. Cross-compiling
// to other arches excludes the helpers entirely, so the alias is unused
// there — but we still need it defined to satisfy reference inside the
// cfg-in scope on x86_64.

// ============================================================================
// Unified magetypes #[rite] helpers — single source per algorithm, per-tier
// variants generated by `#[magetypes(rite, define(f32x16), ...)]`.
//
// `f32x16` polyfills natively per tier: 1 op on V4 (AVX-512), 2× f32x8 on V3.
// V3 + V4 only — NEON/WASM/scalar slice dispatchers go through
// `crate::tokens::x4::*` rite helpers (still per-arch, by design).
// ============================================================================

// Pattern 2 dispatchers route to these via `incant!` inside their tier
// bodies. Scalar is auto-emitted as a fallback by archmage's `resolve_tiers`
// even when omitted from the list; our family dispatchers fall back to
// `crate::scalar::*` per-element for remainder loops, leaving the rite
// scalar variant unused on x86_64 — hence `dead_code` allow.
#[allow(dead_code)]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128)]
fn mt_srgb_to_linear(token: Token, srgb: [f32; 16]) -> [f32; 16] {
    use crate::rational_poly::{S2L_P, S2L_Q, SRGB_THRESHOLD};

    let srgb = f32x16::from_array(token, srgb);
    let zero = f32x16::zero(token);
    let one = f32x16::splat(token, 1.0);
    let clamped = srgb.max(zero).min(one);

    let linear_result = clamped * f32x16::splat(token, 1.0 / 12.92);

    let x = clamped;
    let yp = f32x16::splat(token, S2L_P[4]).mul_add(x, f32x16::splat(token, S2L_P[3]));
    let yp = yp.mul_add(x, f32x16::splat(token, S2L_P[2]));
    let yp = yp.mul_add(x, f32x16::splat(token, S2L_P[1]));
    let yp = yp.mul_add(x, f32x16::splat(token, S2L_P[0]));

    let yq = f32x16::splat(token, S2L_Q[4]).mul_add(x, f32x16::splat(token, S2L_Q[3]));
    let yq = yq.mul_add(x, f32x16::splat(token, S2L_Q[2]));
    let yq = yq.mul_add(x, f32x16::splat(token, S2L_Q[1]));
    let yq = yq.mul_add(x, f32x16::splat(token, S2L_Q[0]));

    let power_result = (yp / yq).min(one);

    let mask = clamped.simd_lt(f32x16::splat(token, SRGB_THRESHOLD));
    let result = f32x16::blend(mask, linear_result, power_result);
    // Force exact 1.0 for inputs >= 1.0 (polynomial may undershoot at boundary)
    let ge_one = srgb.simd_ge(one);
    f32x16::blend(ge_one, one, result).to_array()
}

// Pattern 2 dispatchers route to these via `incant!` inside their tier
// bodies. Scalar is auto-emitted as a fallback by archmage's `resolve_tiers`
// even when omitted from the list; our family dispatchers fall back to
// `crate::scalar::*` per-element for remainder loops, leaving the rite
// scalar variant unused on x86_64 — hence `dead_code` allow.
#[allow(dead_code)]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128)]
fn mt_linear_to_srgb(token: Token, linear: [f32; 16]) -> [f32; 16] {
    use crate::rational_poly::{L2S_P, L2S_Q, LINEAR_THRESHOLD};

    let linear = f32x16::from_array(token, linear);
    let zero = f32x16::zero(token);
    let one = f32x16::splat(token, 1.0);
    let clamped = linear.max(zero).min(one);

    let linear_result = clamped * f32x16::splat(token, 12.92);

    let x = clamped.sqrt();
    let yp = f32x16::splat(token, L2S_P[4]).mul_add(x, f32x16::splat(token, L2S_P[3]));
    let yp = yp.mul_add(x, f32x16::splat(token, L2S_P[2]));
    let yp = yp.mul_add(x, f32x16::splat(token, L2S_P[1]));
    let yp = yp.mul_add(x, f32x16::splat(token, L2S_P[0]));

    let yq = f32x16::splat(token, L2S_Q[4]).mul_add(x, f32x16::splat(token, L2S_Q[3]));
    let yq = yq.mul_add(x, f32x16::splat(token, L2S_Q[2]));
    let yq = yq.mul_add(x, f32x16::splat(token, L2S_Q[1]));
    let yq = yq.mul_add(x, f32x16::splat(token, L2S_Q[0]));

    let power_result = (yp / yq).min(one);

    let mask = clamped.simd_lt(f32x16::splat(token, LINEAR_THRESHOLD));
    let result = f32x16::blend(mask, linear_result, power_result);
    let ge_one = linear.simd_ge(one);
    f32x16::blend(ge_one, one, result).to_array()
}

// Pattern 2 dispatchers route to these via `incant!` inside their tier
// bodies. Scalar is auto-emitted as a fallback by archmage's `resolve_tiers`
// even when omitted from the list; our family dispatchers fall back to
// `crate::scalar::*` per-element for remainder loops, leaving the rite
// scalar variant unused on x86_64 — hence `dead_code` allow.
#[allow(dead_code)]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128)]
fn mt_gamma_to_linear(token: Token, encoded: [f32; 16], gamma: f32) -> [f32; 16] {
    let encoded = f32x16::from_array(token, encoded);
    let zero = f32x16::zero(token);
    let one = f32x16::splat(token, 1.0);
    let encoded = encoded.max(zero).min(one);
    encoded.pow_midp(gamma).to_array()
}

// Pattern 2 dispatchers route to these via `incant!` inside their tier
// bodies. Scalar is auto-emitted as a fallback by archmage's `resolve_tiers`
// even when omitted from the list; our family dispatchers fall back to
// `crate::scalar::*` per-element for remainder loops, leaving the rite
// scalar variant unused on x86_64 — hence `dead_code` allow.
#[allow(dead_code)]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128)]
fn mt_linear_to_gamma(token: Token, linear: [f32; 16], gamma: f32) -> [f32; 16] {
    let linear = f32x16::from_array(token, linear);
    let zero = f32x16::zero(token);
    let one = f32x16::splat(token, 1.0);
    let linear = linear.max(zero).min(one);
    linear.pow_midp(1.0 / gamma).to_array()
}

// ============================================================================
// sRGB ↔ Linear Slice Functions (plain + RGBA, magetypes-unified)
// ============================================================================

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn srgb_to_linear_slice_tier(_token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        *chunk = incant!(mt_srgb_to_linear(*chunk));
    }
    for v in remainder {
        *v = crate::scalar::srgb_to_linear(*v);
    }
}

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn srgb_to_linear_rgba_slice_tier(_token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let a = [chunk[3], chunk[7], chunk[11], chunk[15]];
        *chunk = incant!(mt_srgb_to_linear(*chunk));
        [chunk[3], chunk[7], chunk[11], chunk[15]] = a;
    }
    for pixel in remainder.chunks_exact_mut(4) {
        pixel[0] = crate::scalar::srgb_to_linear(pixel[0]);
        pixel[1] = crate::scalar::srgb_to_linear(pixel[1]);
        pixel[2] = crate::scalar::srgb_to_linear(pixel[2]);
    }
}

/// Convert sRGB f32 values to linear in-place.
///
/// Uses AVX-512 (16-wide), AVX2+FMA (8-wide), NEON (4-wide), or scalar depending on CPU.
///
/// # Example
/// ```
/// use linear_srgb::default::srgb_to_linear_slice;
///
/// let mut values = vec![0.0f32, 0.25, 0.5, 0.75, 1.0];
/// srgb_to_linear_slice(&mut values);
/// ```
#[inline]
pub fn srgb_to_linear_slice(values: &mut [f32]) {
    incant!(
        srgb_to_linear_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

/// Convert sRGB RGBA f32 values to linear in-place, preserving alpha.
///
/// Expects interleaved RGBA data (`[R, G, B, A, R, G, B, A, ...]`).
/// Every 4th element (alpha) is left unchanged. Trailing elements that
/// don't form a complete RGBA pixel are ignored.
///
/// # Example
/// ```
/// use linear_srgb::default::srgb_to_linear_rgba_slice;
///
/// let mut rgba = vec![0.5f32, 0.5, 0.5, 0.75, 1.0, 1.0, 1.0, 1.0];
/// srgb_to_linear_rgba_slice(&mut rgba);
/// assert_eq!(rgba[3], 0.75); // alpha preserved
/// ```
#[inline]
pub fn srgb_to_linear_rgba_slice(values: &mut [f32]) {
    incant!(
        srgb_to_linear_rgba_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_srgb_slice_tier(_token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        *chunk = incant!(mt_linear_to_srgb(*chunk));
    }
    for v in remainder {
        *v = crate::scalar::linear_to_srgb(*v);
    }
}

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_srgb_rgba_slice_tier(_token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let a = [chunk[3], chunk[7], chunk[11], chunk[15]];
        *chunk = incant!(mt_linear_to_srgb(*chunk));
        [chunk[3], chunk[7], chunk[11], chunk[15]] = a;
    }
    for pixel in remainder.chunks_exact_mut(4) {
        pixel[0] = crate::scalar::linear_to_srgb(pixel[0]);
        pixel[1] = crate::scalar::linear_to_srgb(pixel[1]);
        pixel[2] = crate::scalar::linear_to_srgb(pixel[2]);
    }
}

/// Convert linear f32 values to sRGB in-place.
///
/// Uses AVX-512 (16-wide), AVX2+FMA (8-wide), NEON (4-wide), or scalar depending on CPU.
///
/// # Example
/// ```
/// use linear_srgb::default::linear_to_srgb_slice;
///
/// let mut values = vec![0.0f32, 0.1, 0.2, 0.5, 1.0];
/// linear_to_srgb_slice(&mut values);
/// ```
#[inline]
pub fn linear_to_srgb_slice(values: &mut [f32]) {
    incant!(
        linear_to_srgb_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

/// Convert linear RGBA f32 values to sRGB in-place, preserving alpha.
///
/// Expects interleaved RGBA data (`[R, G, B, A, R, G, B, A, ...]`).
/// Every 4th element (alpha) is left unchanged. Trailing elements that
/// don't form a complete RGBA pixel are ignored.
///
/// # Example
/// ```
/// use linear_srgb::default::linear_to_srgb_rgba_slice;
///
/// let mut rgba = vec![0.2f32, 0.2, 0.2, 0.75, 0.8, 0.8, 0.8, 1.0];
/// linear_to_srgb_rgba_slice(&mut rgba);
/// assert_eq!(rgba[3], 0.75); // alpha preserved
/// ```
#[inline]
pub fn linear_to_srgb_rgba_slice(values: &mut [f32]) {
    incant!(
        linear_to_srgb_rgba_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ============================================================================
// Extended-range sRGB ↔ Linear Slice Functions (no clamping)
// ============================================================================

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn srgb_to_linear_extended_slice_tier(token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let v = f32x16::from_array(token, *chunk);
        *chunk = crate::tf::srgb::srgb_to_linear_extended_x16(token, v).to_array();
    }
    for v in remainder {
        *v = crate::scalar::srgb_to_linear_extended(*v);
    }
}

/// Convert sRGB f32 values to linear in-place without clamping (extended range).
///
/// Uses sign-preserving extension per CSS Color 4: `sign(v) * eotf(|v|)`.
/// Pure SIMD polynomial on x86-64 (AVX2+FMA), AArch64 (NEON), and
/// WebAssembly (SIMD128). Scalar `powf` fallback on other architectures.
///
/// Designed for **SDR cross-gamut conversion** — converting between gamuts
/// (P3→sRGB, BT.2020→sRGB, etc.) at SDR peak (linear 1.0). Out-of-gamut
/// values from the 3×3 matrix survive the transfer function and can be
/// gamut-mapped or composited downstream.
///
/// # Accuracy
///
/// Uses a 6/6 rational polynomial fitted to \[0, 8\] — wider domain
/// than the clamped path's 4/4 polynomial, with comparable in-range
/// accuracy (5 ULP max in \[0,1\] vs 11 for clamped).
///
/// | Precision | Max |encoded| for < 0.5 LSB error | Headroom |
/// |-----------|-------------------------------------|----------|
/// | u8 (8-bit) | 8.0 | 8× SDR |
/// | u16 (16-bit) | ~4.2 | ~4× SDR |
///
/// Covers all SDR cross-gamut conversions at u16 precision (ACES AP0
/// worst case is 1.50). u16 boundary measured via SIMD FMA dispatch.
///
/// # Example
/// ```
/// use linear_srgb::default::srgb_to_linear_extended_slice;
///
/// let mut values = vec![-0.1f32, 0.0, 0.5, 1.0, 1.5];
/// srgb_to_linear_extended_slice(&mut values);
/// assert!(values[0] < 0.0);  // negative preserved
/// assert!(values[4] > 1.0);  // super-white preserved
/// ```
#[inline]
pub fn srgb_to_linear_extended_slice(values: &mut [f32]) {
    incant!(
        srgb_to_linear_extended_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_srgb_extended_slice_tier(token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let v = f32x16::from_array(token, *chunk);
        *chunk = crate::tf::srgb::linear_to_srgb_extended_x16(token, v).to_array();
    }
    for v in remainder {
        *v = crate::scalar::linear_to_srgb_extended(*v);
    }
}

/// Convert linear f32 values to sRGB in-place without clamping (extended range).
///
/// Uses sign-preserving extension per CSS Color 4: `sign(v) * oetf(|v|)`.
/// Pure SIMD polynomial on x86-64 (AVX2+FMA), AArch64 (NEON), and
/// WebAssembly (SIMD128). Scalar `powf` fallback on other architectures.
///
/// Designed for **SDR cross-gamut conversion** — converting between gamuts
/// (P3→sRGB, BT.2020→sRGB, etc.) at SDR peak (linear 1.0).
///
/// # Accuracy
///
/// Uses a 6/6 rational polynomial fitted on √x to \[0, 64\]. The sqrt
/// compression gives excellent extrapolation — u16-safe across the
/// entire fitted domain (5 ULP max in \[0,1\]).
///
/// | Precision | Max |linear| for < 0.5 LSB error | Headroom |
/// |-----------|--------------------------------------|----------|
/// | u8 (8-bit) | 64.0 | 64× SDR |
/// | u16 (16-bit) | 64.0 | 64× SDR |
///
/// Covers all SDR cross-gamut conversions and all practical HDR
/// scenarios at u16 precision.
///
/// # Example
/// ```
/// use linear_srgb::default::linear_to_srgb_extended_slice;
///
/// let mut values = vec![-0.1f32, 0.0, 0.5, 1.0, 1.5];
/// linear_to_srgb_extended_slice(&mut values);
/// assert!(values[0] < 0.0);  // negative preserved
/// assert!(values[4] > 1.0);  // super-white preserved
/// ```
#[inline]
pub fn linear_to_srgb_extended_slice(values: &mut [f32]) {
    incant!(
        linear_to_srgb_extended_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ============================================================================
// sRGB→Linear + Premultiply RGBA f32 (SIMD-fused single-pass)
// ============================================================================

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn srgb_to_linear_premultiply_rgba_slice_tier(token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let a = [chunk[3], chunk[7], chunk[11], chunk[15]];
        let converted_arr = incant!(mt_srgb_to_linear(*chunk));
        let converted = f32x16::from_array(token, converted_arr);
        let alpha = f32x16::from_array(
            token,
            [
                a[0], a[0], a[0], 1.0, a[1], a[1], a[1], 1.0, a[2], a[2], a[2], 1.0, a[3], a[3],
                a[3], 1.0,
            ],
        );
        *chunk = (converted * alpha).to_array();
        [chunk[3], chunk[7], chunk[11], chunk[15]] = a;
    }
    for pixel in remainder.chunks_exact_mut(4) {
        let a = pixel[3];
        pixel[0] = crate::scalar::srgb_to_linear(pixel[0]) * a;
        pixel[1] = crate::scalar::srgb_to_linear(pixel[1]) * a;
        pixel[2] = crate::scalar::srgb_to_linear(pixel[2]) * a;
    }
}

/// Convert sRGB RGBA to linear premultiplied RGBA in-place.
///
/// Each RGB channel is converted from sRGB to linear light, then multiplied
/// by the alpha channel — in a single SIMD pass (no second memory traversal).
/// Alpha is left unchanged.
///
/// Input: `[R_srgb, G_srgb, B_srgb, A, ...]` (straight alpha)
/// Output: `[R_linear*A, G_linear*A, B_linear*A, A, ...]` (premultiplied alpha)
///
/// Trailing elements that don't form a complete RGBA pixel are ignored.
///
/// # Example
/// ```
/// use linear_srgb::default::srgb_to_linear_premultiply_rgba_slice;
///
/// let mut rgba = vec![0.5f32, 0.5, 0.5, 0.5, 1.0, 1.0, 1.0, 1.0];
/// srgb_to_linear_premultiply_rgba_slice(&mut rgba);
/// // RGB converted to linear then multiplied by alpha
/// assert!(rgba[0] < 0.15); // srgb_to_linear(0.5) ≈ 0.214, × 0.5 ≈ 0.107
/// assert_eq!(rgba[3], 0.5); // alpha preserved
/// ```
#[inline]
pub fn srgb_to_linear_premultiply_rgba_slice(values: &mut [f32]) {
    incant!(
        srgb_to_linear_premultiply_rgba_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ============================================================================
// Unpremultiply + Linear→sRGB RGBA f32 (SIMD-fused single-pass)
// ============================================================================

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn unpremultiply_linear_to_srgb_rgba_slice_tier(token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let a = [chunk[3], chunk[7], chunk[11], chunk[15]];
        let inv = [
            if a[0] > crate::UNPREMUL_ALPHA_THRESHOLD {
                1.0 / a[0]
            } else {
                0.0
            },
            if a[1] > crate::UNPREMUL_ALPHA_THRESHOLD {
                1.0 / a[1]
            } else {
                0.0
            },
            if a[2] > crate::UNPREMUL_ALPHA_THRESHOLD {
                1.0 / a[2]
            } else {
                0.0
            },
            if a[3] > crate::UNPREMUL_ALPHA_THRESHOLD {
                1.0 / a[3]
            } else {
                0.0
            },
        ];
        let v = f32x16::from_array(token, *chunk);
        let inv_alpha = f32x16::from_array(
            token,
            [
                inv[0], inv[0], inv[0], 1.0, inv[1], inv[1], inv[1], 1.0, inv[2], inv[2], inv[2],
                1.0, inv[3], inv[3], inv[3], 1.0,
            ],
        );
        let unpremul = (v * inv_alpha).to_array();
        *chunk = incant!(mt_linear_to_srgb(unpremul));
        [chunk[3], chunk[7], chunk[11], chunk[15]] = a;
    }
    for pixel in remainder.chunks_exact_mut(4) {
        let a = pixel[3];
        if a > crate::UNPREMUL_ALPHA_THRESHOLD {
            let inv_a = 1.0 / a;
            pixel[0] = crate::scalar::linear_to_srgb(pixel[0] * inv_a);
            pixel[1] = crate::scalar::linear_to_srgb(pixel[1] * inv_a);
            pixel[2] = crate::scalar::linear_to_srgb(pixel[2] * inv_a);
        } else {
            pixel[0] = 0.0;
            pixel[1] = 0.0;
            pixel[2] = 0.0;
        }
    }
}

/// Convert linear premultiplied RGBA to sRGB straight-alpha RGBA in-place.
///
/// Each RGB channel is divided by alpha (unpremultiplied), then converted
/// from linear light to sRGB — in a single SIMD pass. Alpha is left unchanged.
///
/// Input: `[R_linear*A, G_linear*A, B_linear*A, A, ...]` (premultiplied)
/// Output: `[R_srgb, G_srgb, B_srgb, A, ...]` (straight alpha)
///
/// When alpha is zero, the RGB channels are set to zero (fully transparent
/// pixels have no meaningful color). This avoids division-by-zero artifacts.
///
/// Trailing elements that don't form a complete RGBA pixel are ignored.
///
/// # Example
/// ```
/// use linear_srgb::default::{srgb_to_linear_premultiply_rgba_slice,
///     unpremultiply_linear_to_srgb_rgba_slice};
///
/// let mut rgba = vec![0.5f32, 0.5, 0.5, 0.75, 0.0, 0.0, 0.0, 0.0];
/// srgb_to_linear_premultiply_rgba_slice(&mut rgba);
/// unpremultiply_linear_to_srgb_rgba_slice(&mut rgba);
/// assert!((rgba[0] - 0.5).abs() < 1e-4); // roundtrips
/// assert_eq!(rgba[3], 0.75);              // alpha preserved
/// assert_eq!(rgba[4], 0.0);               // transparent pixel stays zero
/// ```
#[inline]
pub fn unpremultiply_linear_to_srgb_rgba_slice(values: &mut [f32]) {
    incant!(
        unpremultiply_linear_to_srgb_rgba_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ============================================================================
// u8 Batch Functions
// ============================================================================

/// Convert sRGB u8 values to linear f32.
///
/// Uses a precomputed LUT for each u8 value, processed in batches of 8.
///
/// # Panics
/// Panics if `input.len() != output.len()`.
///
/// # Example
/// ```
/// use linear_srgb::default::srgb_u8_to_linear_slice;
///
/// let input: Vec<u8> = (0..=255).collect();
/// let mut output = vec![0.0f32; 256];
/// srgb_u8_to_linear_slice(&input, &mut output);
/// ```
#[inline]
pub fn srgb_u8_to_linear_slice(input: &[u8], output: &mut [f32]) {
    assert_eq!(input.len(), output.len());

    let (in_chunks, in_remainder) = input.as_chunks::<8>();
    let (out_chunks, out_remainder) = output.as_chunks_mut::<8>();

    for (inp, out) in in_chunks.iter().zip(out_chunks.iter_mut()) {
        *out = crate::scalar::srgb_u8_to_linear_x8(*inp);
    }

    for (inp, out) in in_remainder.iter().zip(out_remainder.iter_mut()) {
        *out = crate::scalar::srgb_u8_to_linear(*inp);
    }
}

// ---------- SIMD-indexed LUT path for linear_to_srgb_u8_slice ----------
//
// Computes the LUT index in SIMD (clamp, FMA by (4095, 0.5), truncate-to-int)
// so the 8 scalar LUT loads following each SIMD chunk are independent and
// issue in parallel. Preserves the exact scalar LUT formula — output is
// bit-identical across all tiers.
//
// `#[archmage::magetypes(...)]` generates one tier-suffixed variant per
// SIMD token (`_v4`, `_v3`, `_neon`, `_wasm128`, `_scalar`) from this
// single body. `f32x8` is native on x86-V3 / x86-V4; on NEON / WASM128
// it's polyfilled as 2×f32x4 (inlined, no runtime overhead).

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_srgb_u8_slice_tier(token: Token, input: &[f32], output: &mut [u8]) {
    // f32x16 is native on V4 (AVX-512) and polyfilled on V3 (2×f32x8), NEON
    // (4×f32x4), Wasm128 (4×f32x4), and scalar. F32x8Backend isn't impl'd
    // for X64V4Token in published magetypes 0.9.19, so f32x16 is the
    // natural common width across all tiers.
    let lut = crate::const_luts::linear_to_srgb_u8();
    let (in_chunks, in_rem) = input.as_chunks::<16>();
    let (out_chunks, out_rem) = output.as_chunks_mut::<16>();
    for (inp, out) in in_chunks.iter().zip(out_chunks.iter_mut()) {
        let v = f32x16::from_array(token, *inp);
        let clamped = v.max(f32x16::zero(token)).min(f32x16::splat(token, 1.0));
        let idx_f = clamped.mul_add(f32x16::splat(token, 4095.0), f32x16::splat(token, 0.5));
        let idx_i = idx_f.to_i32().to_array();
        for i in 0..16 {
            out[i] = lut[(idx_i[i] as usize) & 0xFFF];
        }
    }
    for (inp, out) in in_rem.iter().zip(out_rem.iter_mut()) {
        let clamped = inp.clamp(0.0, 1.0);
        let idx = (clamped * 4095.0 + 0.5) as usize & 0xFFF;
        *out = lut[idx];
    }
}

/// Convert linear f32 values to sRGB u8.
///
/// Uses a 4096-entry const LUT with SIMD-computed indices (AVX-512 / AVX2+FMA
/// / NEON / WASM SIMD128) so the 4/8/16 scalar LUT loads per chunk can issue
/// in parallel rather than serializing through the float-to-int cast.
///
/// # Panics
/// Panics if `input.len() != output.len()`.
///
/// # Example
/// ```
/// use linear_srgb::default::linear_to_srgb_u8_slice;
///
/// let input: Vec<f32> = (0..=255).map(|i| i as f32 / 255.0).collect();
/// let mut output = vec![0u8; 256];
/// linear_to_srgb_u8_slice(&input, &mut output);
/// ```
#[inline]
pub fn linear_to_srgb_u8_slice(input: &[f32], output: &mut [u8]) {
    assert_eq!(input.len(), output.len());
    incant!(
        linear_to_srgb_u8_slice_tier(input, output),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ============================================================================
// u16 Batch Functions (LUT-based)
// ============================================================================

// ---------- SIMD polynomial path for srgb_u16_to_linear_slice ----------
//
// Normalizes u16→f32 via `*(1.0/65535.0)` (auto-vectorizes to
// vpmovzxwd + vcvtdq2ps + vmulps) and evaluates the `S2L_P/Q` rational
// polynomial with FMA. No LUT and no cache footprint — trades ~20 f32
// ops per lane for freeing the 256KB decode LUT from the L2 budget.
// Cross-tier output may differ by ≤1 u16 LSB (same precision envelope
// as the encode slice).

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn srgb_u16_to_linear_slice_tier(token: Token, input: &[u16], output: &mut [f32]) {
    use crate::rational_poly::{LINEAR_SCALE, S2L_P, S2L_Q, SRGB_THRESHOLD};

    let (in_chunks, in_rem) = input.as_chunks::<16>();
    let (out_chunks, out_rem) = output.as_chunks_mut::<16>();
    for (inp, out) in in_chunks.iter().zip(out_chunks.iter_mut()) {
        // u16 → f32, normalized to [0, 1]. Scalar widening auto-vectorizes.
        let mut f = [0.0f32; 16];
        for i in 0..16 {
            f[i] = inp[i] as f32;
        }
        let v = f32x16::from_array(token, f) * f32x16::splat(token, 1.0 / 65535.0);
        let one = f32x16::splat(token, 1.0);

        let linear_result = v * f32x16::splat(token, LINEAR_SCALE);

        let yp = f32x16::splat(token, S2L_P[4]).mul_add(v, f32x16::splat(token, S2L_P[3]));
        let yp = yp.mul_add(v, f32x16::splat(token, S2L_P[2]));
        let yp = yp.mul_add(v, f32x16::splat(token, S2L_P[1]));
        let yp = yp.mul_add(v, f32x16::splat(token, S2L_P[0]));

        let yq = f32x16::splat(token, S2L_Q[4]).mul_add(v, f32x16::splat(token, S2L_Q[3]));
        let yq = yq.mul_add(v, f32x16::splat(token, S2L_Q[2]));
        let yq = yq.mul_add(v, f32x16::splat(token, S2L_Q[1]));
        let yq = yq.mul_add(v, f32x16::splat(token, S2L_Q[0]));

        let power_result = (yp / yq).min(one);

        let mask = v.simd_le(f32x16::splat(token, SRGB_THRESHOLD));
        let result = f32x16::blend(mask, linear_result, power_result);

        // Match the scalar `srgb_to_linear_fast` early-exit: v >= 1.0 → 1.0.
        // At u16=65535 the normalized v rounds to 1 + 2^-16 in f32, and the
        // polynomial alone drifts a few ULP short of 1.0 — snap it back so
        // srgb_u16_to_linear(65535) == 1.0 bit-exact (as the LUT does).
        let ge_one = v.simd_ge(one);
        let result = f32x16::blend(ge_one, one, result);
        *out = result.to_array();
    }

    for (inp, out) in in_rem.iter().zip(out_rem.iter_mut()) {
        *out = crate::scalar::srgb_u16_to_linear(*inp);
    }
}

/// Convert sRGB u16 values to linear f32 via rational polynomial (SIMD).
///
/// Dispatches through `incant!` over `[v4, v3, neon, wasm128, scalar]` so
/// the polynomial evaluates 4/8/16 wide. No LUT and no cache footprint —
/// replaces the 256KB decode LUT on the slice path. Boundary values
/// (0, 65535) map exactly to (0.0, 1.0). Output may differ from the
/// scalar LUT by ≤1 f32 ULP at interior values.
///
/// # Panics
/// Panics if `input.len() != output.len()`.
#[inline]
pub fn srgb_u16_to_linear_slice(input: &[u16], output: &mut [f32]) {
    assert_eq!(input.len(), output.len());
    incant!(
        srgb_u16_to_linear_slice_tier(input, output),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ---------- SIMD polynomial + quantize path for linear_to_srgb_u16_slice ----------
//
// Inlines the linear→sRGB rational polynomial against the `rational_poly`
// constants (no `transfer` feature needed), scales by 65535+0.5, truncates
// to i32, and casts to u16. `f32x16` polyfills to 2×f32x8 on V3, 4×f32x4
// on NEON / WASM (inlined, no runtime overhead). Cross-tier output may
// differ by ≤1 u16 LSB — see `linear_to_srgb_u16_all_tiers_within_one_lsb`.

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_srgb_u16_slice_tier(token: Token, input: &[f32], output: &mut [u16]) {
    use crate::rational_poly::{L2S_P, L2S_Q, LINEAR_THRESHOLD};

    let (in_chunks, in_rem) = input.as_chunks::<16>();
    let (out_chunks, out_rem) = output.as_chunks_mut::<16>();
    for (inp, out) in in_chunks.iter().zip(out_chunks.iter_mut()) {
        let linear = f32x16::from_array(token, *inp);
        let zero = f32x16::zero(token);
        let one = f32x16::splat(token, 1.0);
        let clamped = linear.max(zero).min(one);
        let linear_result = clamped * f32x16::splat(token, 12.92);
        let x = clamped.sqrt();
        let yp = f32x16::splat(token, L2S_P[4]).mul_add(x, f32x16::splat(token, L2S_P[3]));
        let yp = yp.mul_add(x, f32x16::splat(token, L2S_P[2]));
        let yp = yp.mul_add(x, f32x16::splat(token, L2S_P[1]));
        let yp = yp.mul_add(x, f32x16::splat(token, L2S_P[0]));
        let yq = f32x16::splat(token, L2S_Q[4]).mul_add(x, f32x16::splat(token, L2S_Q[3]));
        let yq = yq.mul_add(x, f32x16::splat(token, L2S_Q[2]));
        let yq = yq.mul_add(x, f32x16::splat(token, L2S_Q[1]));
        let yq = yq.mul_add(x, f32x16::splat(token, L2S_Q[0]));
        let power_result = (yp / yq).min(one);
        let thresh_mask = clamped.simd_lt(f32x16::splat(token, LINEAR_THRESHOLD));
        let srgb = f32x16::blend(thresh_mask, linear_result, power_result);
        let ge_one = linear.simd_ge(one);
        let srgb = f32x16::blend(ge_one, one, srgb);

        let scaled = srgb.mul_add(f32x16::splat(token, 65535.0), f32x16::splat(token, 0.5));
        let idx_i = scaled.to_i32().to_array();
        for i in 0..16 {
            out[i] = idx_i[i] as u16;
        }
    }
    for (inp, out) in in_rem.iter().zip(out_rem.iter_mut()) {
        *out = crate::scalar::linear_to_srgb_u16(*inp);
    }
}

/// Convert linear f32 values to sRGB u16 via rational polynomial.
///
/// Perfect roundtrip. Dispatches through `incant!` over
/// `[v4, v3, neon, wasm128, scalar]` so the polynomial evaluates 4/8/16 wide
/// before f32→u16 quantization. For ~10× faster encode with ±1 max error,
/// use [`linear_to_srgb_u16_slice_fast`].
///
/// # Panics
/// Panics if `input.len() != output.len()`.
#[inline]
pub fn linear_to_srgb_u16_slice(input: &[f32], output: &mut [u16]) {
    assert_eq!(input.len(), output.len());
    incant!(
        linear_to_srgb_u16_slice_tier(input, output),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ---------- SIMD-indexed sqrt-LUT path for linear_to_srgb_u16_slice_fast ----------
//
// Same shape as the u8 LUT path but with sqrt-indexing:
//   idx = (sqrt(clamp(linear)) * ENCODE_SQRT_SCALE + 0.5) as usize
// SIMD does clamp, sqrt, FMA(65536, 0.5), cvttps2dq; the scalar LUT loads
// following each SIMD chunk are independent so they issue in parallel.
// Bit-exact output across all tiers (same formula).
//
// Requires `std` because the sqrt-LUT is lazily initialized via OnceLock.
// In `no_std` the scalar fallback uses the full polynomial (no LUT).

#[cfg(feature = "std")]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_srgb_u16_slice_fast_tier(token: Token, input: &[f32], output: &mut [u16]) {
    let lut = crate::u16_lut::encode_lut();
    let max_idx = crate::u16_lut::ENCODE_LUT_N - 1;
    let scale = crate::u16_lut::ENCODE_SQRT_SCALE;
    let (in_chunks, in_rem) = input.as_chunks::<16>();
    let (out_chunks, out_rem) = output.as_chunks_mut::<16>();
    for (inp, out) in in_chunks.iter().zip(out_chunks.iter_mut()) {
        let v = f32x16::from_array(token, *inp);
        let clamped = v.max(f32x16::zero(token)).min(f32x16::splat(token, 1.0));
        let idx_f = clamped
            .sqrt()
            .mul_add(f32x16::splat(token, scale), f32x16::splat(token, 0.5));
        let idx_i = idx_f.to_i32().to_array();
        for i in 0..16 {
            out[i] = lut[(idx_i[i] as usize).min(max_idx)];
        }
    }
    for (inp, out) in in_rem.iter().zip(out_rem.iter_mut()) {
        *out = crate::scalar::linear_to_srgb_u16_fast(*inp);
    }
}

/// Convert linear f32 values to sRGB u16 using sqrt-indexed LUT (~10× faster).
///
/// Max ±1 u16 roundtrip error, 94.2% exact. SIMD-computes the sqrt-based
/// index 4/8/16-wide per chunk so the scalar LUT loads can issue in
/// parallel. See [`linear_to_srgb_u16_fast`](crate::scalar::linear_to_srgb_u16_fast)
/// for the exact formula.
///
/// # Panics
/// Panics if `input.len() != output.len()`.
#[inline]
pub fn linear_to_srgb_u16_slice_fast(input: &[f32], output: &mut [u16]) {
    assert_eq!(input.len(), output.len());
    // The sqrt-LUT only exists with `std`. Without `std`, fall back to the
    // scalar polynomial path used by `linear_to_srgb_u16_fast`.
    #[cfg(feature = "std")]
    {
        incant!(
            linear_to_srgb_u16_slice_fast_tier(input, output),
            [v4, v3, neon, wasm128, scalar]
        )
    }
    #[cfg(not(feature = "std"))]
    {
        for (inp, out) in input.iter().zip(output.iter_mut()) {
            *out = crate::scalar::linear_to_srgb_u16_fast(*inp);
        }
    }
}

// ============================================================================
// RGBA u8 Batch Functions (LUT-based, alpha passthrough)
// ============================================================================

/// Convert sRGB RGBA u8 values to linear f32, preserving alpha.
///
/// RGB channels are decoded via LUT. Alpha is passed through as `a / 255.0`
/// without sRGB transfer. Trailing elements that don't form a complete
/// RGBA pixel are ignored.
///
/// # Panics
/// Panics if `input.len() != output.len()`.
///
/// # Example
/// ```
/// use linear_srgb::default::srgb_u8_to_linear_rgba_slice;
///
/// let input = [128u8, 128, 128, 255, 64, 64, 64, 128];
/// let mut output = [0.0f32; 8];
/// srgb_u8_to_linear_rgba_slice(&input, &mut output);
/// assert_eq!(output[3], 1.0);           // alpha 255 → 1.0
/// assert!((output[7] - 0.502).abs() < 0.01); // alpha 128 → ~0.502
/// ```
pub fn srgb_u8_to_linear_rgba_slice(input: &[u8], output: &mut [f32]) {
    assert_eq!(input.len(), output.len());

    // Process in x8 batches (2 RGBA pixels), fix alpha after LUT
    let (in_chunks, in_remainder) = input.as_chunks::<8>();
    let (out_chunks, out_remainder) = output.as_chunks_mut::<8>();

    for (inp, out) in in_chunks.iter().zip(out_chunks.iter_mut()) {
        *out = crate::scalar::srgb_u8_to_linear_x8(*inp);
        out[3] = inp[3] as f32 / 255.0;
        out[7] = inp[7] as f32 / 255.0;
    }

    // Remainder: at most one RGBA pixel (4 elements)
    let in_rem_pixels = in_remainder.chunks_exact(4);
    let out_rem_pixels = out_remainder.chunks_exact_mut(4);
    for (inp, out) in in_rem_pixels.zip(out_rem_pixels) {
        out[0] = crate::scalar::srgb_u8_to_linear(inp[0]);
        out[1] = crate::scalar::srgb_u8_to_linear(inp[1]);
        out[2] = crate::scalar::srgb_u8_to_linear(inp[2]);
        out[3] = inp[3] as f32 / 255.0;
    }
}

/// Convert linear RGBA f32 values to sRGB u8, preserving alpha.
///
/// RGB channels are encoded via 4096-entry const LUT. Alpha is passed through
/// as `(a * 255 + 0.5) as u8` without sRGB transfer. Trailing elements that
/// don't form a complete RGBA pixel are ignored.
///
/// # Panics
/// Panics if `input.len() != output.len()`.
///
/// # Example
/// ```
/// use linear_srgb::default::linear_to_srgb_u8_rgba_slice;
///
/// let input = [0.2158f32, 0.2158, 0.2158, 1.0, 0.05, 0.05, 0.05, 0.5];
/// let mut output = [0u8; 8];
/// linear_to_srgb_u8_rgba_slice(&input, &mut output);
/// assert_eq!(output[3], 255);  // alpha 1.0 → 255
/// assert_eq!(output[7], 128);  // alpha 0.5 → 128
/// ```
// ---------- SIMD-indexed LUT path for linear_to_srgb_u8_rgba_slice ----------
//
// Computes LUT indices in SIMD for all lanes; alpha lanes (every 4th) are
// overwritten with a scalar `(alpha * 255 + 0.5) as u8` direct cast. Same
// 25%-wasted-SIMD-lanes pattern as the other RGBA paths — wins come from
// parallelizing the LUT loads.

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_srgb_u8_rgba_slice_tier(token: Token, input: &[f32], output: &mut [u8]) {
    let lut = crate::const_luts::linear_to_srgb_u8();
    let (in_chunks, in_rem) = input.as_chunks::<16>();
    let (out_chunks, out_rem) = output.as_chunks_mut::<16>();
    for (inp, out) in in_chunks.iter().zip(out_chunks.iter_mut()) {
        let v = f32x16::from_array(token, *inp);
        let clamped = v.max(f32x16::zero(token)).min(f32x16::splat(token, 1.0));
        let idx_f = clamped.mul_add(f32x16::splat(token, 4095.0), f32x16::splat(token, 0.5));
        let idx_i = idx_f.to_i32().to_array();
        for px in 0..4 {
            let base = px * 4;
            out[base] = lut[(idx_i[base] as usize) & 0xFFF];
            out[base + 1] = lut[(idx_i[base + 1] as usize) & 0xFFF];
            out[base + 2] = lut[(idx_i[base + 2] as usize) & 0xFFF];
            out[base + 3] = (inp[base + 3].clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
        }
    }
    for (inp, out) in in_rem.chunks_exact(4).zip(out_rem.chunks_exact_mut(4)) {
        for i in 0..3 {
            let clamped = inp[i].clamp(0.0, 1.0);
            let idx = (clamped * 4095.0 + 0.5) as usize & 0xFFF;
            out[i] = lut[idx];
        }
        out[3] = (inp[3].clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
    }
}

/// Convert linear RGBA f32 to sRGB RGBA u8, preserving alpha.
///
/// RGB channels are LUT-encoded with SIMD-computed indices; alpha is scaled
/// linearly by 255 and rounded. Trailing elements that don't form a complete
/// RGBA pixel are ignored.
///
/// # Panics
/// Panics if `input.len() != output.len()`.
#[inline]
pub fn linear_to_srgb_u8_rgba_slice(input: &[f32], output: &mut [u8]) {
    assert_eq!(input.len(), output.len());
    incant!(
        linear_to_srgb_u8_rgba_slice_tier(input, output),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ============================================================================
// RGBA u8 Premultiply Batch Functions (LUT-based)
// ============================================================================

/// Convert sRGB RGBA u8 to linear premultiplied RGBA f32.
///
/// Fused operation: RGB channels are decoded via LUT to linear f32, then
/// multiplied by alpha. Alpha is passed through as `a / 255.0`.
///
/// Trailing elements that don't form a complete RGBA pixel are ignored.
///
/// # Panics
/// Panics if `input.len() != output.len()`.
///
/// # Example
/// ```
/// use linear_srgb::default::srgb_u8_to_linear_premultiply_rgba_slice;
///
/// let input = [128u8, 128, 128, 128, 255, 255, 255, 255];
/// let mut output = [0.0f32; 8];
/// srgb_u8_to_linear_premultiply_rgba_slice(&input, &mut output);
/// // RGB decoded then premultiplied by alpha (128/255 ≈ 0.502)
/// assert!(output[0] < 0.12); // srgb_to_linear(128/255) * 0.502 ≈ 0.107
/// assert!((output[3] - 128.0 / 255.0).abs() < 1e-6); // alpha passthrough
/// ```
pub fn srgb_u8_to_linear_premultiply_rgba_slice(input: &[u8], output: &mut [f32]) {
    assert_eq!(input.len(), output.len());

    // Process in x8 batches (2 RGBA pixels), premultiply after LUT
    let (in_chunks, in_remainder) = input.as_chunks::<8>();
    let (out_chunks, out_remainder) = output.as_chunks_mut::<8>();

    for (inp, out) in in_chunks.iter().zip(out_chunks.iter_mut()) {
        *out = crate::scalar::srgb_u8_to_linear_x8(*inp);
        let a0 = inp[3] as f32 / 255.0;
        let a1 = inp[7] as f32 / 255.0;
        out[0] *= a0;
        out[1] *= a0;
        out[2] *= a0;
        out[3] = a0;
        out[4] *= a1;
        out[5] *= a1;
        out[6] *= a1;
        out[7] = a1;
    }

    // Remainder: at most one RGBA pixel
    let in_rem_pixels = in_remainder.chunks_exact(4);
    let out_rem_pixels = out_remainder.chunks_exact_mut(4);
    for (inp, out) in in_rem_pixels.zip(out_rem_pixels) {
        let a = inp[3] as f32 / 255.0;
        out[0] = crate::scalar::srgb_u8_to_linear(inp[0]) * a;
        out[1] = crate::scalar::srgb_u8_to_linear(inp[1]) * a;
        out[2] = crate::scalar::srgb_u8_to_linear(inp[2]) * a;
        out[3] = a;
    }
}

// ---------- SIMD unpremultiply + SIMD LUT index for u8 RGBA output ----------
//
// Per-pixel strategy:
//   1. Scalar: extract alpha, compute inv_a = 1/a (or 0 if a <= threshold).
//      Below-threshold pixels get inv_a = 0, which makes RGB * inv_a = 0,
//      clamp stays 0, LUT index stays 0, and lut[0] == 0 (sRGB-encoded
//      black) — so the "transparent pixel → zero RGB" contract falls out
//      of the math with no per-pixel branch on the write side.
//   2. SIMD: build a per-lane multiplier vector — [inv_a, inv_a, inv_a,
//      1.0] per pixel — then multiply, clamp, FMA(4095, 0.5), cvttps2dq.
//      Scalar LUT loads following each chunk are independent.
//   3. Alpha lane (every 4th) is overwritten with a scalar
//      `(a * 255 + 0.5) as u8` direct cast; its SIMD LUT index is
//      discarded.

#[inline(always)]
fn inv_alpha_or_zero(a: f32) -> f32 {
    if a > crate::UNPREMUL_ALPHA_THRESHOLD {
        1.0 / a
    } else {
        0.0
    }
}

#[allow(clippy::needless_range_loop)]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn unpremultiply_linear_to_srgb_u8_rgba_slice_tier(token: Token, input: &[f32], output: &mut [u8]) {
    let lut = crate::const_luts::linear_to_srgb_u8();
    let (in_chunks, in_rem) = input.as_chunks::<16>();
    let (out_chunks, out_rem) = output.as_chunks_mut::<16>();
    for (inp, out) in in_chunks.iter().zip(out_chunks.iter_mut()) {
        let a = [inp[3], inp[7], inp[11], inp[15]];
        let inv_a = [
            inv_alpha_or_zero(a[0]),
            inv_alpha_or_zero(a[1]),
            inv_alpha_or_zero(a[2]),
            inv_alpha_or_zero(a[3]),
        ];
        let mul_arr = [
            inv_a[0], inv_a[0], inv_a[0], 1.0, inv_a[1], inv_a[1], inv_a[1], 1.0, inv_a[2],
            inv_a[2], inv_a[2], 1.0, inv_a[3], inv_a[3], inv_a[3], 1.0,
        ];
        let mul_vec = f32x16::from_array(token, mul_arr);
        let v = f32x16::from_array(token, *inp);
        let unpremul = v * mul_vec;
        let clamped = unpremul
            .max(f32x16::zero(token))
            .min(f32x16::splat(token, 1.0));
        let idx_f = clamped.mul_add(f32x16::splat(token, 4095.0), f32x16::splat(token, 0.5));
        let idx_i = idx_f.to_i32().to_array();
        for px in 0..4 {
            let base = px * 4;
            out[base] = lut[(idx_i[base] as usize) & 0xFFF];
            out[base + 1] = lut[(idx_i[base + 1] as usize) & 0xFFF];
            out[base + 2] = lut[(idx_i[base + 2] as usize) & 0xFFF];
            out[base + 3] = (a[px].clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
        }
    }
    for (inp, out) in in_rem.chunks_exact(4).zip(out_rem.chunks_exact_mut(4)) {
        let a = inp[3];
        let inv_a = inv_alpha_or_zero(a);
        for i in 0..3 {
            let clamped = (inp[i] * inv_a).clamp(0.0, 1.0);
            let idx = (clamped * 4095.0 + 0.5) as usize & 0xFFF;
            out[i] = lut[idx];
        }
        out[3] = (a.clamp(0.0, 1.0) * 255.0 + 0.5) as u8;
    }
}

/// Convert linear premultiplied RGBA f32 to sRGB straight-alpha RGBA u8.
///
/// Fused SIMD operation: each RGB channel is divided by alpha
/// (unpremultiplied), then encoded to sRGB u8 via LUT. Alpha is passed
/// through as `(a * 255 + 0.5) as u8`. When alpha is at or below
/// [`UNPREMUL_ALPHA_THRESHOLD`](crate::UNPREMUL_ALPHA_THRESHOLD), RGB
/// output bytes are set to zero — this falls out of the math naturally
/// (`inv_a = 0 → lut[0] = 0`) with no per-pixel branch on the write side.
///
/// Trailing elements that don't form a complete RGBA pixel are ignored.
///
/// # Panics
/// Panics if `input.len() != output.len()`.
///
/// # Example
/// ```
/// use linear_srgb::default::{srgb_u8_to_linear_premultiply_rgba_slice,
///     unpremultiply_linear_to_srgb_u8_rgba_slice};
///
/// let input = [128u8, 128, 128, 255, 0, 0, 0, 0];
/// let mut linear = [0.0f32; 8];
/// srgb_u8_to_linear_premultiply_rgba_slice(&input, &mut linear);
/// let mut output = [0u8; 8];
/// unpremultiply_linear_to_srgb_u8_rgba_slice(&linear, &mut output);
/// assert!((output[0] as i32 - 128).abs() <= 1); // roundtrips within 1
/// assert_eq!(output[7], 0); // transparent pixel
/// ```
#[inline]
pub fn unpremultiply_linear_to_srgb_u8_rgba_slice(input: &[f32], output: &mut [u8]) {
    assert_eq!(input.len(), output.len());
    incant!(
        unpremultiply_linear_to_srgb_u8_rgba_slice_tier(input, output),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ============================================================================
// RGBA u16 Batch Functions (LUT-based, alpha passthrough)
// ============================================================================

/// Convert sRGB RGBA u16 values to linear f32, preserving alpha.
///
/// RGB channels are decoded via lazily-initialized 65536-entry LUT. Alpha is passed
/// through as `a / 65535.0` without sRGB transfer. Trailing elements
/// that don't form a complete RGBA pixel are ignored.
///
/// # Panics
/// Panics if `input.len() != output.len()`.
pub fn srgb_u16_to_linear_rgba_slice(input: &[u16], output: &mut [f32]) {
    assert_eq!(input.len(), output.len());
    let in_pixels = input.chunks_exact(4);
    let out_pixels = output.chunks_exact_mut(4);
    for (inp, out) in in_pixels.zip(out_pixels) {
        out[0] = crate::scalar::srgb_u16_to_linear(inp[0]);
        out[1] = crate::scalar::srgb_u16_to_linear(inp[1]);
        out[2] = crate::scalar::srgb_u16_to_linear(inp[2]);
        out[3] = inp[3] as f32 / 65535.0;
    }
}

// ---------- SIMD polynomial + quantize for linear_to_srgb_u16_rgba_slice ----------
//
// Applies the polynomial to all lanes (including alpha positions — their
// polynomial result is discarded and replaced with a scalar
// `(alpha * 65535 + 0.5) as u16` direct cast). Same 25% lane-waste pattern
// as other memory-based RGBA paths.

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_srgb_u16_rgba_slice_tier(token: Token, input: &[f32], output: &mut [u16]) {
    use crate::rational_poly::{L2S_P, L2S_Q, LINEAR_THRESHOLD};

    let (in_chunks, in_rem) = input.as_chunks::<16>();
    let (out_chunks, out_rem) = output.as_chunks_mut::<16>();
    for (inp, out) in in_chunks.iter().zip(out_chunks.iter_mut()) {
        let linear = f32x16::from_array(token, *inp);
        let zero = f32x16::zero(token);
        let one = f32x16::splat(token, 1.0);
        let clamped = linear.max(zero).min(one);
        let linear_result = clamped * f32x16::splat(token, 12.92);
        let x = clamped.sqrt();
        let yp = f32x16::splat(token, L2S_P[4]).mul_add(x, f32x16::splat(token, L2S_P[3]));
        let yp = yp.mul_add(x, f32x16::splat(token, L2S_P[2]));
        let yp = yp.mul_add(x, f32x16::splat(token, L2S_P[1]));
        let yp = yp.mul_add(x, f32x16::splat(token, L2S_P[0]));
        let yq = f32x16::splat(token, L2S_Q[4]).mul_add(x, f32x16::splat(token, L2S_Q[3]));
        let yq = yq.mul_add(x, f32x16::splat(token, L2S_Q[2]));
        let yq = yq.mul_add(x, f32x16::splat(token, L2S_Q[1]));
        let yq = yq.mul_add(x, f32x16::splat(token, L2S_Q[0]));
        let power_result = (yp / yq).min(one);
        let thresh_mask = clamped.simd_lt(f32x16::splat(token, LINEAR_THRESHOLD));
        let srgb = f32x16::blend(thresh_mask, linear_result, power_result);
        let ge_one = linear.simd_ge(one);
        let srgb = f32x16::blend(ge_one, one, srgb);

        let scaled = srgb.mul_add(f32x16::splat(token, 65535.0), f32x16::splat(token, 0.5));
        let idx_i = scaled.to_i32().to_array();
        for px in 0..4 {
            let base = px * 4;
            out[base] = idx_i[base] as u16;
            out[base + 1] = idx_i[base + 1] as u16;
            out[base + 2] = idx_i[base + 2] as u16;
            out[base + 3] = (inp[base + 3].clamp(0.0, 1.0) * 65535.0 + 0.5) as u16;
        }
    }
    for (inp, out) in in_rem.chunks_exact(4).zip(out_rem.chunks_exact_mut(4)) {
        out[0] = crate::scalar::linear_to_srgb_u16(inp[0]);
        out[1] = crate::scalar::linear_to_srgb_u16(inp[1]);
        out[2] = crate::scalar::linear_to_srgb_u16(inp[2]);
        out[3] = (inp[3].clamp(0.0, 1.0) * 65535.0 + 0.5) as u16;
    }
}

/// Convert linear RGBA f32 to sRGB u16, preserving alpha. Polynomial encode
/// with SIMD dispatch (perfect roundtrip). For ~10× faster, use
/// [`linear_to_srgb_u16_rgba_slice_fast`].
///
/// # Panics
/// Panics if `input.len() != output.len()`.
#[inline]
pub fn linear_to_srgb_u16_rgba_slice(input: &[f32], output: &mut [u16]) {
    assert_eq!(input.len(), output.len());
    incant!(
        linear_to_srgb_u16_rgba_slice_tier(input, output),
        [v4, v3, neon, wasm128, scalar]
    )
}

/// Convert linear RGBA f32 to sRGB u16, preserving alpha. Sqrt-indexed LUT
/// encode (~10× faster, max ±1 roundtrip error).
///
/// # Panics
/// Panics if `input.len() != output.len()`.
// ---------- SIMD-indexed sqrt-LUT path for linear_to_srgb_u16_rgba_slice_fast ----------
//
// Like linear_to_srgb_u16_slice_fast, but computes indices for all lanes
// (including alpha positions — those indices are discarded and replaced
// with scalar `(alpha * 65535 + 0.5) as u16` direct casts). Alpha is
// bit-exact across tiers.

#[cfg(feature = "std")]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_srgb_u16_rgba_slice_fast_tier(token: Token, input: &[f32], output: &mut [u16]) {
    let lut = crate::u16_lut::encode_lut();
    let max_idx = crate::u16_lut::ENCODE_LUT_N - 1;
    let scale = crate::u16_lut::ENCODE_SQRT_SCALE;

    let (in_chunks, in_rem) = input.as_chunks::<16>();
    let (out_chunks, out_rem) = output.as_chunks_mut::<16>();
    for (inp, out) in in_chunks.iter().zip(out_chunks.iter_mut()) {
        let v = f32x16::from_array(token, *inp);
        let clamped = v.max(f32x16::zero(token)).min(f32x16::splat(token, 1.0));
        let idx_f = clamped
            .sqrt()
            .mul_add(f32x16::splat(token, scale), f32x16::splat(token, 0.5));
        let idx_i = idx_f.to_i32().to_array();
        for px in 0..4 {
            let base = px * 4;
            out[base] = lut[(idx_i[base] as usize).min(max_idx)];
            out[base + 1] = lut[(idx_i[base + 1] as usize).min(max_idx)];
            out[base + 2] = lut[(idx_i[base + 2] as usize).min(max_idx)];
            out[base + 3] = (inp[base + 3].clamp(0.0, 1.0) * 65535.0 + 0.5) as u16;
        }
    }
    for (inp, out) in in_rem.chunks_exact(4).zip(out_rem.chunks_exact_mut(4)) {
        out[0] = crate::scalar::linear_to_srgb_u16_fast(inp[0]);
        out[1] = crate::scalar::linear_to_srgb_u16_fast(inp[1]);
        out[2] = crate::scalar::linear_to_srgb_u16_fast(inp[2]);
        out[3] = (inp[3].clamp(0.0, 1.0) * 65535.0 + 0.5) as u16;
    }
}

/// Convert linear RGBA f32 to sRGB u16, preserving alpha. Sqrt-indexed LUT
/// encode with SIMD-computed indices (~10× faster than the polynomial
/// variant, max ±1 u16 roundtrip error).
///
/// # Panics
/// Panics if `input.len() != output.len()`.
#[inline]
pub fn linear_to_srgb_u16_rgba_slice_fast(input: &[f32], output: &mut [u16]) {
    assert_eq!(input.len(), output.len());
    #[cfg(feature = "std")]
    {
        incant!(
            linear_to_srgb_u16_rgba_slice_fast_tier(input, output),
            [v4, v3, neon, wasm128, scalar]
        )
    }
    #[cfg(not(feature = "std"))]
    {
        let in_pixels = input.chunks_exact(4);
        let out_pixels = output.chunks_exact_mut(4);
        for (inp, out) in in_pixels.zip(out_pixels) {
            out[0] = crate::scalar::linear_to_srgb_u16_fast(inp[0]);
            out[1] = crate::scalar::linear_to_srgb_u16_fast(inp[1]);
            out[2] = crate::scalar::linear_to_srgb_u16_fast(inp[2]);
            out[3] = (inp[3].clamp(0.0, 1.0) * 65535.0 + 0.5) as u16;
        }
    }
}

// ============================================================================
// Custom Gamma Slice Functions
// ============================================================================

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn gamma_to_linear_slice_tier(token: Token, values: &mut [f32], gamma: f32) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let v = f32x16::from_array(token, *chunk);
        let clamped = v.max(f32x16::zero(token)).min(f32x16::splat(token, 1.0));
        *chunk = clamped.pow_midp(gamma).to_array();
    }
    for v in remainder {
        *v = crate::scalar::gamma_to_linear(*v, gamma);
    }
}

/// Convert gamma-encoded f32 values to linear in-place using a custom gamma.
///
/// Uses AVX-512 (16-wide), AVX2+FMA (8-wide), NEON (4-wide), WASM SIMD128 (4-wide), or scalar depending on CPU.
///
/// # Example
/// ```
/// use linear_srgb::default::gamma_to_linear_slice;
///
/// let mut values = vec![0.0f32, 0.25, 0.5, 0.75, 1.0];
/// gamma_to_linear_slice(&mut values, 2.2);
/// ```
#[inline]
pub fn gamma_to_linear_slice(values: &mut [f32], gamma: f32) {
    incant!(
        gamma_to_linear_slice_tier(values, gamma),
        [v4, v3, neon, wasm128, scalar]
    )
}

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_gamma_slice_tier(token: Token, values: &mut [f32], gamma: f32) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let v = f32x16::from_array(token, *chunk);
        let clamped = v.max(f32x16::zero(token)).min(f32x16::splat(token, 1.0));
        *chunk = clamped.pow_midp(1.0 / gamma).to_array();
    }
    for v in remainder {
        *v = crate::scalar::linear_to_gamma(*v, gamma);
    }
}

/// Convert linear f32 values to gamma-encoded in-place using a custom gamma.
///
/// Uses AVX-512 (16-wide), AVX2+FMA (8-wide), NEON (4-wide), WASM SIMD128 (4-wide), or scalar depending on CPU.
///
/// # Example
/// ```
/// use linear_srgb::default::linear_to_gamma_slice;
///
/// let mut values = vec![0.0f32, 0.1, 0.2, 0.5, 1.0];
/// linear_to_gamma_slice(&mut values, 2.2);
/// ```
#[inline]
pub fn linear_to_gamma_slice(values: &mut [f32], gamma: f32) {
    incant!(
        linear_to_gamma_slice_tier(values, gamma),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ============================================================================
// Custom Gamma + Premultiply RGBA f32 (SIMD-fused single-pass)
// ============================================================================

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn gamma_to_linear_premultiply_rgba_slice_tier(token: Token, values: &mut [f32], gamma: f32) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let a = [chunk[3], chunk[7], chunk[11], chunk[15]];
        *chunk = incant!(mt_gamma_to_linear(*chunk, gamma));
        let v = f32x16::from_array(token, *chunk);
        let alpha = f32x16::from_array(
            token,
            [
                a[0], a[0], a[0], 1.0, a[1], a[1], a[1], 1.0, a[2], a[2], a[2], 1.0, a[3], a[3],
                a[3], 1.0,
            ],
        );
        *chunk = (v * alpha).to_array();
        [chunk[3], chunk[7], chunk[11], chunk[15]] = a;
    }
    for pixel in remainder.chunks_exact_mut(4) {
        let a = pixel[3];
        pixel[0] = crate::scalar::gamma_to_linear(pixel[0], gamma) * a;
        pixel[1] = crate::scalar::gamma_to_linear(pixel[1], gamma) * a;
        pixel[2] = crate::scalar::gamma_to_linear(pixel[2], gamma) * a;
    }
}

/// Convert gamma-encoded RGBA to linear premultiplied RGBA in-place.
///
/// Each RGB channel is decoded via `x.powf(gamma)`, then multiplied by the
/// alpha channel — in a single SIMD pass. Alpha is left unchanged.
///
/// Input: `[R_gamma, G_gamma, B_gamma, A, ...]` (straight alpha)
/// Output: `[R_linear*A, G_linear*A, B_linear*A, A, ...]` (premultiplied)
///
/// Trailing elements that don't form a complete RGBA pixel are ignored.
///
/// # Example
/// ```
/// #[allow(deprecated)]
/// # fn main() {
/// use linear_srgb::default::gamma_to_linear_premultiply_rgba_slice;
///
/// let mut rgba = vec![0.5f32, 0.5, 0.5, 0.5, 1.0, 1.0, 1.0, 1.0];
/// gamma_to_linear_premultiply_rgba_slice(&mut rgba, 2.2);
/// // gamma_to_linear(0.5, 2.2) ≈ 0.218, × 0.5 ≈ 0.109
/// assert!(rgba[0] < 0.12);
/// assert_eq!(rgba[3], 0.5); // alpha preserved
/// # }
/// ```
#[deprecated(
    since = "0.6.4",
    note = "use srgb_to_linear_premultiply_rgba_slice instead; gamma-based premultiply will be removed in a future release"
)]
#[inline]
pub fn gamma_to_linear_premultiply_rgba_slice(values: &mut [f32], gamma: f32) {
    incant!(
        gamma_to_linear_premultiply_rgba_slice_tier(values, gamma),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ============================================================================
// Unpremultiply + Linear→Gamma RGBA f32 (SIMD-fused single-pass)
// ============================================================================

#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn unpremultiply_linear_to_gamma_rgba_slice_tier(token: Token, values: &mut [f32], gamma: f32) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let a = [chunk[3], chunk[7], chunk[11], chunk[15]];
        let inv = [
            if a[0] > crate::UNPREMUL_ALPHA_THRESHOLD {
                1.0 / a[0]
            } else {
                0.0
            },
            if a[1] > crate::UNPREMUL_ALPHA_THRESHOLD {
                1.0 / a[1]
            } else {
                0.0
            },
            if a[2] > crate::UNPREMUL_ALPHA_THRESHOLD {
                1.0 / a[2]
            } else {
                0.0
            },
            if a[3] > crate::UNPREMUL_ALPHA_THRESHOLD {
                1.0 / a[3]
            } else {
                0.0
            },
        ];
        let v = f32x16::from_array(token, *chunk);
        let inv_alpha = f32x16::from_array(
            token,
            [
                inv[0], inv[0], inv[0], 1.0, inv[1], inv[1], inv[1], 1.0, inv[2], inv[2], inv[2],
                1.0, inv[3], inv[3], inv[3], 1.0,
            ],
        );
        let unpremul = (v * inv_alpha).to_array();
        *chunk = incant!(mt_linear_to_gamma(unpremul, gamma));
        [chunk[3], chunk[7], chunk[11], chunk[15]] = a;
    }
    for pixel in remainder.chunks_exact_mut(4) {
        let a = pixel[3];
        if a > crate::UNPREMUL_ALPHA_THRESHOLD {
            let inv_a = 1.0 / a;
            pixel[0] = crate::scalar::linear_to_gamma(pixel[0] * inv_a, gamma);
            pixel[1] = crate::scalar::linear_to_gamma(pixel[1] * inv_a, gamma);
            pixel[2] = crate::scalar::linear_to_gamma(pixel[2] * inv_a, gamma);
        } else {
            pixel[0] = 0.0;
            pixel[1] = 0.0;
            pixel[2] = 0.0;
        }
    }
}

/// Convert linear premultiplied RGBA to gamma-encoded straight-alpha RGBA in-place.
///
/// Each RGB channel is divided by alpha, then encoded via `x.powf(1.0 / gamma)`
/// — in a single SIMD pass. Alpha is left unchanged.
///
/// Input: `[R_linear*A, G_linear*A, B_linear*A, A, ...]` (premultiplied)
/// Output: `[R_gamma, G_gamma, B_gamma, A, ...]` (straight alpha)
///
/// When alpha is zero, the RGB channels are set to zero. Trailing elements
/// that don't form a complete RGBA pixel are ignored.
///
/// # Example
/// ```
/// #[allow(deprecated)]
/// # fn main() {
/// use linear_srgb::default::{gamma_to_linear_premultiply_rgba_slice,
///     unpremultiply_linear_to_gamma_rgba_slice};
///
/// let mut rgba = vec![0.5f32, 0.5, 0.5, 0.75, 0.0, 0.0, 0.0, 0.0];
/// gamma_to_linear_premultiply_rgba_slice(&mut rgba, 2.2);
/// unpremultiply_linear_to_gamma_rgba_slice(&mut rgba, 2.2);
/// assert!((rgba[0] - 0.5).abs() < 1e-3); // roundtrips
/// assert_eq!(rgba[3], 0.75);              // alpha preserved
/// assert_eq!(rgba[4], 0.0);               // transparent pixel stays zero
/// # }
/// ```
#[deprecated(
    since = "0.6.4",
    note = "use unpremultiply_linear_to_srgb_rgba_slice instead; gamma-based unpremultiply will be removed in a future release"
)]
#[inline]
pub fn unpremultiply_linear_to_gamma_rgba_slice(values: &mut [f32], gamma: f32) {
    incant!(
        unpremultiply_linear_to_gamma_rgba_slice_tier(values, gamma),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ============================================================================
// Transfer function slice dispatchers (BT.709, PQ, HLG)
// ============================================================================

// Each public dispatcher uses `#[magetypes]` to generate per-tier `#[arcane]`
// wrappers from a single generic body that drives `f32x16<Token>` (the
// magetypes generic alias auto-injected by `define(f32x16)`) over the
// underlying `crate::tf::*_x16` kernels. On V4 this lowers to native
// AVX-512; on V3 it polyfills to 2×f32x8; on NEON/WASM to 4×f32x4; scalar
// falls through to the per-element TF function.

#[cfg(feature = "transfer")]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn bt709_to_linear_slice_tier(token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let v = f32x16::from_array(token, *chunk);
        *chunk = crate::tf::bt709::bt709_to_linear_x16(token, v).to_array();
    }
    for v in remainder {
        *v = crate::tf::bt709_to_linear(*v);
    }
}

/// Convert BT.709 signal f32 values to linear in-place.
///
/// Applies the transfer function to **every element of the slice** — if you
/// pass RGBA data, alpha will be decoded too. Use
/// [`bt709_to_linear_rgba_slice`] for alpha-preserving RGBA conversion.
///
/// Uses AVX-512 (16-wide), AVX2+FMA (8-wide), NEON (4-wide), WASM SIMD128
/// (4-wide), or scalar depending on CPU.
#[cfg(feature = "transfer")]
#[inline]
pub fn bt709_to_linear_slice(values: &mut [f32]) {
    incant!(
        bt709_to_linear_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

#[cfg(feature = "transfer")]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_bt709_slice_tier(token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let v = f32x16::from_array(token, *chunk);
        *chunk = crate::tf::bt709::linear_to_bt709_x16(token, v).to_array();
    }
    for v in remainder {
        *v = crate::tf::linear_to_bt709(*v);
    }
}

/// Convert linear f32 values to BT.709 signal in-place.
///
/// Applies the transfer function to **every element of the slice** — if you
/// pass RGBA data, alpha will be encoded too. Use
/// [`linear_to_bt709_rgba_slice`] for alpha-preserving RGBA conversion.
///
/// Uses AVX-512 (16-wide), AVX2+FMA (8-wide), NEON (4-wide), WASM SIMD128
/// (4-wide), or scalar depending on CPU.
#[cfg(feature = "transfer")]
#[inline]
pub fn linear_to_bt709_slice(values: &mut [f32]) {
    incant!(
        linear_to_bt709_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

#[cfg(feature = "transfer")]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn pq_to_linear_slice_tier(token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let v = f32x16::from_array(token, *chunk);
        *chunk = crate::tf::pq::pq_to_linear_x16(token, v).to_array();
    }
    for v in remainder {
        *v = crate::tf::pq_to_linear(*v);
    }
}

/// Convert PQ (ST 2084) signal f32 values to linear in-place.
///
/// Applies the transfer function to **every element of the slice** — if you
/// pass RGBA data, alpha will be decoded too. Use [`pq_to_linear_rgba_slice`]
/// for alpha-preserving RGBA conversion.
///
/// Uses AVX-512 (16-wide), AVX2+FMA (8-wide), NEON (4-wide), WASM SIMD128
/// (4-wide), or scalar depending on CPU.
#[cfg(feature = "transfer")]
#[inline]
pub fn pq_to_linear_slice(values: &mut [f32]) {
    incant!(
        pq_to_linear_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

#[cfg(feature = "transfer")]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_pq_slice_tier(token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let v = f32x16::from_array(token, *chunk);
        *chunk = crate::tf::pq::linear_to_pq_x16(token, v).to_array();
    }
    for v in remainder {
        *v = crate::tf::linear_to_pq(*v);
    }
}

/// Convert linear f32 values to PQ (ST 2084) signal in-place.
///
/// Applies the transfer function to **every element of the slice** — if you
/// pass RGBA data, alpha will be encoded too. Use [`linear_to_pq_rgba_slice`]
/// for alpha-preserving RGBA conversion.
///
/// Uses AVX-512 (16-wide), AVX2+FMA (8-wide), NEON (4-wide), WASM SIMD128
/// (4-wide), or scalar depending on CPU.
#[cfg(feature = "transfer")]
#[inline]
pub fn linear_to_pq_slice(values: &mut [f32]) {
    incant!(
        linear_to_pq_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

#[cfg(feature = "transfer")]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn hlg_to_linear_slice_tier(token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let v = f32x16::from_array(token, *chunk);
        *chunk = crate::tf::hlg::hlg_to_linear_x16(token, v).to_array();
    }
    for v in remainder {
        *v = crate::tf::hlg_to_linear(*v);
    }
}

/// Convert HLG (ARIB STD-B67) signal f32 values to linear in-place.
///
/// Applies the transfer function to **every element of the slice** — if you
/// pass RGBA data, alpha will be decoded too. Use [`hlg_to_linear_rgba_slice`]
/// for alpha-preserving RGBA conversion.
///
/// Uses AVX-512 (16-wide), AVX2+FMA (8-wide), NEON (4-wide), WASM SIMD128
/// (4-wide), or scalar depending on CPU.
#[cfg(feature = "transfer")]
#[inline]
pub fn hlg_to_linear_slice(values: &mut [f32]) {
    incant!(
        hlg_to_linear_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

#[cfg(feature = "transfer")]
#[archmage::magetypes(define(f32x16), v4(cfg(avx512)), v3, neon, wasm128, scalar)]
fn linear_to_hlg_slice_tier(token: Token, values: &mut [f32]) {
    let (chunks, remainder) = values.as_chunks_mut::<16>();
    for chunk in chunks {
        let v = f32x16::from_array(token, *chunk);
        *chunk = crate::tf::hlg::linear_to_hlg_x16(token, v).to_array();
    }
    for v in remainder {
        *v = crate::tf::linear_to_hlg(*v);
    }
}

/// Convert linear f32 values to HLG (ARIB STD-B67) signal in-place.
///
/// Applies the transfer function to **every element of the slice** — if you
/// pass RGBA data, alpha will be encoded too. Use [`linear_to_hlg_rgba_slice`]
/// for alpha-preserving RGBA conversion.
///
/// Uses AVX-512 (16-wide), AVX2+FMA (8-wide), NEON (4-wide), WASM SIMD128
/// (4-wide), or scalar depending on CPU.
#[cfg(feature = "transfer")]
#[inline]
pub fn linear_to_hlg_slice(values: &mut [f32]) {
    incant!(
        linear_to_hlg_slice_tier(values),
        [v4, v3, neon, wasm128, scalar]
    )
}

// ============================================================================
// Transfer function RGBA slice dispatchers (BT.709, PQ, HLG — alpha-preserving)
// ============================================================================
//
// Each RGBA dispatcher applies the TF to all four lanes of every RGBA pixel,
// then restores the alpha channel from a per-chunk stash. The plain slice
// rites can't be reused because they're slice-shaped; we go through the
// per-N-lanes rites (`crate::tokens::x8::bt709_to_linear_v3` et al.) so
// alpha save/restore fits naturally around the SIMD step.

#[cfg(feature = "transfer")]
macro_rules! tf_rgba_slice_dispatcher {
    (
        pub = $pub_name:ident,
        tier_base = $tier_base:ident,
        tier_v4 = $tier_v4:ident,
        tier_v3 = $tier_v3:ident,
        tier_neon = $tier_neon:ident,
        tier_wasm128 = $tier_wasm128:ident,
        tier_scalar = $tier_scalar:ident,
        scalar = $scalar:path,
        x16_v4 = $x16_v4:path,
        x8_v3 = $x8_v3:path,
        x4_neon = $x4_neon:path,
        x4_wasm128 = $x4_wasm128:path,
        doc = $doc:expr,
    ) => {
        #[cfg(feature = "avx512")]
        #[arcane]
        fn $tier_v4(token: X64V4Token, values: &mut [f32]) {
            let (chunks, remainder) = values.as_chunks_mut::<16>();
            for chunk in chunks {
                let a = [chunk[3], chunk[7], chunk[11], chunk[15]];
                *chunk = $x16_v4(token, *chunk);
                [chunk[3], chunk[7], chunk[11], chunk[15]] = a;
            }
            for pixel in remainder.chunks_exact_mut(4) {
                pixel[0] = $scalar(pixel[0]);
                pixel[1] = $scalar(pixel[1]);
                pixel[2] = $scalar(pixel[2]);
            }
        }

        #[arcane]
        fn $tier_v3(token: X64V3Token, values: &mut [f32]) {
            let (chunks, remainder) = values.as_chunks_mut::<8>();
            for chunk in chunks {
                let a = [chunk[3], chunk[7]];
                *chunk = $x8_v3(token, *chunk);
                [chunk[3], chunk[7]] = a;
            }
            for pixel in remainder.chunks_exact_mut(4) {
                pixel[0] = $scalar(pixel[0]);
                pixel[1] = $scalar(pixel[1]);
                pixel[2] = $scalar(pixel[2]);
            }
        }

        #[arcane]
        fn $tier_neon(token: NeonToken, values: &mut [f32]) {
            let (chunks, _remainder) = values.as_chunks_mut::<4>();
            for chunk in chunks {
                let a = chunk[3];
                *chunk = $x4_neon(token, *chunk);
                chunk[3] = a;
            }
        }

        #[arcane]
        fn $tier_wasm128(token: Wasm128Token, values: &mut [f32]) {
            let (chunks, _remainder) = values.as_chunks_mut::<4>();
            for chunk in chunks {
                let a = chunk[3];
                *chunk = $x4_wasm128(token, *chunk);
                chunk[3] = a;
            }
        }

        fn $tier_scalar(_token: ScalarToken, values: &mut [f32]) {
            for pixel in values.chunks_exact_mut(4) {
                pixel[0] = $scalar(pixel[0]);
                pixel[1] = $scalar(pixel[1]);
                pixel[2] = $scalar(pixel[2]);
            }
        }

        #[doc = $doc]
        ///
        /// Expects interleaved RGBA data (`[R, G, B, A, R, G, B, A, ...]`).
        /// Every 4th element (alpha) is left unchanged. Trailing elements
        /// that don't form a complete RGBA pixel are ignored.
        #[inline]
        pub fn $pub_name(values: &mut [f32]) {
            incant!($tier_base(values), [v4, v3, neon, wasm128, scalar])
        }
    };
}

#[cfg(feature = "transfer")]
tf_rgba_slice_dispatcher! {
    pub = bt709_to_linear_rgba_slice,
    tier_base = bt709_to_linear_rgba_slice_tier,
    tier_v4 = bt709_to_linear_rgba_slice_tier_v4,
    tier_v3 = bt709_to_linear_rgba_slice_tier_v3,
    tier_neon = bt709_to_linear_rgba_slice_tier_neon,
    tier_wasm128 = bt709_to_linear_rgba_slice_tier_wasm128,
    tier_scalar = bt709_to_linear_rgba_slice_tier_scalar,
    scalar = crate::tf::bt709_to_linear,
    x16_v4 = crate::tokens::x16::bt709_to_linear_v4,
    x8_v3 = crate::tokens::x8::bt709_to_linear_v3,
    x4_neon = crate::tokens::x4::bt709_to_linear_neon,
    x4_wasm128 = crate::tokens::x4::bt709_to_linear_wasm128,
    doc = "Convert BT.709 signal RGBA f32 values to linear in-place, preserving alpha.",
}

#[cfg(feature = "transfer")]
tf_rgba_slice_dispatcher! {
    pub = linear_to_bt709_rgba_slice,
    tier_base = linear_to_bt709_rgba_slice_tier,
    tier_v4 = linear_to_bt709_rgba_slice_tier_v4,
    tier_v3 = linear_to_bt709_rgba_slice_tier_v3,
    tier_neon = linear_to_bt709_rgba_slice_tier_neon,
    tier_wasm128 = linear_to_bt709_rgba_slice_tier_wasm128,
    tier_scalar = linear_to_bt709_rgba_slice_tier_scalar,
    scalar = crate::tf::linear_to_bt709,
    x16_v4 = crate::tokens::x16::linear_to_bt709_v4,
    x8_v3 = crate::tokens::x8::linear_to_bt709_v3,
    x4_neon = crate::tokens::x4::linear_to_bt709_neon,
    x4_wasm128 = crate::tokens::x4::linear_to_bt709_wasm128,
    doc = "Convert linear RGBA f32 values to BT.709 signal in-place, preserving alpha.",
}

#[cfg(feature = "transfer")]
tf_rgba_slice_dispatcher! {
    pub = pq_to_linear_rgba_slice,
    tier_base = pq_to_linear_rgba_slice_tier,
    tier_v4 = pq_to_linear_rgba_slice_tier_v4,
    tier_v3 = pq_to_linear_rgba_slice_tier_v3,
    tier_neon = pq_to_linear_rgba_slice_tier_neon,
    tier_wasm128 = pq_to_linear_rgba_slice_tier_wasm128,
    tier_scalar = pq_to_linear_rgba_slice_tier_scalar,
    scalar = crate::tf::pq_to_linear,
    x16_v4 = crate::tokens::x16::pq_to_linear_v4,
    x8_v3 = crate::tokens::x8::pq_to_linear_v3,
    x4_neon = crate::tokens::x4::pq_to_linear_neon,
    x4_wasm128 = crate::tokens::x4::pq_to_linear_wasm128,
    doc = "Convert PQ (ST 2084) signal RGBA f32 values to linear in-place, preserving alpha.",
}

#[cfg(feature = "transfer")]
tf_rgba_slice_dispatcher! {
    pub = linear_to_pq_rgba_slice,
    tier_base = linear_to_pq_rgba_slice_tier,
    tier_v4 = linear_to_pq_rgba_slice_tier_v4,
    tier_v3 = linear_to_pq_rgba_slice_tier_v3,
    tier_neon = linear_to_pq_rgba_slice_tier_neon,
    tier_wasm128 = linear_to_pq_rgba_slice_tier_wasm128,
    tier_scalar = linear_to_pq_rgba_slice_tier_scalar,
    scalar = crate::tf::linear_to_pq,
    x16_v4 = crate::tokens::x16::linear_to_pq_v4,
    x8_v3 = crate::tokens::x8::linear_to_pq_v3,
    x4_neon = crate::tokens::x4::linear_to_pq_neon,
    x4_wasm128 = crate::tokens::x4::linear_to_pq_wasm128,
    doc = "Convert linear RGBA f32 values to PQ (ST 2084) signal in-place, preserving alpha.",
}

#[cfg(feature = "transfer")]
tf_rgba_slice_dispatcher! {
    pub = hlg_to_linear_rgba_slice,
    tier_base = hlg_to_linear_rgba_slice_tier,
    tier_v4 = hlg_to_linear_rgba_slice_tier_v4,
    tier_v3 = hlg_to_linear_rgba_slice_tier_v3,
    tier_neon = hlg_to_linear_rgba_slice_tier_neon,
    tier_wasm128 = hlg_to_linear_rgba_slice_tier_wasm128,
    tier_scalar = hlg_to_linear_rgba_slice_tier_scalar,
    scalar = crate::tf::hlg_to_linear,
    x16_v4 = crate::tokens::x16::hlg_to_linear_v4,
    x8_v3 = crate::tokens::x8::hlg_to_linear_v3,
    x4_neon = crate::tokens::x4::hlg_to_linear_neon,
    x4_wasm128 = crate::tokens::x4::hlg_to_linear_wasm128,
    doc = "Convert HLG (ARIB STD-B67) signal RGBA f32 values to linear in-place, preserving alpha.",
}

#[cfg(feature = "transfer")]
tf_rgba_slice_dispatcher! {
    pub = linear_to_hlg_rgba_slice,
    tier_base = linear_to_hlg_rgba_slice_tier,
    tier_v4 = linear_to_hlg_rgba_slice_tier_v4,
    tier_v3 = linear_to_hlg_rgba_slice_tier_v3,
    tier_neon = linear_to_hlg_rgba_slice_tier_neon,
    tier_wasm128 = linear_to_hlg_rgba_slice_tier_wasm128,
    tier_scalar = linear_to_hlg_rgba_slice_tier_scalar,
    scalar = crate::tf::linear_to_hlg,
    x16_v4 = crate::tokens::x16::linear_to_hlg_v4,
    x8_v3 = crate::tokens::x8::linear_to_hlg_v3,
    x4_neon = crate::tokens::x4::linear_to_hlg_neon,
    x4_wasm128 = crate::tokens::x4::linear_to_hlg_wasm128,
    doc = "Convert linear RGBA f32 values to HLG (ARIB STD-B67) signal in-place, preserving alpha.",
}

// ============================================================================
// Tests
// ============================================================================

#[cfg(test)]
#[allow(clippy::needless_range_loop)]
mod tests {
    use super::*;

    #[cfg(not(feature = "std"))]
    use alloc::{vec, vec::Vec};

    #[test]
    fn test_srgb_u8_to_linear_x8() {
        let input = [0u8, 64, 128, 192, 255, 32, 96, 160];
        let result = crate::scalar::srgb_u8_to_linear_x8(input);

        for (i, (&r, &inp)) in result.iter().zip(input.iter()).enumerate() {
            let expected = crate::scalar::srgb_to_linear(inp as f32 / 255.0);
            assert!(
                (r - expected).abs() < 1e-4,
                "srgb_u8_to_linear_x8 mismatch at {}: got {}, expected {}",
                i,
                r,
                expected
            );
        }
    }

    #[test]
    fn test_slice_roundtrip() {
        let mut values: Vec<f32> = (0..=10).map(|i| i as f32 / 10.0).collect();
        let original = values.clone();

        srgb_to_linear_slice(&mut values);
        linear_to_srgb_slice(&mut values);

        for (i, (orig, conv)) in original.iter().zip(values.iter()).enumerate() {
            assert!(
                (orig - conv).abs() < 1e-5,
                "Slice roundtrip failed at {}: {} -> {}",
                i,
                orig,
                conv
            );
        }
    }

    #[test]
    fn test_srgb_u8_to_linear_slice_basic() {
        let input: Vec<u8> = (0..=255).collect();
        let mut output = vec![0.0f32; 256];
        srgb_u8_to_linear_slice(&input, &mut output);

        for (i, &val) in output.iter().enumerate() {
            let expected = crate::scalar::srgb_to_linear(i as f32 / 255.0);
            assert!(
                (val - expected).abs() < 1e-4,
                "u8_to_linear mismatch at {}: got {}, expected {}",
                i,
                val,
                expected
            );
        }
    }

    #[test]
    fn test_linear_to_srgb_u8_slice_basic() {
        let input: Vec<f32> = (0..=255).map(|i| i as f32 / 255.0).collect();
        let mut output = vec![0u8; 256];
        let mut direct = vec![0.0f32; 256];

        // Convert input to linear first
        for (i, &srgb) in input.iter().enumerate() {
            direct[i] = crate::scalar::srgb_to_linear(srgb);
        }

        linear_to_srgb_u8_slice(&direct, &mut output);

        // Should roundtrip within 1 level
        for (i, &val) in output.iter().enumerate() {
            let diff = (val as i32 - i as i32).unsigned_abs();
            assert!(
                diff <= 1,
                "linear_to_srgb_u8 at {}: got {}, expected {}",
                i,
                val,
                i
            );
        }
    }

    #[test]
    fn test_gamma_slice_roundtrip() {
        let mut values: Vec<f32> = (1..=100).map(|i| i as f32 / 100.0).collect();
        let original = values.clone();

        gamma_to_linear_slice(&mut values, 2.2);
        linear_to_gamma_slice(&mut values, 2.2);

        for (i, (&orig, &conv)) in original.iter().zip(values.iter()).enumerate() {
            assert!(
                (orig - conv).abs() < 1e-3,
                "Gamma roundtrip failed at {}: {} -> {}",
                i,
                orig,
                conv
            );
        }
    }

    // Regression tests for GitHub issue #1:
    // slice functions convert ALL elements including alpha channels.
    // These tests document the current (incorrect) behavior so any fix
    // can be verified against them.

    #[test]
    fn issue_1_srgb_to_linear_slice_modifies_alpha() {
        // RGBA data: 4 pixels, alpha should stay unchanged
        let mut rgba = vec![
            0.5, 0.5, 0.5, 1.0, // pixel 0: mid-gray, full alpha
            0.2, 0.4, 0.8, 0.5, // pixel 1: color, half alpha
            0.0, 0.0, 0.0, 0.0, // pixel 2: transparent black
            1.0, 1.0, 1.0, 0.75, // pixel 3: white, 75% alpha
        ];
        let alphas_before: Vec<f32> = rgba.iter().skip(3).step_by(4).copied().collect();

        srgb_to_linear_slice(&mut rgba);

        let alphas_after: Vec<f32> = rgba.iter().skip(3).step_by(4).copied().collect();

        // Current behavior: alpha IS modified (this is the bug).
        // Alpha 0.0 and 1.0 are fixed points of srgb_to_linear, so they survive.
        // But 0.5 and 0.75 will be changed.
        assert_eq!(
            alphas_before[0], alphas_after[0],
            "alpha=1.0 is a fixed point"
        );
        assert_eq!(
            alphas_before[2], alphas_after[2],
            "alpha=0.0 is a fixed point"
        );
        // These SHOULD be equal but aren't — documenting the bug:
        assert_ne!(
            alphas_before[1], alphas_after[1],
            "BUG(#1): alpha=0.5 is incorrectly converted by srgb_to_linear_slice"
        );
        assert_ne!(
            alphas_before[3], alphas_after[3],
            "BUG(#1): alpha=0.75 is incorrectly converted by srgb_to_linear_slice"
        );
    }

    #[test]
    fn issue_1_linear_to_srgb_slice_modifies_alpha() {
        // Linear RGBA data
        let mut rgba = vec![
            0.2, 0.2, 0.2, 1.0, // pixel 0: full alpha
            0.1, 0.3, 0.5, 0.5, // pixel 1: half alpha
            0.0, 0.0, 0.0, 0.0, // pixel 2: transparent
            0.8, 0.8, 0.8, 0.25, // pixel 3: 25% alpha
        ];
        let alphas_before: Vec<f32> = rgba.iter().skip(3).step_by(4).copied().collect();

        linear_to_srgb_slice(&mut rgba);

        let alphas_after: Vec<f32> = rgba.iter().skip(3).step_by(4).copied().collect();

        // 0.0 is exact fixed point, 1.0 has minor rounding in rational poly
        assert_eq!(
            alphas_before[2], alphas_after[2],
            "alpha=0.0 is a fixed point"
        );
        // Non-trivial alpha values are definitely modified:
        assert_ne!(
            alphas_before[1], alphas_after[1],
            "BUG(#1): alpha=0.5 is incorrectly converted by linear_to_srgb_slice"
        );
        assert_ne!(
            alphas_before[3], alphas_after[3],
            "BUG(#1): alpha=0.25 is incorrectly converted by linear_to_srgb_slice"
        );
    }

    #[test]
    fn issue_1_srgb_u8_to_linear_converts_all_channels() {
        // RGBA u8 data: alpha bytes are at indices 3, 7, 11, 15
        let input: Vec<u8> = vec![
            128, 128, 128, 255, // pixel 0: mid-gray, full alpha
            64, 128, 192, 128, // pixel 1: color, half alpha
        ];
        let mut output = vec![0.0f32; 8];

        srgb_u8_to_linear_slice(&input, &mut output);

        // Alpha=255 maps to 1.0 (fixed point)
        assert_eq!(output[3], 1.0, "alpha=255/255 should map to 1.0");
        // Alpha=128 should stay 128/255 ≈ 0.502 but gets sRGB-decoded instead
        let alpha_128_linear = output[7];
        let expected_passthrough = 128.0 / 255.0;
        assert!(
            (alpha_128_linear - expected_passthrough).abs() > 0.01,
            "BUG(#1): alpha=128 is sRGB-decoded ({}) instead of passed through ({})",
            alpha_128_linear,
            expected_passthrough
        );
    }

    // ====================================================================
    // RGBA variant tests — alpha MUST be preserved
    // ====================================================================

    #[test]
    fn rgba_srgb_to_linear_f32_preserves_alpha() {
        let mut rgba = vec![
            0.5, 0.5, 0.5, 1.0, // full alpha
            0.2, 0.4, 0.8, 0.5, // half alpha
            0.0, 0.0, 0.0, 0.0, // transparent
            1.0, 1.0, 1.0, 0.75, // 75% alpha
        ];
        let alphas_before: Vec<f32> = rgba.iter().skip(3).step_by(4).copied().collect();
        srgb_to_linear_rgba_slice(&mut rgba);
        let alphas_after: Vec<f32> = rgba.iter().skip(3).step_by(4).copied().collect();
        assert_eq!(alphas_before, alphas_after, "all alphas must be preserved");
        // RGB channels should have changed (not fixed points except 0.0/1.0)
        assert_ne!(rgba[0], 0.5, "RGB should be converted");
    }

    #[test]
    fn rgba_linear_to_srgb_f32_preserves_alpha() {
        let mut rgba = vec![
            0.2, 0.2, 0.2, 1.0, 0.1, 0.3, 0.5, 0.5, 0.0, 0.0, 0.0, 0.0, 0.8, 0.8, 0.8, 0.25,
        ];
        let alphas_before: Vec<f32> = rgba.iter().skip(3).step_by(4).copied().collect();
        linear_to_srgb_rgba_slice(&mut rgba);
        let alphas_after: Vec<f32> = rgba.iter().skip(3).step_by(4).copied().collect();
        assert_eq!(alphas_before, alphas_after, "all alphas must be preserved");
    }

    #[test]
    fn rgba_srgb_u8_to_linear_preserves_alpha() {
        let input: Vec<u8> = vec![
            128, 128, 128, 255, // full alpha
            64, 128, 192, 128, // half alpha
            0, 0, 0, 0, // transparent
            255, 255, 255, 191, // 75% alpha
        ];
        let mut output = vec![0.0f32; 16];
        srgb_u8_to_linear_rgba_slice(&input, &mut output);

        // Alpha passthrough: a / 255.0
        assert_eq!(output[3], 1.0);
        assert!((output[7] - 128.0 / 255.0).abs() < 1e-6);
        assert_eq!(output[11], 0.0);
        assert!((output[15] - 191.0 / 255.0).abs() < 1e-6);

        // RGB should be sRGB-decoded (different from a/255 passthrough)
        // Pixel 1 G channel is 128 → sRGB decoded
        let srgb_decoded_128 = crate::scalar::srgb_u8_to_linear(128);
        assert_eq!(output[5], srgb_decoded_128, "RGB should use sRGB LUT");
        assert_ne!(output[7], srgb_decoded_128, "alpha should NOT use sRGB LUT");
    }

    #[test]
    fn rgba_linear_to_srgb_u8_preserves_alpha() {
        // Linear RGBA → sRGB u8
        let linear: Vec<f32> = vec![0.2158, 0.2158, 0.2158, 1.0, 0.0, 0.0, 0.0, 0.5];
        let mut output = vec![0u8; 8];
        linear_to_srgb_u8_rgba_slice(&linear, &mut output);

        // Alpha: (1.0 * 255 + 0.5) as u8 = 255
        assert_eq!(output[3], 255);
        // Alpha: (0.5 * 255 + 0.5) as u8 = 128
        assert_eq!(output[7], 128);
        // RGB ~128 for 0.2158 linear
        assert!((output[0] as i32 - 128).unsigned_abs() <= 1);
    }

    #[test]
    fn rgba_srgb_u16_to_linear_preserves_alpha() {
        let input: Vec<u16> = vec![
            32768, 32768, 32768, 65535, // full alpha
            16384, 32768, 49152, 32768, // half alpha
        ];
        let mut output = vec![0.0f32; 8];
        srgb_u16_to_linear_rgba_slice(&input, &mut output);

        assert_eq!(output[3], 1.0);
        assert!((output[7] - 32768.0 / 65535.0).abs() < 1e-6);
        // RGB should differ from linear passthrough
        assert_ne!(output[0], 32768.0 / 65535.0, "RGB must be sRGB-decoded");
    }

    #[test]
    fn rgba_linear_to_srgb_u16_preserves_alpha() {
        let linear: Vec<f32> = vec![0.5, 0.5, 0.5, 1.0, 0.0, 0.0, 0.0, 0.5];
        let mut output = vec![0u16; 8];
        linear_to_srgb_u16_rgba_slice(&linear, &mut output);

        assert_eq!(output[3], 65535);
        // alpha 0.5: (0.5 * 65535 + 0.5) as u16 = 32768
        assert_eq!(output[7], 32768);
    }

    #[test]
    fn rgba_f32_roundtrip_preserves_all() {
        let original = vec![
            0.5f32, 0.3, 0.8, 0.42, 0.1, 0.9, 0.0, 1.0, 1.0, 0.0, 0.5, 0.0,
        ];
        let mut rgba = original.clone();
        srgb_to_linear_rgba_slice(&mut rgba);
        linear_to_srgb_rgba_slice(&mut rgba);

        for (i, (&orig, &conv)) in original.iter().zip(rgba.iter()).enumerate() {
            if i % 4 == 3 {
                assert_eq!(orig, conv, "alpha at pixel {} must be exact", i / 4);
            } else {
                assert!(
                    (orig - conv).abs() < 1e-5,
                    "RGB roundtrip at {}: {} -> {}",
                    i,
                    orig,
                    conv
                );
            }
        }
    }

    // ====================================================================
    // SIMD boundary tests — exercise v4 (16-wide), v3 (8-wide), scalar
    // remainder paths with various pixel counts
    // ====================================================================

    fn make_rgba_srgb(num_pixels: usize) -> Vec<f32> {
        (0..num_pixels * 4)
            .map(|i| {
                if i % 4 == 3 {
                    0.3 + (i as f32 / 400.0) // varying alpha
                } else {
                    (i % 256) as f32 / 255.0
                }
            })
            .collect()
    }

    #[test]
    fn rgba_f32_s2l_various_pixel_counts() {
        // 1 pixel: pure remainder for both v3 and v4
        // 2 pixels: one v3 chunk, remainder for v4
        // 3 pixels: one v3 chunk + remainder, remainder for v4
        // 4 pixels: one v4 chunk, two v3 chunks
        // 5 pixels: one v4 chunk + remainder
        // 9 pixels: multiple v3 chunks + remainder
        // 17 pixels: one v4 chunk + v3 chunk + remainder
        for num_pixels in [1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17, 31, 32, 33] {
            let data = make_rgba_srgb(num_pixels);
            let alphas_before: Vec<f32> = data.iter().skip(3).step_by(4).copied().collect();
            let mut rgba = data.clone();
            srgb_to_linear_rgba_slice(&mut rgba);
            let alphas_after: Vec<f32> = rgba.iter().skip(3).step_by(4).copied().collect();
            assert_eq!(
                alphas_before, alphas_after,
                "alpha mismatch at {num_pixels} pixels"
            );
            // Verify RGB channels actually changed
            for px in 0..num_pixels {
                let srgb_r = data[px * 4];
                let linear_r = rgba[px * 4];
                if srgb_r > 0.04045 && srgb_r < 1.0 {
                    assert_ne!(
                        srgb_r, linear_r,
                        "RGB should change at pixel {px}/{num_pixels}"
                    );
                }
            }
        }
    }

    #[test]
    fn rgba_f32_l2s_various_pixel_counts() {
        for num_pixels in [1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17, 31, 32, 33] {
            let data = make_rgba_srgb(num_pixels);
            // Pretend data is linear (values in [0,1] are valid linear)
            let alphas_before: Vec<f32> = data.iter().skip(3).step_by(4).copied().collect();
            let mut rgba = data.clone();
            linear_to_srgb_rgba_slice(&mut rgba);
            let alphas_after: Vec<f32> = rgba.iter().skip(3).step_by(4).copied().collect();
            assert_eq!(
                alphas_before, alphas_after,
                "alpha mismatch at {num_pixels} pixels"
            );
        }
    }

    // ====================================================================
    // RGBA consistency — RGB channels must match non-RGBA output
    // ====================================================================

    #[test]
    fn rgba_rgb_channels_match_plain_s2l() {
        let srgb_values = make_rgba_srgb(20);

        // Plain slice: converts everything including alpha
        let mut plain = srgb_values.clone();
        srgb_to_linear_slice(&mut plain);

        // RGBA slice: preserves alpha
        let mut rgba = srgb_values.clone();
        srgb_to_linear_rgba_slice(&mut rgba);

        // RGB channels must be identical
        for px in 0..20 {
            for ch in 0..3 {
                let idx = px * 4 + ch;
                assert_eq!(
                    plain[idx], rgba[idx],
                    "RGB mismatch at pixel {px} channel {ch}"
                );
            }
        }
    }

    #[test]
    fn rgba_rgb_channels_match_plain_l2s() {
        let linear_values = make_rgba_srgb(20);

        let mut plain = linear_values.clone();
        linear_to_srgb_slice(&mut plain);

        let mut rgba = linear_values.clone();
        linear_to_srgb_rgba_slice(&mut rgba);

        for px in 0..20 {
            for ch in 0..3 {
                let idx = px * 4 + ch;
                assert_eq!(
                    plain[idx], rgba[idx],
                    "RGB mismatch at pixel {px} channel {ch}"
                );
            }
        }
    }

    // ====================================================================
    // Empty and edge-case inputs
    // ====================================================================

    #[test]
    fn rgba_f32_empty_slice() {
        let mut empty: Vec<f32> = vec![];
        srgb_to_linear_rgba_slice(&mut empty);
        linear_to_srgb_rgba_slice(&mut empty);
        assert!(empty.is_empty());
    }

    #[test]
    fn rgba_u8_empty_slice() {
        let input: Vec<u8> = vec![];
        let mut output: Vec<f32> = vec![];
        srgb_u8_to_linear_rgba_slice(&input, &mut output);
        assert!(output.is_empty());
    }

    #[test]
    fn rgba_f32_trailing_elements_ignored() {
        // 5 floats = 1 pixel + 1 trailing element
        let mut data = vec![0.5, 0.5, 0.5, 0.42, 0.99];
        let trailing_before = data[4];
        srgb_to_linear_rgba_slice(&mut data);
        // Alpha preserved
        assert_eq!(data[3], 0.42);
        // Trailing element unchanged (not part of a complete pixel)
        assert_eq!(data[4], trailing_before);
    }

    #[test]
    fn rgba_u8_trailing_elements_ignored() {
        // 6 u8s = 1 pixel + 2 trailing
        let input = vec![128u8, 128, 128, 200, 99, 99];
        let mut output = vec![0.0f32; 6];
        srgb_u8_to_linear_rgba_slice(&input, &mut output);
        // First pixel processed
        assert_eq!(output[3], 200.0 / 255.0);
        // Trailing elements untouched
        assert_eq!(output[4], 0.0);
        assert_eq!(output[5], 0.0);
    }

    // ====================================================================
    // u8 RGBA batch boundary (x8 batch + remainder)
    // ====================================================================

    #[test]
    fn rgba_u8_to_linear_batch_boundaries() {
        // Test pixel counts that exercise x8 batch (2 pixels) + remainder (1 pixel)
        for num_pixels in [1, 2, 3, 4, 5, 8, 9, 16, 17] {
            let input: Vec<u8> = (0..num_pixels * 4)
                .map(|i| {
                    if i % 4 == 3 {
                        ((i / 4) * 30 + 10) as u8 // varying alpha
                    } else {
                        128u8
                    }
                })
                .collect();
            let mut output = vec![0.0f32; num_pixels * 4];
            srgb_u8_to_linear_rgba_slice(&input, &mut output);

            for px in 0..num_pixels {
                let alpha_in = input[px * 4 + 3];
                let alpha_out = output[px * 4 + 3];
                let expected = alpha_in as f32 / 255.0;
                assert!(
                    (alpha_out - expected).abs() < 1e-6,
                    "alpha mismatch at pixel {px}/{num_pixels}: got {alpha_out}, expected {expected}"
                );
                // RGB should be sRGB-decoded 128
                let rgb_out = output[px * 4];
                let expected_rgb = crate::scalar::srgb_u8_to_linear(128);
                assert_eq!(rgb_out, expected_rgb, "RGB mismatch at pixel {px}");
            }
        }
    }

    // ====================================================================
    // u8/u16 RGBA roundtrips
    // ====================================================================

    #[test]
    fn rgba_u8_roundtrip() {
        // u8 sRGB → f32 linear → u8 sRGB, alpha must survive exactly
        let input: Vec<u8> = vec![
            0, 0, 0, 0, // black transparent
            128, 128, 128, 128, // mid-gray, half alpha
            255, 255, 255, 255, // white opaque
            64, 192, 32, 200, // colorful
        ];
        let mut linear = vec![0.0f32; 16];
        srgb_u8_to_linear_rgba_slice(&input, &mut linear);

        let mut output = vec![0u8; 16];
        linear_to_srgb_u8_rgba_slice(&linear, &mut output);

        for px in 0..4 {
            // Alpha must roundtrip exactly
            assert_eq!(
                input[px * 4 + 3],
                output[px * 4 + 3],
                "alpha roundtrip failed at pixel {px}"
            );
            // RGB within 1 level
            for ch in 0..3 {
                let diff = (input[px * 4 + ch] as i32 - output[px * 4 + ch] as i32).unsigned_abs();
                assert!(
                    diff <= 1,
                    "RGB roundtrip at pixel {px} ch {ch}: {} -> {}",
                    input[px * 4 + ch],
                    output[px * 4 + ch]
                );
            }
        }
    }

    #[test]
    fn rgba_u16_roundtrip() {
        let input: Vec<u16> = vec![
            0, 0, 0, 0, 32768, 32768, 32768, 32768, 65535, 65535, 65535, 65535, 16384, 49152, 8192,
            40000,
        ];
        let mut linear = vec![0.0f32; 16];
        srgb_u16_to_linear_rgba_slice(&input, &mut linear);

        let mut output = vec![0u16; 16];
        linear_to_srgb_u16_rgba_slice(&linear, &mut output);

        for px in 0..4 {
            assert_eq!(
                input[px * 4 + 3],
                output[px * 4 + 3],
                "alpha must roundtrip exactly at pixel {px}"
            );
        }
    }

    // ====================================================================
    // Non-RGBA u16 slice roundtrip (was missing)
    // ====================================================================

    #[test]
    fn test_u16_slice_roundtrip() {
        // Full range u16 roundtrip: sRGB u16 → linear f32 → sRGB u16
        // The decode LUT has 65536 entries, encode LUT has 65537. Both pass through
        // f32 which has ~24 bits mantissa — at low sRGB values the linear values
        // are tiny and LUT index quantization causes up to ~10 levels of error.
        let input: Vec<u16> = (0..=255).map(|i| (i * 257) as u16).collect();
        let mut linear = vec![0.0f32; 256];
        srgb_u16_to_linear_slice(&input, &mut linear);

        let mut output = vec![0u16; 256];
        linear_to_srgb_u16_slice(&linear, &mut output);

        let mut max_diff = 0u32;
        for (i, (&inp, &out)) in input.iter().zip(output.iter()).enumerate() {
            let diff = (inp as i32 - out as i32).unsigned_abs();
            max_diff = max_diff.max(diff);
            assert!(
                diff <= 10,
                "u16 roundtrip at {i}: {inp} -> {out} (diff {diff})"
            );
        }
        // Verify high values roundtrip well (most error is at low sRGB values)
        assert_eq!(output[255], 65535, "u16 max must roundtrip exactly");
    }

    // ====================================================================
    // Threshold boundary — values near the sRGB linear/curve threshold
    // ====================================================================

    #[test]
    fn rgba_f32_near_threshold() {
        // sRGB threshold: 0.04045 (sRGB→linear), 0.0031308 (linear→sRGB)
        let mut rgba = vec![
            0.04044, 0.04045, 0.04046, 0.77, // pixel 0: straddles s2l threshold
            0.003130, 0.0031308, 0.003132, 0.33, // pixel 1: straddles l2s threshold
        ];
        let alphas_before = [rgba[3], rgba[7]];

        srgb_to_linear_rgba_slice(&mut rgba);
        assert_eq!(rgba[3], alphas_before[0]);
        assert_eq!(rgba[7], alphas_before[1]);

        // Values should be monotonic across threshold
        assert!(rgba[0] < rgba[1], "s2l should be monotonic");
        assert!(rgba[1] < rgba[2], "s2l should be monotonic");

        linear_to_srgb_rgba_slice(&mut rgba);
        assert_eq!(rgba[3], alphas_before[0]);
        assert_eq!(rgba[7], alphas_before[1]);
    }

    // ====================================================================
    // Boundary values — 0.0 and 1.0 exact
    // ====================================================================

    #[test]
    fn rgba_f32_boundary_values() {
        let mut rgba = vec![
            0.0, 0.0, 0.0, 0.0, // all zero
            1.0, 1.0, 1.0, 1.0, // all one
        ];
        srgb_to_linear_rgba_slice(&mut rgba);
        assert_eq!(rgba[0], 0.0, "srgb_to_linear(0.0) must be 0.0");
        assert_eq!(rgba[3], 0.0, "alpha 0.0 preserved");
        // 1.0 may have tiny rounding in rational poly, but alpha must be exact
        assert_eq!(rgba[7], 1.0, "alpha 1.0 preserved");

        let mut rgba2 = vec![0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0];
        linear_to_srgb_rgba_slice(&mut rgba2);
        assert_eq!(rgba2[0], 0.0, "linear_to_srgb(0.0) must be 0.0");
        assert_eq!(rgba2[3], 0.0, "alpha 0.0 preserved");
        assert_eq!(rgba2[7], 1.0, "alpha 1.0 preserved");
    }

    #[test]
    fn rgba_u8_boundary_values() {
        let input = vec![0u8, 0, 0, 0, 255, 255, 255, 255];
        let mut output = vec![0.0f32; 8];
        srgb_u8_to_linear_rgba_slice(&input, &mut output);
        assert_eq!(output[0], 0.0);
        assert_eq!(output[3], 0.0); // alpha
        assert_eq!(output[4], 1.0); // sRGB 255 → linear 1.0
        assert_eq!(output[7], 1.0); // alpha 255 → 1.0

        let linear_input = vec![0.0f32, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0];
        let mut u8_output = vec![0u8; 8];
        linear_to_srgb_u8_rgba_slice(&linear_input, &mut u8_output);
        assert_eq!(u8_output[0], 0);
        assert_eq!(u8_output[3], 0); // alpha
        assert_eq!(u8_output[4], 255);
        assert_eq!(u8_output[7], 255); // alpha
    }

    // ====================================================================
    // u8/u16 RGBA consistency with scalar per-channel
    // ====================================================================

    #[test]
    fn rgba_u8_rgb_matches_non_rgba() {
        let input: Vec<u8> = (0..40).map(|i| (i * 6 + 10) as u8).collect(); // 10 RGBA pixels
        let mut rgba_out = vec![0.0f32; 40];
        let mut plain_out = vec![0.0f32; 40];

        srgb_u8_to_linear_rgba_slice(&input, &mut rgba_out);
        srgb_u8_to_linear_slice(&input, &mut plain_out);

        // RGB channels must match
        for px in 0..10 {
            for ch in 0..3 {
                let idx = px * 4 + ch;
                assert_eq!(
                    rgba_out[idx], plain_out[idx],
                    "u8 RGB mismatch at pixel {px} ch {ch}"
                );
            }
            // Alpha should differ: RGBA does passthrough, plain does sRGB decode
            let alpha_val = input[px * 4 + 3];
            if alpha_val > 10 && alpha_val < 245 {
                // Not near fixed points
                assert_ne!(
                    rgba_out[px * 4 + 3],
                    plain_out[px * 4 + 3],
                    "alpha should differ between RGBA and plain at pixel {px}"
                );
            }
        }
    }

    // ====================================================================
    // Premultiply/Unpremultiply tests
    // ====================================================================

    #[test]
    fn premultiply_f32_basic() {
        let mut rgba = vec![
            0.5, 0.5, 0.5, 1.0, // full alpha — premul should match non-premul
            0.5, 0.5, 0.5, 0.5, // half alpha — RGB halved after conversion
            0.5, 0.5, 0.5, 0.0, // zero alpha — RGB should be zero
        ];
        srgb_to_linear_premultiply_rgba_slice(&mut rgba);

        // Full alpha: premul = linear
        let expected_full = crate::scalar::srgb_to_linear(0.5);
        assert!(
            (rgba[0] - expected_full).abs() < 1e-5,
            "full alpha: {} vs {}",
            rgba[0],
            expected_full
        );
        assert_eq!(rgba[3], 1.0, "alpha preserved");

        // Half alpha: premul = linear * 0.5
        let expected_half = crate::scalar::srgb_to_linear(0.5) * 0.5;
        assert!(
            (rgba[4] - expected_half).abs() < 1e-5,
            "half alpha: {} vs {}",
            rgba[4],
            expected_half
        );
        assert_eq!(rgba[7], 0.5, "alpha preserved");

        // Zero alpha: RGB = 0
        assert_eq!(rgba[8], 0.0, "zero alpha: R=0");
        assert_eq!(rgba[9], 0.0, "zero alpha: G=0");
        assert_eq!(rgba[10], 0.0, "zero alpha: B=0");
        assert_eq!(rgba[11], 0.0, "alpha preserved");
    }

    #[test]
    fn premultiply_f32_roundtrip() {
        // sRGB → linear premul → unpremul sRGB should roundtrip
        let original = vec![
            0.5f32, 0.3, 0.8, 0.75, // typical pixel
            0.1, 0.9, 0.5, 1.0, // full alpha
            1.0, 0.0, 0.5, 0.25, // quarter alpha
        ];
        let mut rgba = original.clone();
        srgb_to_linear_premultiply_rgba_slice(&mut rgba);
        unpremultiply_linear_to_srgb_rgba_slice(&mut rgba);

        for (i, (&orig, &conv)) in original.iter().zip(rgba.iter()).enumerate() {
            if i % 4 == 3 {
                assert_eq!(orig, conv, "alpha must be exact at index {i}");
            } else {
                assert!(
                    (orig - conv).abs() < 1e-4,
                    "RGB roundtrip at {i}: {} -> {} (diff {})",
                    orig,
                    conv,
                    (orig - conv).abs()
                );
            }
        }
    }

    #[test]
    fn premultiply_f32_zero_alpha_roundtrip() {
        // Zero-alpha pixel: should produce zero RGB, and roundtrip to zero
        let mut rgba = vec![0.5, 0.8, 0.3, 0.0];
        srgb_to_linear_premultiply_rgba_slice(&mut rgba);
        assert_eq!(rgba, [0.0, 0.0, 0.0, 0.0], "premul with a=0 → all zero");

        unpremultiply_linear_to_srgb_rgba_slice(&mut rgba);
        assert_eq!(rgba, [0.0, 0.0, 0.0, 0.0], "unpremul a=0 → stays zero");
    }

    #[test]
    fn premultiply_f32_various_pixel_counts() {
        // Exercise SIMD boundaries: v4 (16-wide/4px), v3 (8-wide/2px), scalar
        for num_pixels in [1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17, 31, 32, 33] {
            let data = make_rgba_srgb(num_pixels);
            let alphas: Vec<f32> = data.iter().skip(3).step_by(4).copied().collect();

            let mut rgba = data.clone();
            srgb_to_linear_premultiply_rgba_slice(&mut rgba);

            // Alpha must be preserved exactly
            let alphas_after: Vec<f32> = rgba.iter().skip(3).step_by(4).copied().collect();
            assert_eq!(
                alphas, alphas_after,
                "alpha mismatch at {num_pixels} pixels"
            );

            // RGB should be premultiplied: rgb_premul = srgb_to_linear(rgb) * alpha
            for px in 0..num_pixels {
                let a = alphas[px];
                for ch in 0..3 {
                    let idx = px * 4 + ch;
                    let expected = crate::scalar::srgb_to_linear(data[idx]) * a;
                    assert!(
                        (rgba[idx] - expected).abs() < 1e-5,
                        "premul mismatch at pixel {px} ch {ch} (npx={num_pixels}): {} vs {}",
                        rgba[idx],
                        expected
                    );
                }
            }

            // Roundtrip
            unpremultiply_linear_to_srgb_rgba_slice(&mut rgba);
            for px in 0..num_pixels {
                let a = alphas[px];
                if a > 0.0 {
                    for ch in 0..3 {
                        let idx = px * 4 + ch;
                        assert!(
                            (rgba[idx] - data[idx]).abs() < 1e-4,
                            "roundtrip at px {px} ch {ch} (npx={num_pixels}): {} vs {}",
                            rgba[idx],
                            data[idx]
                        );
                    }
                }
            }
        }
    }

    #[test]
    fn premultiply_rgb_matches_non_premul_at_alpha_1() {
        // With alpha=1.0, premultiplied output should match non-premultiplied
        let mut premul_data: Vec<f32> = (0..80)
            .map(|i| {
                if i % 4 == 3 {
                    1.0 // all opaque
                } else {
                    (i % 256) as f32 / 255.0
                }
            })
            .collect();
        let mut plain_data = premul_data.clone();

        srgb_to_linear_premultiply_rgba_slice(&mut premul_data);
        srgb_to_linear_rgba_slice(&mut plain_data);

        for (i, (&p, &n)) in premul_data.iter().zip(plain_data.iter()).enumerate() {
            assert!(
                (p - n).abs() < 1e-6,
                "alpha=1 mismatch at {i}: premul={p} vs plain={n}"
            );
        }
    }

    #[test]
    fn premultiply_u8_basic() {
        let input = vec![
            128u8, 128, 128, 255, // full alpha
            128, 128, 128, 128, // half alpha
            128, 128, 128, 0, // zero alpha
        ];
        let mut output = vec![0.0f32; 12];
        srgb_u8_to_linear_premultiply_rgba_slice(&input, &mut output);

        // Full alpha: same as non-premul
        let expected_128 = crate::scalar::srgb_u8_to_linear(128);
        assert!(
            (output[0] - expected_128).abs() < 1e-5,
            "full alpha u8: {} vs {}",
            output[0],
            expected_128
        );
        assert_eq!(output[3], 1.0);

        // Half alpha: premul = linear * (128/255)
        let a_half = 128.0 / 255.0;
        let expected_half = expected_128 * a_half;
        assert!(
            (output[4] - expected_half).abs() < 1e-5,
            "half alpha u8: {} vs {}",
            output[4],
            expected_half
        );
        assert!((output[7] - a_half).abs() < 1e-6);

        // Zero alpha
        assert_eq!(output[8], 0.0);
        assert_eq!(output[9], 0.0);
        assert_eq!(output[10], 0.0);
        assert_eq!(output[11], 0.0);
    }

    #[test]
    fn premultiply_u8_roundtrip() {
        let input: Vec<u8> = vec![
            0, 0, 0, 0, // transparent
            128, 128, 128, 128, // half alpha
            255, 255, 255, 255, // opaque white
            64, 192, 32, 200, // colorful
        ];
        let mut linear = vec![0.0f32; 16];
        srgb_u8_to_linear_premultiply_rgba_slice(&input, &mut linear);

        let mut output = vec![0u8; 16];
        unpremultiply_linear_to_srgb_u8_rgba_slice(&linear, &mut output);

        for px in 0..4 {
            // Alpha must roundtrip exactly
            assert_eq!(
                input[px * 4 + 3],
                output[px * 4 + 3],
                "alpha roundtrip at pixel {px}"
            );
            // RGB within 1 level (except transparent pixel)
            if input[px * 4 + 3] > 0 {
                for ch in 0..3 {
                    let diff =
                        (input[px * 4 + ch] as i32 - output[px * 4 + ch] as i32).unsigned_abs();
                    assert!(
                        diff <= 1,
                        "u8 premul roundtrip at px {px} ch {ch}: {} -> {}",
                        input[px * 4 + ch],
                        output[px * 4 + ch]
                    );
                }
            }
        }
    }

    #[test]
    fn premultiply_f32_empty() {
        let mut empty: Vec<f32> = vec![];
        srgb_to_linear_premultiply_rgba_slice(&mut empty);
        unpremultiply_linear_to_srgb_rgba_slice(&mut empty);
    }

    #[test]
    fn premultiply_u8_empty() {
        let input: Vec<u8> = vec![];
        let mut output: Vec<f32> = vec![];
        srgb_u8_to_linear_premultiply_rgba_slice(&input, &mut output);
    }

    #[test]
    fn premultiply_f32_boundary_values() {
        let mut rgba = vec![
            0.0, 0.0, 0.0, 0.0, // all zero
            1.0, 1.0, 1.0, 1.0, // all one
            1.0, 1.0, 1.0, 0.0, // white transparent
        ];
        srgb_to_linear_premultiply_rgba_slice(&mut rgba);

        // All zero stays zero
        assert_eq!(&rgba[0..4], &[0.0, 0.0, 0.0, 0.0]);
        // All one: srgb_to_linear(1.0) * 1.0 = 1.0
        assert_eq!(rgba[4], 1.0);
        assert_eq!(rgba[7], 1.0);
        // White transparent: RGB * 0 = 0
        assert_eq!(&rgba[8..12], &[0.0, 0.0, 0.0, 0.0]);
    }

    #[test]
    fn premultiply_u8_batch_boundaries() {
        // Test various pixel counts to exercise x8 batch + remainder
        for num_pixels in [1, 2, 3, 4, 5, 8, 9, 16, 17] {
            let input: Vec<u8> = (0..num_pixels * 4)
                .map(|i| {
                    if i % 4 == 3 {
                        ((i / 4) * 30 + 10) as u8
                    } else {
                        128u8
                    }
                })
                .collect();
            let mut output = vec![0.0f32; num_pixels * 4];
            srgb_u8_to_linear_premultiply_rgba_slice(&input, &mut output);

            let expected_rgb = crate::scalar::srgb_u8_to_linear(128);
            for px in 0..num_pixels {
                let a = input[px * 4 + 3] as f32 / 255.0;
                let expected_premul = expected_rgb * a;
                assert!(
                    (output[px * 4] - expected_premul).abs() < 1e-5,
                    "u8 premul batch at px {px}/{num_pixels}: {} vs {}",
                    output[px * 4],
                    expected_premul
                );
                assert!(
                    (output[px * 4 + 3] - a).abs() < 1e-6,
                    "u8 premul alpha at px {px}/{num_pixels}"
                );
            }
        }
    }

    #[test]
    #[allow(deprecated)]
    fn gamma_premultiply_roundtrip() {
        // Exercise SIMD tiers with various pixel counts (1..=17 covers
        // scalar remainder, V3 8-wide, and V4 16-wide paths)
        for num_pixels in 1..=17 {
            let mut rgba: Vec<f32> = (0..num_pixels)
                .flat_map(|i| {
                    let v = i as f32 / num_pixels as f32;
                    [v, v * 0.5, v * 0.8, 0.75]
                })
                .collect();
            let original = rgba.clone();

            gamma_to_linear_premultiply_rgba_slice(&mut rgba, 2.2);
            unpremultiply_linear_to_gamma_rgba_slice(&mut rgba, 2.2);

            for (i, (&orig, &conv)) in original.iter().zip(rgba.iter()).enumerate() {
                if i % 4 == 3 {
                    assert_eq!(orig, conv, "alpha changed at {i}/{num_pixels}");
                } else {
                    assert!(
                        (orig - conv).abs() < 2e-3,
                        "gamma premul roundtrip at {i}/{num_pixels}: {orig} -> {conv}"
                    );
                }
            }
        }
    }

    #[test]
    #[allow(deprecated)]
    fn gamma_premultiply_zero_alpha() {
        let mut rgba = vec![0.5f32, 0.5, 0.5, 0.0, 0.8, 0.8, 0.8, 1.0];
        gamma_to_linear_premultiply_rgba_slice(&mut rgba, 2.2);
        // Zero alpha: RGB should be 0
        assert_eq!(rgba[0], 0.0);
        assert_eq!(rgba[1], 0.0);
        assert_eq!(rgba[2], 0.0);
        assert_eq!(rgba[3], 0.0);
        // Full alpha: gamma_to_linear(0.8, 2.2)
        assert!(rgba[4] > 0.0);
        assert_eq!(rgba[7], 1.0);

        unpremultiply_linear_to_gamma_rgba_slice(&mut rgba, 2.2);
        assert_eq!(rgba[0], 0.0);
        assert_eq!(rgba[3], 0.0);
        assert!((rgba[4] - 0.8).abs() < 2e-3);
    }

    #[test]
    fn gamma_rgba_slice_basic() {
        // Separate from premultiply — test plain gamma slice with RGBA-like data
        let mut values: Vec<f32> = (0..100).map(|i| i as f32 / 99.0).collect();
        let original = values.clone();

        gamma_to_linear_slice(&mut values, 1.8);
        linear_to_gamma_slice(&mut values, 1.8);

        for (i, (&orig, &conv)) in original.iter().zip(values.iter()).enumerate() {
            assert!(
                (orig - conv).abs() < 1e-3,
                "gamma 1.8 roundtrip at {i}: {orig} -> {conv}"
            );
        }
    }

    // ====================================================================
    // Systematic length tests — exercise SIMD boundaries (scalar remainder,
    // 8-wide AVX2, 16-wide AVX-512) for ALL public slice functions.
    // ====================================================================

    /// Element counts that probe SIMD boundaries:
    /// 1, 7 (pure scalar), 8 (one AVX2 chunk), 9 (AVX2 + 1 remainder),
    /// 15, 16 (one AVX-512 chunk), 17, 31, 32, 33, 100.
    const TEST_LENGTHS: &[usize] = &[1, 3, 7, 8, 9, 15, 16, 17, 31, 32, 33, 100];

    fn make_srgb_values(n: usize) -> Vec<f32> {
        (0..n).map(|i| (i % 256) as f32 / 255.0).collect()
    }

    fn make_linear_values(n: usize) -> Vec<f32> {
        (0..n).map(|i| (i % 256) as f32 / 255.0).collect()
    }

    fn make_u8_values(n: usize) -> Vec<u8> {
        (0..n).map(|i| (i % 256) as u8).collect()
    }

    fn make_u16_values(n: usize) -> Vec<u16> {
        (0..n).map(|i| ((i % 256) * 257) as u16).collect()
    }

    #[test]
    fn length_srgb_to_linear_slice() {
        for &n in TEST_LENGTHS {
            let mut values = make_srgb_values(n);
            let original = values.clone();
            srgb_to_linear_slice(&mut values);
            for (i, (&s, &l)) in original.iter().zip(values.iter()).enumerate() {
                let expected = crate::scalar::srgb_to_linear(s);
                assert!(
                    (l - expected).abs() < 1e-5,
                    "s2l_slice n={n} i={i}: {l} vs {expected}"
                );
            }
        }
    }

    #[test]
    fn length_linear_to_srgb_slice() {
        for &n in TEST_LENGTHS {
            let mut values = make_linear_values(n);
            let original = values.clone();
            linear_to_srgb_slice(&mut values);
            for (i, (&l, &s)) in original.iter().zip(values.iter()).enumerate() {
                let expected = crate::scalar::linear_to_srgb(l);
                assert!(
                    (s - expected).abs() < 1e-5,
                    "l2s_slice n={n} i={i}: {s} vs {expected}"
                );
            }
        }
    }

    #[test]
    fn length_srgb_u8_to_linear_slice() {
        for &n in TEST_LENGTHS {
            let input = make_u8_values(n);
            let mut output = vec![0.0f32; n];
            srgb_u8_to_linear_slice(&input, &mut output);
            for (i, (&u, &l)) in input.iter().zip(output.iter()).enumerate() {
                let expected = crate::scalar::srgb_u8_to_linear(u);
                assert!(
                    (l - expected).abs() < 1e-5,
                    "u8_s2l n={n} i={i}: {l} vs {expected}"
                );
            }
        }
    }

    #[test]
    fn length_linear_to_srgb_u8_slice() {
        for &n in TEST_LENGTHS {
            let input = make_linear_values(n);
            let mut output = vec![0u8; n];
            linear_to_srgb_u8_slice(&input, &mut output);
            for (i, (&l, &u)) in input.iter().zip(output.iter()).enumerate() {
                let expected = crate::scalar::linear_to_srgb_u8(l);
                let diff = (u as i32 - expected as i32).unsigned_abs();
                assert!(diff <= 1, "l2s_u8 n={n} i={i}: {u} vs {expected}");
            }
        }
    }

    #[test]
    fn length_srgb_u16_to_linear_slice() {
        for &n in TEST_LENGTHS {
            let input = make_u16_values(n);
            let mut output = vec![0.0f32; n];
            srgb_u16_to_linear_slice(&input, &mut output);
            for (i, (&u, &l)) in input.iter().zip(output.iter()).enumerate() {
                let expected = crate::scalar::srgb_u16_to_linear(u);
                assert!(
                    (l - expected).abs() < 1e-4,
                    "u16_s2l n={n} i={i}: {l} vs {expected}"
                );
            }
        }
    }

    #[test]
    fn length_linear_to_srgb_u16_slice() {
        for &n in TEST_LENGTHS {
            let input = make_linear_values(n);
            let mut output = vec![0u16; n];
            linear_to_srgb_u16_slice(&input, &mut output);
            for (i, (&l, &u)) in input.iter().zip(output.iter()).enumerate() {
                let expected = crate::scalar::linear_to_srgb_u16(l);
                let diff = (u as i32 - expected as i32).unsigned_abs();
                assert!(diff <= 1, "l2s_u16 n={n} i={i}: {u} vs {expected}");
            }
        }
    }

    #[test]
    fn length_gamma_to_linear_slice() {
        for &n in TEST_LENGTHS {
            let mut values = make_srgb_values(n);
            let original = values.clone();
            gamma_to_linear_slice(&mut values, 2.2);
            linear_to_gamma_slice(&mut values, 2.2);
            for (i, (&orig, &conv)) in original.iter().zip(values.iter()).enumerate() {
                assert!(
                    (orig - conv).abs() < 1e-3,
                    "gamma roundtrip n={n} i={i}: {orig} vs {conv}"
                );
            }
        }
    }

    #[test]
    fn length_u8_rgba_roundtrip() {
        for &num_pixels in TEST_LENGTHS {
            let n = num_pixels * 4;
            let input: Vec<u8> = (0..n).map(|i| (i % 256) as u8).collect();
            let mut linear = vec![0.0f32; n];
            srgb_u8_to_linear_rgba_slice(&input, &mut linear);
            let mut output = vec![0u8; n];
            linear_to_srgb_u8_rgba_slice(&linear, &mut output);
            for px in 0..num_pixels {
                assert_eq!(
                    input[px * 4 + 3],
                    output[px * 4 + 3],
                    "u8 RGBA alpha roundtrip at px {px}/{num_pixels}"
                );
                for ch in 0..3 {
                    let diff =
                        (input[px * 4 + ch] as i32 - output[px * 4 + ch] as i32).unsigned_abs();
                    assert!(
                        diff <= 1,
                        "u8 RGBA RGB roundtrip at px {px} ch {ch}/{num_pixels}: {} vs {}",
                        input[px * 4 + ch],
                        output[px * 4 + ch]
                    );
                }
            }
        }
    }

    #[test]
    fn length_u16_rgba_roundtrip() {
        for &num_pixels in TEST_LENGTHS {
            let n = num_pixels * 4;
            let input: Vec<u16> = (0..n).map(|i| ((i % 256) * 257) as u16).collect();
            let mut linear = vec![0.0f32; n];
            srgb_u16_to_linear_rgba_slice(&input, &mut linear);
            // Alpha must be passthrough: a / 65535.0
            for px in 0..num_pixels {
                let expected_a = input[px * 4 + 3] as f32 / 65535.0;
                assert!(
                    (linear[px * 4 + 3] - expected_a).abs() < 1e-5,
                    "u16 RGBA alpha at px {px}/{num_pixels}"
                );
            }
            let mut output = vec![0u16; n];
            linear_to_srgb_u16_rgba_slice(&linear, &mut output);
            for px in 0..num_pixels {
                assert_eq!(
                    input[px * 4 + 3],
                    output[px * 4 + 3],
                    "u16 RGBA alpha roundtrip at px {px}/{num_pixels}"
                );
            }
        }
    }

    #[test]
    fn length_premultiply_u8_roundtrip() {
        for &num_pixels in TEST_LENGTHS {
            let n = num_pixels * 4;
            let input: Vec<u8> = (0..n)
                .map(|i| {
                    if i % 4 == 3 {
                        ((i / 4) * 15 + 50).min(255) as u8
                    } else {
                        128u8
                    }
                })
                .collect();
            let mut linear = vec![0.0f32; n];
            srgb_u8_to_linear_premultiply_rgba_slice(&input, &mut linear);
            let mut output = vec![0u8; n];
            unpremultiply_linear_to_srgb_u8_rgba_slice(&linear, &mut output);
            for px in 0..num_pixels {
                assert_eq!(
                    input[px * 4 + 3],
                    output[px * 4 + 3],
                    "u8 premul alpha roundtrip at px {px}/{num_pixels}"
                );
                if input[px * 4 + 3] > 0 {
                    for ch in 0..3 {
                        let diff =
                            (input[px * 4 + ch] as i32 - output[px * 4 + ch] as i32).unsigned_abs();
                        assert!(
                            diff <= 1,
                            "u8 premul RGB roundtrip at px {px} ch {ch}/{num_pixels}: {} vs {}",
                            input[px * 4 + ch],
                            output[px * 4 + ch]
                        );
                    }
                }
            }
        }
    }

    // ====================================================================
    // Regression: polynomial overshoot near 1.0 must be clamped
    // ====================================================================

    #[test]
    fn simd_power_result_clamped_near_one() {
        // The rational polynomial can slightly overshoot 1.0 for inputs
        // very close to 1.0 due to FMA rounding. The SIMD dispatch path
        // (mt_srgb_to_linear / mt_linear_to_srgb) must apply .min(one)
        // to match the token implementations.
        //
        // Generate values near 1.0 where overshoot is most likely.
        let near_one: Vec<f32> = (0..1000)
            .map(|i| 1.0 - (i as f32) * 1e-7)
            .chain(core::iter::once(1.0))
            .collect();

        // sRGB-to-linear: SIMD dispatch path
        let mut simd_s2l = near_one.clone();
        srgb_to_linear_slice(&mut simd_s2l);

        for (i, &v) in simd_s2l.iter().enumerate() {
            assert!(
                v <= 1.0,
                "srgb_to_linear overshoot at index {i}: input={}, output={} (bits: {:08x})",
                near_one[i],
                v,
                v.to_bits()
            );
            assert!(v >= 0.0, "srgb_to_linear undershoot at index {i}");
        }

        // linear-to-sRGB: SIMD dispatch path
        let mut simd_l2s = near_one.clone();
        linear_to_srgb_slice(&mut simd_l2s);

        for (i, &v) in simd_l2s.iter().enumerate() {
            assert!(
                v <= 1.0,
                "linear_to_srgb overshoot at index {i}: input={}, output={} (bits: {:08x})",
                near_one[i],
                v,
                v.to_bits()
            );
            assert!(v >= 0.0, "linear_to_srgb undershoot at index {i}");
        }

        // Verify SIMD results match scalar exactly at the bit level
        for (i, &input) in near_one.iter().enumerate() {
            let scalar_s2l = crate::scalar::srgb_to_linear(input);
            let scalar_l2s = crate::scalar::linear_to_srgb(input);
            assert!(
                (simd_s2l[i] - scalar_s2l).abs() <= 1e-6,
                "srgb_to_linear SIMD/scalar mismatch at {i}: input={input}, simd={}, scalar={}",
                simd_s2l[i],
                scalar_s2l
            );
            assert!(
                (simd_l2s[i] - scalar_l2s).abs() <= 1e-6,
                "linear_to_srgb SIMD/scalar mismatch at {i}: input={input}, simd={}, scalar={}",
                simd_l2s[i],
                scalar_l2s
            );
        }
    }

    // ====================================================================
    // Transfer function slice dispatchers match scalar reference
    // ====================================================================

    #[cfg(feature = "transfer")]
    mod tf_slice_parity {
        use super::super::*;

        fn sweep() -> Vec<f32> {
            // Include small remainder past the widest SIMD width (16) to
            // exercise chunk + remainder paths for every tier.
            (0..=1024)
                .map(|i| i as f32 / 1024.0)
                .chain([0.0, 0.25, 0.5, 0.75, 1.0])
                .collect()
        }

        fn check<F, G>(name: &str, slice_fn: F, scalar_fn: G, tol: f32)
        where
            F: Fn(&mut [f32]),
            G: Fn(f32) -> f32,
        {
            let input = sweep();
            let mut simd = input.clone();
            slice_fn(&mut simd);
            for (i, &v) in input.iter().enumerate() {
                let expect = scalar_fn(v);
                let got = simd[i];
                assert!(
                    (got - expect).abs() <= tol,
                    "{name} mismatch at {i} (input={v}): simd={got}, scalar={expect}"
                );
            }
        }

        #[test]
        fn bt709_to_linear_slice_matches_scalar() {
            check(
                "bt709_to_linear_slice",
                bt709_to_linear_slice,
                crate::tf::bt709_to_linear,
                1e-5,
            );
        }

        #[test]
        fn linear_to_bt709_slice_matches_scalar() {
            check(
                "linear_to_bt709_slice",
                linear_to_bt709_slice,
                crate::tf::linear_to_bt709,
                1e-4,
            );
        }

        #[test]
        fn pq_to_linear_slice_matches_scalar() {
            check(
                "pq_to_linear_slice",
                pq_to_linear_slice,
                crate::tf::pq_to_linear,
                1e-5,
            );
        }

        #[test]
        fn linear_to_pq_slice_matches_scalar() {
            check(
                "linear_to_pq_slice",
                linear_to_pq_slice,
                crate::tf::linear_to_pq,
                1e-5,
            );
        }

        #[test]
        fn hlg_to_linear_slice_matches_scalar() {
            check(
                "hlg_to_linear_slice",
                hlg_to_linear_slice,
                crate::tf::hlg_to_linear,
                1e-4,
            );
        }

        #[test]
        fn linear_to_hlg_slice_matches_scalar() {
            check(
                "linear_to_hlg_slice",
                linear_to_hlg_slice,
                crate::tf::linear_to_hlg,
                1e-4,
            );
        }

        // ============================================================
        // RGBA dispatchers: verify TF applied to RGB, alpha preserved
        // ============================================================

        fn rgba_sweep() -> Vec<f32> {
            // 257 RGBA pixels = 1028 floats — exercises chunk + remainder for
            // every SIMD width (x16, x8, x4).
            let mut v = Vec::with_capacity(257 * 4);
            for i in 0..257 {
                let t = i as f32 / 256.0;
                v.push(t);
                v.push((t * 0.5).min(1.0));
                v.push((1.0 - t).max(0.0));
                // Use an alpha value that couldn't collide with TF(R/G/B) by
                // luck — deliberately out of [0,1] so any accidental TF
                // application shows up immediately.
                v.push(-0.125 - t * 0.3);
            }
            v
        }

        fn check_rgba<F, G>(name: &str, rgba_fn: F, scalar_fn: G, tol: f32)
        where
            F: Fn(&mut [f32]),
            G: Fn(f32) -> f32,
        {
            let input = rgba_sweep();
            let mut out = input.clone();
            rgba_fn(&mut out);
            for (px_idx, (in_px, out_px)) in
                input.chunks_exact(4).zip(out.chunks_exact(4)).enumerate()
            {
                for ch in 0..3 {
                    let expect = scalar_fn(in_px[ch]);
                    assert!(
                        (out_px[ch] - expect).abs() <= tol,
                        "{name} RGB mismatch at px {px_idx} ch {ch}: input={}, simd={}, scalar={}",
                        in_px[ch],
                        out_px[ch],
                        expect
                    );
                }
                assert_eq!(
                    out_px[3].to_bits(),
                    in_px[3].to_bits(),
                    "{name} alpha clobbered at px {px_idx}: was {}, now {}",
                    in_px[3],
                    out_px[3]
                );
            }
        }

        #[test]
        fn bt709_to_linear_rgba_slice_matches_scalar_and_preserves_alpha() {
            check_rgba(
                "bt709_to_linear_rgba_slice",
                bt709_to_linear_rgba_slice,
                crate::tf::bt709_to_linear,
                1e-5,
            );
        }

        #[test]
        fn linear_to_bt709_rgba_slice_matches_scalar_and_preserves_alpha() {
            check_rgba(
                "linear_to_bt709_rgba_slice",
                linear_to_bt709_rgba_slice,
                crate::tf::linear_to_bt709,
                1e-4,
            );
        }

        #[test]
        fn pq_to_linear_rgba_slice_matches_scalar_and_preserves_alpha() {
            check_rgba(
                "pq_to_linear_rgba_slice",
                pq_to_linear_rgba_slice,
                crate::tf::pq_to_linear,
                1e-5,
            );
        }

        #[test]
        fn linear_to_pq_rgba_slice_matches_scalar_and_preserves_alpha() {
            check_rgba(
                "linear_to_pq_rgba_slice",
                linear_to_pq_rgba_slice,
                crate::tf::linear_to_pq,
                1e-5,
            );
        }

        #[test]
        fn hlg_to_linear_rgba_slice_matches_scalar_and_preserves_alpha() {
            check_rgba(
                "hlg_to_linear_rgba_slice",
                hlg_to_linear_rgba_slice,
                crate::tf::hlg_to_linear,
                1e-4,
            );
        }

        #[test]
        fn linear_to_hlg_rgba_slice_matches_scalar_and_preserves_alpha() {
            check_rgba(
                "linear_to_hlg_rgba_slice",
                linear_to_hlg_rgba_slice,
                crate::tf::linear_to_hlg,
                1e-4,
            );
        }
    }
}