allocateEmitterDrivesQ16()

bool fl::allocateEmitterDrivesQ16	(	const WhiteAllocationQ16 &	allocation,
		const i32(&)	xyz[3],
		i32(&)	drives[4] )

One pixel: XYZ in s16.16 to four drives, in the order red, green, blue, white, at whichever end of the feasible interval the profile's policy names.

False when no white level keeps the RGB drives in range, which means the target is outside the device hull – the gamut mapper's job, not this one's. drives is not written in that case.

Cost note, recorded rather than optimized away on a guess: this performs up to six s16.16 divisions per pixel, and is the only stage in the pipeline that divides per pixel at all. Each bound can instead be compared by cross-multiplication, leaving one division for the chosen level, at the price of i64 multiplies that are not obviously cheaper on an 8-bit target. Nobody has measured which wins, so the straightforward version is what ships.

Definition at line 177 of file white_allocation.cpp.hpp.

                                                             {
    i32 at_zero[3];
    solveRgbDrivesQ16(allocation.rgb_solve, xyz, at_zero);
 
    // The interval of white levels that keeps every RGB drive in range.
    // Each bound is one inequality in the white level because d(w) is affine
    // in w -- that is the whole reason no search is needed here.
    //
    // Strict bounds, deliberately. Slack here would be *spent* rather than
    // merely tolerated: the policy maximizes white, so widening the bounds
    // by 64 raw units lets it take 64 units out of every RGB drive on every
    // pixel. That is not a rounding allowance, it is a systematic colour
    // shift -- measured at white = 886 where the reference says 0. The
    // slack lives on the drive check below, which is what actually decides
    // feasibility.
    i64 low = 0;
    i64 high = kWhiteFullDrive;
    for (int i = 0; i < 3; ++i) {
        const i32 slope = allocation.per_white[i];
        if (slope != 0) {
            // Dividing by a negative slope swaps which bound is which.
            const i64 first = divideWhiteQ16(at_zero[i], slope);
            const i64 second = divideWhiteQ16(at_zero[i] - kWhiteFullDrive, slope);
            const i64 upper = slope > 0 ? first : second;
            const i64 lower = slope > 0 ? second : first;
            if (upper < high) {
                high = upper;
            }
            if (lower > low) {
                low = lower;
            }
        } else if (at_zero[i] < -allocation.slack[i] ||
                   at_zero[i] > kWhiteFullDrive + allocation.slack[i]) {
            // White cannot move this drive at all, and it is already out.
            return false;
        }
    }
    // At the dark floor the solve rounds a drive to -1 raw on a colour the
    // device reproduces exactly -- corpus target (4, 1, 19) solves to
    // (0, -1, 1) -- which drags `high` below zero. Clamp rather than refuse;
    // the drive check below decides whether the target is really reachable.
    if (high < 0) {
        high = 0;
    }
    if (low > high) {
        return false;
    }
 
    // Either end reproduces the target exactly; which one is policy. Both
    // ends are inside [0, full] by construction, so the narrowing is safe.
    const i32 level = static_cast<i32>(
        allocation.policy == WhiteAllocationPolicy::RgbPreferred ? low : high);
    i32 rgb[3];
    for (int i = 0; i < 3; ++i) {
        const i32 drive = at_zero[i] - scaleWhiteQ16(allocation.per_white[i], level);
        const i32 channel_slack = allocation.slack[i];
        if (drive < -channel_slack || drive > kWhiteFullDrive + channel_slack) {
            return false;
        }
        rgb[i] = drive < 0 ? 0 : (drive > kWhiteFullDrive ? kWhiteFullDrive : drive);
    }
    drives[0] = rgb[0];
    drives[1] = rgb[1];
    drives[2] = rgb[2];
    drives[3] = level < 0 ? 0
                          : (level > kWhiteFullDrive ? kWhiteFullDrive : level);
    return true;
}

References FL_NO_EXCEPT, fl::WhiteAllocationQ16::per_white, fl::WhiteAllocationQ16::policy, fl::WhiteAllocationQ16::rgb_solve, RgbPreferred, fl::WhiteAllocationQ16::slack, and solveRgbDrivesQ16().

Referenced by buildGamutMapRgbwFromSolveQ16(), mapAndAllocateRgbwQ16(), fl::anonymous_namespace{gamut_map.cpp.hpp}::RgbwFeasible::operator()(), and processPixelWideLinearQ16().

Here is the call graph for this function:

Here is the caller graph for this function: