mapAndSolveDrivesQ16()

void fl::mapAndSolveDrivesQ16	(	const GamutMapQ16 &	map,
		const i32(&)	xyz[3],
		i32(&)	drives[3] )

One pixel: XYZ in s16.16 to in-gamut emitter drives in s16.16.

Drives always come back inside [0, 1]. A target already inside the hull is returned untouched, so an in-gamut image pays only the solve and the bounds check.

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

                                                         {
    solveRgbDrivesQ16(map.solve, xyz, drives);
    if (gamutDrivesAreInRange(drives, kGamutFeasibilitySlack)) {
        // Already inside the hull. An in-gamut image pays one solve, this
        // comparison and the clamp, and never touches OKLab at all.
        clampGamutDrives(drives);
        return;
    }
 
    i32 lab[3];
    xyzToOklabQ16(xyz, lab);
 
    i32 lightness = lab[0];
    if (lightness < 0) {
        lightness = 0;
    }
 
    // Above the brightest neutral, try keeping the lightness (#4245). The
    // feasible chroma there is an interval that does not contain zero, so it
    // has to be located before either edge can be bisected; when it is found,
    // clamping the target's chroma into it holds the requested lightness
    // instead of discarding up to 29.7% of what the hull reaches.
    if (lightness > map.max_neutral_lightness) {
        i32 low_edge = 0;
        i32 high_edge = 0;
        if (feasibleChromaInterval(lab, lightness, RgbFeasible{map.solve},
                                   &low_edge, &high_edge)) {
            i32 candidate_xyz[3];
            chromaCandidateXyz(lab, lightness, clampChromaFactor(low_edge, high_edge),
                               candidate_xyz);
            i32 candidate[3];
            solveRgbDrivesQ16(map.solve, candidate_xyz, candidate);
            if (gamutDrivesAreInRange(candidate, kGamutFeasibilitySlack)) {
                for (int i = 0; i < 3; ++i) {
                    drives[i] = candidate[i];
                }
                clampGamutDrives(drives);
                return;
            }
        }
        // No seed at this lightness. Walking down to the highest lightness
        // that still has one keeps the answer continuous; dropping straight
        // to the neutral cap does not, and that step measured 234 eight-bit
        // codes before this search was added.
        const i32 reachable = highestReachableLightness(
            lab, map.max_neutral_lightness, lightness, RgbFeasible{map.solve});
        i32 edge_low = 0;
        i32 edge_high = 0;
        if (reachable > map.max_neutral_lightness &&
            feasibleChromaInterval(lab, reachable, RgbFeasible{map.solve},
                                   &edge_low, &edge_high)) {
            i32 candidate_xyz[3];
            chromaCandidateXyz(lab, reachable,
                               clampChromaFactor(edge_low, edge_high),
                               candidate_xyz);
            i32 candidate[3];
            solveRgbDrivesQ16(map.solve, candidate_xyz, candidate);
            if (gamutDrivesAreInRange(candidate, kGamutFeasibilitySlack)) {
                for (int i = 0; i < 3; ++i) {
                    drives[i] = candidate[i];
                }
                clampGamutDrives(drives);
                return;
            }
        }
        // Nothing above the cap works for this hue at all. Fall through to
        // the clamp, which is what shipped before #4245.
        lightness = map.max_neutral_lightness;
    }
 
    // Then chroma, by scaling (a, b) toward zero.
    const i32 factor = largestFeasibleChroma(lab, lightness, RgbFeasible{map.solve});
    i32 mapped_xyz[3];
    chromaCandidateXyz(lab, lightness, factor, mapped_xyz);
    solveRgbDrivesQ16(map.solve, mapped_xyz, drives);
    clampGamutDrives(drives);
}

References FL_NO_EXCEPT, solveRgbDrivesQ16(), and xyzToOklabQ16().

Referenced by processPixelLinearQ16().

Here is the call graph for this function:

Here is the caller graph for this function: