buildWidePipelineQ16()

bool fl::anonymous_namespace{pipeline.cpp.hpp}::buildWidePipelineQ16	(	const colorimetric_response::EmitterProfile &	device,
		const Chromaticity *	target_white,
		const EmitterSolveMatrixQ16 *	effective_solve,
		shared_ptr< const WidePipelineQ16 > *	out )

Definition at line 76 of file pipeline.cpp.hpp.

                                                         {
    shared_ptr<WidePipelineQ16> wide = make_shared<WidePipelineQ16>();
    if (!wide) return false;
    wide->topology = device.topology;
    i32 white1[3];
    i32 white2[3] = {};
    if (!wideWhiteColumnQ16(device.xy_white1, device.lum_white1, white1))
        return false;
    if (device.topology == colorimetric_response::EmitterTopology::RGBWW &&
        !wideWhiteColumnQ16(device.xy_white2, device.lum_white2, white2))
        return false;
    if (target_white != nullptr) {
        AdaptationMatrixQ16 to_working;
        if (!buildBradfordMatrixQ16(*target_white, kPipelineD65,
                                    &to_working)) return false;
        i32 adapted1[3];
        adaptXyzQ16(to_working, white1, adapted1);
        for (int i = 0; i < 3; ++i) white1[i] = adapted1[i];
        if (device.topology == colorimetric_response::EmitterTopology::RGBWW) {
            i32 adapted2[3];
            adaptXyzQ16(to_working, white2, adapted2);
            for (int i = 0; i < 3; ++i) white2[i] = adapted2[i];
        }
    }
    const WhiteAllocationPolicy allocation = WhiteAllocationPolicy::WhitePreferred;
    if (device.topology == colorimetric_response::EmitterTopology::RGBW) {
        const bool ok = effective_solve == nullptr
            ? buildGamutMapRgbwQ16(device, white1, allocation, &wide->rgbw)
            : buildGamutMapRgbwFromSolveQ16(device, *effective_solve, white1,
                                            allocation, &wide->rgbw);
        if (!ok) return false;
    } else if (device.topology == colorimetric_response::EmitterTopology::RGBWW) {
        const bool ok = effective_solve == nullptr
            ? buildGamutMapRgbwwQ16(device, white1, white2, allocation,
                                    &wide->rgbww)
            : buildGamutMapRgbwwFromSolveQ16(device, *effective_solve, white1,
                                             white2, allocation, &wide->rgbww);
        if (!ok) return false;
    } else {
        return false;
    }
    if (device.response_lut_size != 0) {
        const u16 size = device.response_lut_size;
        if (!validResponseLut(device.response_lut_white1, size)) return false;
        wide->white1_response.assign(device.response_lut_white1,
                                     device.response_lut_white1 + size);
        if (wide->white1_response.size() != size) return false;
        if (device.topology == colorimetric_response::EmitterTopology::RGBWW) {
            if (!validResponseLut(device.response_lut_white2, size)) return false;
            wide->white2_response.assign(device.response_lut_white2,
                                         device.response_lut_white2 + size);
            if (wide->white2_response.size() != size) return false;
        }
    }
    *out = wide;
    return true;
}

References fl::adaptXyzQ16(), fl::buildBradfordMatrixQ16(), fl::buildGamutMapRgbwFromSolveQ16(), fl::buildGamutMapRgbwQ16(), fl::buildGamutMapRgbwwFromSolveQ16(), fl::buildGamutMapRgbwwQ16(), buildWidePipelineQ16(), fl::FL_NO_EXCEPT, kPipelineD65, fl::make_shared(), fl::colorimetric_response::RGBW, fl::colorimetric_response::RGBWW, validResponseLut(), fl::WhitePreferred, and wideWhiteColumnQ16().

Referenced by buildWidePipelineQ16().

Here is the call graph for this function:

Here is the caller graph for this function: