mapAndAllocateRgbwwQ16()

void fl::mapAndAllocateRgbwwQ16	(	const GamutMapRgbwwQ16 &	map,
		const i32(&)	xyz[3],
		i32(&)	drives[5] )

One pixel: XYZ in s16.16 to five in-gamut drives – red, green, blue, white1, white2.

Same shape as the other two paths: one forward OKLab transform, one lightness comparison, then eight halvings, with every feasibility test going through the two-white allocation so the hull is the device's real one.

Definition at line 746 of file gamut_map.cpp.hpp.

                                                           {
    if (allocateTwoWhiteDrivesQ16(map.allocation, xyz, drives)) {
        // Already inside the device's hull, which with two whites is larger
        // again than the one-white one.
        return;
    }
 
    i32 lab[3];
    xyzToOklabQ16(xyz, lab);
    i32 lightness = lab[0];
    if (lightness < 0) {
        lightness = 0;
    }
 
    // And again for two whites (#4245).
    if (lightness > map.max_neutral_lightness) {
        i32 low_edge = 0;
        i32 high_edge = 0;
        if (feasibleChromaInterval(lab, lightness, RgbwwFeasible{map.allocation},
                                   &low_edge, &high_edge)) {
            i32 candidate_xyz[3];
            chromaCandidateXyz(lab, lightness, clampChromaFactor(low_edge, high_edge),
                               candidate_xyz);
            if (allocateTwoWhiteDrivesQ16(map.allocation, candidate_xyz, drives)) {
                return;
            }
        }
 
        // Same walk-down as the RGB path: dropping straight to the cap when
        // the probes stop landing is a step, not a mapping.
        const i32 reachable = highestReachableLightness(
            lab, map.max_neutral_lightness, lightness,
            RgbwwFeasible{map.allocation});
        i32 edge_low = 0;
        i32 edge_high = 0;
        if (reachable > map.max_neutral_lightness &&
            feasibleChromaInterval(lab, reachable, RgbwwFeasible{map.allocation},
                                   &edge_low, &edge_high)) {
            i32 edge_xyz[3];
            chromaCandidateXyz(lab, reachable,
                               clampChromaFactor(edge_low, edge_high), edge_xyz);
            if (allocateTwoWhiteDrivesQ16(map.allocation, edge_xyz, drives)) {
                return;
            }
        }
        lightness = map.max_neutral_lightness;
    }
 
    const i32 factor =
        largestFeasibleChroma(lab, lightness, RgbwwFeasible{map.allocation});
    i32 mapped_xyz[3];
    chromaCandidateXyz(lab, lightness, factor, mapped_xyz);
    if (allocateTwoWhiteDrivesQ16(map.allocation, mapped_xyz, drives)) {
        return;
    }
    // Same last resort as the other paths: the accepted candidate can fall a
    // few ULP outside on the final re-solve, and the neutral at this
    // lightness is guaranteed reachable by the bound above.
    const i32 neutral_lab[3] = {lightness, 0, 0};
    i32 neutral_xyz[3];
    oklabToXyzQ16(neutral_lab, neutral_xyz);
    if (!allocateTwoWhiteDrivesQ16(map.allocation, neutral_xyz, drives)) {
        for (int i = 0; i < 5; ++i) {
            drives[i] = 0;
        }
    }
}

References allocateTwoWhiteDrivesQ16(), FL_NO_EXCEPT, oklabToXyzQ16(), and xyzToOklabQ16().

Referenced by processPixelWideLinearQ16().

Here is the call graph for this function:

Here is the caller graph for this function: