pipeline.h

Go to the documentation of this file.

#pragma once
 
// The streaming pipeline core (P6, #4040).
//
// P6's stages have existed as separate modules for a while -- decode,
// primaries->XYZ, chromatic adaptation, the device solve, the gamut mapper,
// the flux scalar -- with nothing composing them. This is the composition:
// one bind-time build, and one per-pixel call that runs the whole chain.
//
// The chain, and why it is in this order:
//
//   1. `decodeTransferU16` turns each RGB8 code into u16 linear light. One
//      semantic conversion, per B3: there is no intermediate RGB8 linear
//      buffer and no RGB8->RGB8 correction anywhere in it.
//   2. `linearRgbToXyzQ16` takes those to s16.16 XYZ. Chromatic adaptation
//      is folded into that matrix at bind time, so it costs nothing here.
//   3. The gamut mapper maps the target onto the device hull and solves for
//      drives -- clamping belongs to it, not to the stages before.
//   4. `applyFluxScalar` scales linear emitter light. C4's single insertion point:
//      brightness and the power limiter compose into one scalar before they
//      get here. Inverse physical response then produces drive coordinates;
//      native encoding performs the final quantization.
//
// Streaming, per C2: the per-pixel call carries no state and allocates
// nothing, so it runs inside `PixelController` iteration without an RGB16
// framebuffer.
 
#include "fl/gfx/color_profile.h"
#include "fl/gfx/colorimetric_response.h"
#include "fl/gfx/flux_scalar.h"
#include "fl/gfx/gamut_map.h"
#include "fl/gfx/source_xyz.h"
#include "fl/stl/int.h"
#include "fl/stl/noexcept.h"
#include "fl/stl/shared_ptr.h"
#include "fl/stl/vector.h"
 
namespace fl {

struct ResponseLutsQ16 {
    vector<u16> red;
    vector<u16> green;
    vector<u16> blue;
};

struct WidePipelineQ16 {
    colorimetric_response::EmitterTopology topology;
    GamutMapRgbwQ16 rgbw;
    GamutMapRgbwwQ16 rgbww;
    vector<u16> white1_response;
    vector<u16> white2_response;
};

struct StreamingPipelineQ16 {
    TransferFunction transfer;

    SourceMatrixQ16 source;

    GamutMapQ16 gamut;

    GamutPolicy gamut_policy = GamutPolicy::ChromaCompress;

    FluxScalar flux = FluxScalar::unity();

    shared_ptr<const ResponseLutsQ16> response;
 
    shared_ptr<const WidePipelineQ16> wide;
};

bool buildStreamingPipelineQ16(const SourceProfile& source,
                               const colorimetric_response::EmitterProfile& device,
                               GamutPolicy policy,
                               StreamingPipelineQ16* out,
                               const Chromaticity* target_white = nullptr) FL_NO_EXCEPT;

void setPipelineFluxQ16(StreamingPipelineQ16* pipeline, FluxScalar flux) FL_NO_EXCEPT;

void processPixelQ16(const StreamingPipelineQ16& pipeline, u8 r, u8 g, u8 b,
                     i32 (&drives)[3]) FL_NO_EXCEPT;

void processPixelLinearQ16(const StreamingPipelineQ16& pipeline, u8 r, u8 g,
                           u8 b, i32 (&light)[3]) FL_NO_EXCEPT;

void processPixelWideQ16(const StreamingPipelineQ16& pipeline, u8 r, u8 g,
                         u8 b, i32 (&drives)[5]) FL_NO_EXCEPT;
void processPixelWideLinearQ16(const StreamingPipelineQ16& pipeline, u8 r,
                               u8 g, u8 b, i32 (&light)[5]) FL_NO_EXCEPT;

i32 encodeLinearEmitterQ16(const StreamingPipelineQ16& pipeline, u8 emitter,
                            i32 light, FluxScalar flux) FL_NO_EXCEPT;
 
}  // namespace fl