color_managed_source.h

Go to the documentation of this file.

#pragma once
 
// Streaming colour-managed pixel source (P6, #4040).
//
// The last stage of the wiring: something a `PixelIterator` can be built
// over that runs the pipeline per pixel instead of the legacy scale.
//
// It is a source, not a buffer, and that is the point. C2 asks for the
// per-pixel work to happen inside the existing iteration with no RGB16
// framebuffer, and B3 forbids an intermediate RGB8 one. `showPixels`
// already has a place that rewrites pixels -- the XYMap path materializes a
// thread-local `CRGB` vector -- and putting the pipeline there would break
// both rules at once. This reads one pixel, transforms it, and yields the
// bytes; nothing is held between pixels.
//
// `PixelIterator`'s constructor is templated over its source, so this only
// has to provide the same members `PixelController` does. It is not itself
// templated on colour order: the order is applied to the three outputs at
// the end, which avoids six near-identical instantiations for something
// decided at bind time.
 
#include "fl/gfx/pipeline.h"
#include "fl/channels/options.h"  // FL_COLOR_PIPELINE_SHARED
#include "fl/channels/color_profile.h"  // IWYU pragma: keep  (EmitterProfile)
#include "fl/stl/int.h"
#include "fl/stl/noexcept.h"
#include "fl/gfx/eorder.h"
#include "fl/gfx/rgbw.h"
#include "fl/gfx/rgbww.h"
#include "pixel_controller.h"
 
namespace fl {
 
#if FL_COLOR_PIPELINE_SHARED
using ColorPipelineFrameRef = const StreamingPipelineQ16&;
#else
using ColorPipelineFrameRef = StreamingPipelineQ16&;
#endif

class ColorManagedPixelSource {
  public:
    ColorManagedPixelSource(PixelController<RGB>& controller, EOrder order,
                            ColorPipelineFrameRef pipeline,
                            u8 dither_phase) FL_NO_EXCEPT;
    ColorManagedPixelSource(PixelController<RGB>& controller, EOrder order,
                            ColorPipelineFrameRef pipeline) FL_NO_EXCEPT;

    void setFlux(u8 brightness) FL_NO_EXCEPT;
    void setFlux(FluxScalar flux) FL_NO_EXCEPT;

    void loadAndScaleRGB(u8* b0_out, u8* b1_out, u8* b2_out) FL_NO_EXCEPT;
 
#if !FL_PLATFORM_HAS_TINY_MEMORY
    void loadAndScaleRGB16(u16* b0_out, u16* b1_out, u16* b2_out) FL_NO_EXCEPT;
#endif

    void loadAndScaleRGBW(const Rgbw& rgbw, u8* b0_out, u8* b1_out, u8* b2_out,
                          u8* b3_out) FL_NO_EXCEPT;

    void loadAndScaleRGBWW(Rgbww rgbww, u8* b0_out, u8* b1_out, u8* b2_out,
                           u8* b3_out, u8* b4_out) FL_NO_EXCEPT;
 
#if FASTLED_HD_COLOR_MIXING
    void loadRGBScaleAndBrightness(u8* c0, u8* c1, u8* c2,
                                   u8* brightness) FL_NO_EXCEPT;
#endif

    void stepDithering() FL_NO_EXCEPT { mController.stepDithering(); }
 
    void advanceData() FL_NO_EXCEPT { mController.advanceData(); }
    int size() const FL_NO_EXCEPT { return mController.size(); }
    bool has(int n) FL_NO_EXCEPT { return mController.has(n); }
 
  private:
    static u8 quantize(i32 drive) FL_NO_EXCEPT;

    static u8 quantizeDithered(i32 drive, u8 threshold) FL_NO_EXCEPT;

    bool temporalDitherEnabled() const FL_NO_EXCEPT;
 
#if !FL_PLATFORM_HAS_TINY_MEMORY
    static u16 quantize16(i32 drive) FL_NO_EXCEPT;
#endif
 
    PixelController<RGB>& mController;
#if FL_COLOR_PIPELINE_SHARED
    StreamingPipelineQ16 mPipeline;
#else
    StreamingPipelineQ16& mPipeline;
#endif
    int mSlot0;
    int mSlot1;
    int mSlot2;
    u8 mDitherPhase;
};
 
}  // namespace fl