pipeline_binding.h

Go to the documentation of this file.

#pragma once
 
// From a channel's colour-profile binding to a running pipeline (P6, #4040).
//
// `ColorProfileBinding` has carried a source profile, an emitter profile and
// a gamut policy for a while, and nothing read them: the binding's
// acceptance was tracked, but no pixel ever went through it. This is the
// adapter that turns one into a `StreamingPipelineQ16`.
//
// It lives here rather than in fl/gfx because the dependency runs that way
// round -- channels already include gfx headers, and gfx must not learn
// about channels.
 
#include "fl/channels/color_managed_source.h"
#include "fl/channels/color_profile.h"
#include "fl/channels/config.h"
#include "fl/channels/options.h"  // FL_COLOR_PIPELINE_SHARED
#include "fl/channels/power_prepass.h"
#include "fl/chipsets/encoders/pixel_iterator.h"
#include "fl/chipsets/spi_chipsets.h"
#include "fl/stl/vector.h"
#include "fl/gfx/eorder.h"
#include "fl/gfx/pipeline.h"
#include "fl/gfx/rgbw.h"
#include "fl/gfx/rgbww.h"
#include "pixel_controller.h"
#include "fl/stl/noexcept.h"
 
namespace fl {
 
class CLEDController;
class Channel;
 
#if FL_COLOR_PIPELINE_SHARED
shared_ptr<StreamingPipelineQ16> channelColorPipeline(const CLEDController& controller) FL_NO_EXCEPT;
#endif

bool buildPipelineForBinding(const ColorProfileBinding& binding,
                             StreamingPipelineQ16* out) FL_NO_EXCEPT;

constexpr fl::size kColorPipelineSourceStorage = sizeof(ColorManagedPixelSource);
constexpr fl::size kColorPipelineIteratorStorage = sizeof(PixelIterator);
 
#if FL_COLOR_PIPELINE_SHARED
struct ManagedPowerHistogram {
    static constexpr u8 kBins = 64;
    u32 counts[5][kBins] = {};
    u32 pixels = 0;
    u8 emitters = 3;
};
#endif
 
struct ColorPipelineHooks {
    bool (*build)(const ColorProfileBinding&, const ChannelOptions&,
                  const ChipsetVariant&, StreamingPipelineQ16*);

    PixelIterator* (*makeIterator)(void* source_storage,
                                   void* iterator_storage,
                                   PixelController<RGB, 1, 0xFFFFFFFF>& controller,
                                   EOrder order,
                                   ColorPipelineFrameRef pipeline,
                                   const Rgbw& rgbw, Rgbww rgbww,
                                   u8 dither_phase, u8 brightness);

    void (*destroyIterator)(void* source_storage, void* iterator_storage);

    void (*notifyProfileClearedByLegacy)();

#if FL_COLOR_PIPELINE_SHARED
    using PowerEstimator = u32 (*)(span<const u8> interleaved_codes,
                                   u8 emitter_count);
    u32 (*unscaledPowerMilliwatts)(const StreamingPipelineQ16& pipeline,
                                   span<const CRGB> leds, u8 emitter_count,
                                   PowerEstimator estimate);
#endif

    bool (*encodeManagedSpi)(PixelIterator& pixels, vector_psram<u8>* out,
                             SpiChipset chip, const Channel& controller);
};
 
#if FL_COLOR_PIPELINE_SHARED
struct PowerFrameHooks {
    void (*buildPowerHistogram)(const StreamingPipelineQ16& pipeline,
                                span<const CRGB> leds, u8 emitter_count,
                                ManagedPowerHistogram* out);
    u64 (*histogramPowerNumerator)(const StreamingPipelineQ16& pipeline,
                                   const ManagedPowerHistogram& histogram,
                                   FluxScalar flux, PowerCodecPolicy codec,
                                   const u8 (&weights)[5],
                                   u8 (*electricalMap)(u8 code));
    bool frameFluxActive;
    u32 frameFluxQ16;
};
 
PowerFrameHooks& powerFrameHooks() FL_NO_EXCEPT;
#endif

ColorPipelineHooks& colorPipelineHooks() FL_NO_EXCEPT;

void installColorPipelineHooks() FL_NO_EXCEPT;
 
}  // namespace fl