linear-srgb 0.7.0

Fast linear↔sRGB color space conversion with FMA acceleration and LUT support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! HLG (ARIB STD-B67) transfer function (scalar + generic SIMD).

use super::fast_math;
#[allow(unused_imports)]
use num_traits::Float; // provides sqrt via libm in no_std

// =============================================================================
// Scalar
// =============================================================================

const HLG_A: f32 = 0.17883277;
const HLG_B: f32 = 0.28466892; // 1 - 4 * A
const HLG_C: f32 = 0.55991073; // 0.5 - A * ln(4 * A)
const HLG_A_INV_LOG2E: f32 = HLG_A * core::f32::consts::LN_2; // A * ln(2) for log2 conversion
const HLG_INV_A_LOG2E: f32 = core::f32::consts::LOG2_E / HLG_A; // log2(e) / A for exp2 conversion

/// HLG inverse OETF: signal → scene linear. Uses fast_pow2f for exp().
#[inline(always)]
pub fn hlg_to_linear(v: f32) -> f32 {
    if v <= 0.0 {
        0.0
    } else if v <= 0.5 {
        (v * v) / 3.0
    } else {
        (fast_math::fast_pow2f((v - HLG_C) * HLG_INV_A_LOG2E) + HLG_B) / 12.0
    }
}

/// HLG OETF: scene linear → signal. Uses fast_log2f for ln().
#[inline(always)]
pub fn linear_to_hlg(v: f32) -> f32 {
    if v <= 0.0 {
        0.0
    } else if v <= 1.0 / 12.0 {
        (3.0 * v).sqrt()
    } else {
        HLG_A_INV_LOG2E * fast_math::fast_log2f(12.0 * v - HLG_B) + HLG_C
    }
}

// =============================================================================
// Generic SIMD — x4
// =============================================================================

use magetypes::simd::backends::F32x4Convert;
use magetypes::simd::generic::f32x4;

#[allow(dead_code)]
#[inline(always)]
pub(crate) fn hlg_to_linear_x4<T: F32x4Convert>(t: T, v: f32x4<T>) -> f32x4<T> {
    let zero = f32x4::zero(t);
    let half = f32x4::splat(t, 0.5);
    let third = f32x4::splat(t, 1.0 / 3.0);
    let inv_12 = f32x4::splat(t, 1.0 / 12.0);
    let hlg_b = f32x4::splat(t, HLG_B);
    let hlg_c = f32x4::splat(t, HLG_C);
    let hlg_inv_a_log2e = f32x4::splat(t, HLG_INV_A_LOG2E);

    let a = v.max(zero);

    let low = (a * a) * third;

    let exp_arg = (a - hlg_c) * hlg_inv_a_log2e;
    let exp_val = fast_math::fast_pow2f_x4(t, exp_arg);
    let high = (exp_val + hlg_b) * inv_12;

    let mask = a.simd_le(half);
    let result = f32x4::blend(mask, low, high);

    let pos_mask = v.simd_gt(zero);
    result & pos_mask
}

#[allow(dead_code)]
#[inline(always)]
pub(crate) fn linear_to_hlg_x4<T: F32x4Convert>(t: T, v: f32x4<T>) -> f32x4<T> {
    let zero = f32x4::zero(t);
    let threshold = f32x4::splat(t, 1.0 / 12.0);
    let three = f32x4::splat(t, 3.0);
    let twelve = f32x4::splat(t, 12.0);
    let hlg_a_ln2 = f32x4::splat(t, HLG_A_INV_LOG2E);
    let hlg_b = f32x4::splat(t, HLG_B);
    let hlg_c = f32x4::splat(t, HLG_C);

    let a = v.max(zero);

    let low = (three * a).sqrt();

    let arg = twelve * a - hlg_b;
    let safe_arg = arg.max(f32x4::splat(t, f32::MIN_POSITIVE));
    let log2_val = fast_math::fast_log2f_x4(t, safe_arg);
    let high = hlg_a_ln2.mul_add(log2_val, hlg_c);

    let mask = a.simd_le(threshold);
    let result = f32x4::blend(mask, low, high);

    let pos_mask = v.simd_gt(zero);
    result & pos_mask
}

// =============================================================================
// Generic SIMD — x8
// =============================================================================

use magetypes::simd::backends::F32x8Convert;
use magetypes::simd::generic::f32x8;

#[inline(always)]
pub(crate) fn hlg_to_linear_x8<T: F32x8Convert>(t: T, v: f32x8<T>) -> f32x8<T> {
    let zero = f32x8::zero(t);
    let half = f32x8::splat(t, 0.5);
    let third = f32x8::splat(t, 1.0 / 3.0);
    let inv_12 = f32x8::splat(t, 1.0 / 12.0);
    let hlg_b = f32x8::splat(t, HLG_B);
    let hlg_c = f32x8::splat(t, HLG_C);
    let hlg_inv_a_log2e = f32x8::splat(t, HLG_INV_A_LOG2E);

    let a = v.max(zero);

    let low = (a * a) * third;

    let exp_arg = (a - hlg_c) * hlg_inv_a_log2e;
    let exp_val = fast_math::fast_pow2f_x8(t, exp_arg);
    let high = (exp_val + hlg_b) * inv_12;

    let mask = a.simd_le(half);
    let result = f32x8::blend(mask, low, high);

    let pos_mask = v.simd_gt(zero);
    result & pos_mask
}

#[inline(always)]
pub(crate) fn linear_to_hlg_x8<T: F32x8Convert>(t: T, v: f32x8<T>) -> f32x8<T> {
    let zero = f32x8::zero(t);
    let threshold = f32x8::splat(t, 1.0 / 12.0);
    let three = f32x8::splat(t, 3.0);
    let twelve = f32x8::splat(t, 12.0);
    let hlg_a_ln2 = f32x8::splat(t, HLG_A_INV_LOG2E);
    let hlg_b = f32x8::splat(t, HLG_B);
    let hlg_c = f32x8::splat(t, HLG_C);

    let a = v.max(zero);

    let low = (three * a).sqrt();

    let arg = twelve * a - hlg_b;
    let safe_arg = arg.max(f32x8::splat(t, f32::MIN_POSITIVE));
    let log2_val = fast_math::fast_log2f_x8(t, safe_arg);
    let high = hlg_a_ln2.mul_add(log2_val, hlg_c);

    let mask = a.simd_le(threshold);
    let result = f32x8::blend(mask, low, high);

    let pos_mask = v.simd_gt(zero);
    result & pos_mask
}