mapAndAllocateRgbwQ16()

void fl::mapAndAllocateRgbwQ16	(	const GamutMapRgbwQ16 &	map,
		const i32(&)	xyz[3],
		i32(&)	drives[4] )

One pixel: XYZ in s16.16 to four in-gamut drives, red, green, blue, white.

Same shape as the three-emitter path – one forward OKLab transform, one lightness comparison, then eight halvings – but every feasibility test goes through the white-preferred allocation, so the hull it maps onto is the device's real one.

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

                                                          {
    if (allocateEmitterDrivesQ16(map.allocation, xyz, drives)) {
        // Already inside the device's hull -- which, with a white emitter,
        // is a good deal larger than the RGB one.
        return;
    }
 
    i32 lab[3];
    xyzToOklabQ16(xyz, lab);
    i32 lightness = lab[0];
    if (lightness < 0) {
        lightness = 0;
    }
 
    // Same above-cap interval clamp as the RGB path (#4245). The white
    // emitter moves the cap but does not change the shape: above it the
    // feasible chroma still misses zero.
    if (lightness > map.max_neutral_lightness) {
        i32 low_edge = 0;
        i32 high_edge = 0;
        if (feasibleChromaInterval(lab, lightness, RgbwFeasible{map.allocation},
                                   &low_edge, &high_edge)) {
            i32 candidate_xyz[3];
            chromaCandidateXyz(lab, lightness, clampChromaFactor(low_edge, high_edge),
                               candidate_xyz);
            if (allocateEmitterDrivesQ16(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,
            RgbwFeasible{map.allocation});
        i32 edge_low = 0;
        i32 edge_high = 0;
        if (reachable > map.max_neutral_lightness &&
            feasibleChromaInterval(lab, reachable, RgbwFeasible{map.allocation},
                                   &edge_low, &edge_high)) {
            i32 edge_xyz[3];
            chromaCandidateXyz(lab, reachable,
                               clampChromaFactor(edge_low, edge_high), edge_xyz);
            if (allocateEmitterDrivesQ16(map.allocation, edge_xyz, drives)) {
                return;
            }
        }
        lightness = map.max_neutral_lightness;
    }
 
    const i32 factor =
        largestFeasibleChroma(lab, lightness, RgbwFeasible{map.allocation});
    i32 mapped_xyz[3];
    chromaCandidateXyz(lab, lightness, factor, mapped_xyz);
    if (allocateEmitterDrivesQ16(map.allocation, mapped_xyz, drives)) {
        return;
    }
    // The accepted candidate can fall a few ULP outside on the final
    // re-solve. Fall back to the neutral at this lightness, which the
    // lightness bound guarantees is reachable.
    const i32 neutral_lab[3] = {lightness, 0, 0};
    i32 neutral_xyz[3];
    oklabToXyzQ16(neutral_lab, neutral_xyz);
    if (!allocateEmitterDrivesQ16(map.allocation, neutral_xyz, drives)) {
        drives[0] = 0;
        drives[1] = 0;
        drives[2] = 0;
        drives[3] = 0;
    }
}

References allocateEmitterDrivesQ16(), 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: