buildBradfordMatrixQ16()

bool fl::buildBradfordMatrixQ16	(	Chromaticity	source_white,
		Chromaticity	destination_white,
		AdaptationMatrixQ16 *	out )

Build the Bradford transform from source_white to destination_white.

False if either white has a zero cone response, which no real white does but a corrupt profile might.

Definition at line 83 of file chromatic_adaptation.cpp.hpp.

                                                                   {
    if (out == nullptr) {
        return false;
    }
    // In s16.16 throughout (FastLED#4458). The same construction as the
    // float build it replaces: both whites to XYZ at Y = 1, into cone space,
    // the per-cone ratio as a diagonal, and B^-1 * diag * B collapsed once.
    i32 source_xy[2];
    i32 destination_xy[2];
    if (!adaptationWhiteQ16(source_white, source_xy) ||
        !adaptationWhiteQ16(destination_white, destination_xy)) {
        return false;
    }
    i64 source_xyz[3];
    i64 destination_xyz[3];
    if (!detail::xyzColumnQ16(source_xy, kAdaptationQ16One, source_xyz) ||
        !detail::xyzColumnQ16(destination_xy, kAdaptationQ16One, destination_xyz)) {
        return false;
    }
    const i32 source_v[3] = {static_cast<i32>(source_xyz[0]), static_cast<i32>(source_xyz[1]),
                             static_cast<i32>(source_xyz[2])};
    const i32 destination_v[3] = {static_cast<i32>(destination_xyz[0]),
                                  static_cast<i32>(destination_xyz[1]),
                                  static_cast<i32>(destination_xyz[2])};
    i64 scale[3];
    for (int i = 0; i < 3; ++i) {
        const i32 source_cone = detail::dotRowQ16(detail::kBradfordQ16[i], source_v);
        const i32 destination_cone =
            detail::dotRowQ16(detail::kBradfordQ16[i], destination_v);
        // A zero cone response would divide by zero. No physical white does
        // this; a corrupt profile can.
        if (source_cone == 0) {
            return false;
        }
        scale[i] = detail::roundedDivideQ16(
            static_cast<i64>(destination_cone) * kAdaptationQ16One, source_cone);
    }
    for (int row = 0; row < 3; ++row) {
        for (int col = 0; col < 3; ++col) {
            // sum_k Binv[row][k] * scale[k] * B[k][col]: each term is Q48,
            // brought back to Q16 once at the end rather than per product.
            i64 sum_q32 = 0;
            for (int k = 0; k < 3; ++k) {
                const i64 inv_scale_q16 = detail::roundedDivideQ16(
                    static_cast<i64>(detail::kBradfordInverseQ16[row][k]) * scale[k],
                    kAdaptationQ16One);
                sum_q32 += inv_scale_q16 * detail::kBradfordQ16[k][col];
            }
            const i64 value = detail::roundedDivideQ16(sum_q32, kAdaptationQ16One);
            if (value > 2147483647LL || value < -2147483648LL) {
                return false;
            }
            out->m[row][col] = static_cast<i32>(value);
        }
    }
    return true;
}

References fl::detail::dotRowQ16(), FL_NO_EXCEPT, fl::detail::kBradfordInverseQ16, fl::detail::kBradfordQ16, fl::detail::roundedDivideQ16(), scale, type_rank< T >::value, and fl::detail::xyzColumnQ16().

Referenced by buildStreamingPipelineQ16(), and fl::anonymous_namespace{pipeline.cpp.hpp}::buildWidePipelineQ16().

Here is the call graph for this function:

Here is the caller graph for this function: