data.h

Go to the documentation of this file.

 
#pragma once
 
#include "fl/stl/noexcept.h"
#include "fl/stl/atomic.h"
 
#include "fl/stl/vector.h"
#include "fl/stl/stdint.h"
#include "fl/stl/shared_ptr.h"
#include "fl/stl/function.h"
#include "fl/stl/span.h"
#include "fl/channels/config.h"
 
namespace fl {
 
class ChannelData;
FASTLED_SHARED_PTR(ChannelData);

enum class ChannelPixelFormat : u8 {
    Unknown = 0,
    RGB = 3,
    RGBW = 4,
    RGBWW = 5,
};
 
inline u8 channelPixelFormatBytesPerPixel(ChannelPixelFormat format) FL_NO_EXCEPT {
    return static_cast<u8>(format);
}

using PaddingGenerator = fl::function<void(fl::span<const u8> src, fl::span<u8> dst)>;

class ChannelData {
public:
    static ChannelDataPtr create(
        const ChipsetVariant& chipset,
        fl::vector_psram<u8>&& encodedData = fl::vector_psram<u8>(),
        ChannelPixelFormat pixelFormat = ChannelPixelFormat::RGB
    ) FL_NO_EXCEPT;

    static ChannelDataPtr create(
        int pin,
        const ChipsetTimingConfig& timing,
        fl::vector_psram<u8>&& encodedData = fl::vector_psram<u8>(),
        ChannelPixelFormat pixelFormat = ChannelPixelFormat::RGB
    ) FL_NO_EXCEPT;

    int getPin() const FL_NO_EXCEPT;

    const ChipsetVariant& getChipset() const FL_NO_EXCEPT { return mChipset; }

    bool isClockless() const FL_NO_EXCEPT { return mChipset.is<ClocklessChipset>(); }

    bool isSpi() const FL_NO_EXCEPT { return mChipset.is<SpiChipsetConfig>(); }

    const ChipsetTimingConfig& getTiming() const FL_NO_EXCEPT;

    const fl::vector_psram<u8>& getData() const FL_NO_EXCEPT { return mEncodedData; }

    fl::vector_psram<u8>& getData() FL_NO_EXCEPT { return mEncodedData; }

    ChannelPixelFormat getPixelFormat() const FL_NO_EXCEPT { return mPixelFormat; }

    void setPixelFormat(ChannelPixelFormat pixelFormat) FL_NO_EXCEPT {
        mPixelFormat = pixelFormat;
    }

    u8 getExtraZeroBitsPerByte() const FL_NO_EXCEPT { return mExtraZeroBits; }

    void setExtraZeroBitsPerByte(u8 bits) FL_NO_EXCEPT { mExtraZeroBits = bits; }

    u8 getBytesPerPixel() const FL_NO_EXCEPT {
        return channelPixelFormatBytesPerPixel(mPixelFormat);
    }

    size_t getSize() const FL_NO_EXCEPT { return mEncodedData.size(); }

    bool isInUse() const FL_NO_EXCEPT { return mInUse.load(fl::memory_order_acquire); }

    void setInUse(bool inUse) FL_NO_EXCEPT { mInUse.store(inUse, fl::memory_order_release); }

    void setPaddingGenerator(PaddingGenerator generator) FL_NO_EXCEPT {
        mPaddingGenerator = fl::move(generator);
    }

    void writeWithPadding(fl::span<u8> dst) FL_NO_EXCEPT;

    size_t getMinimumSize() const FL_NO_EXCEPT { return mEncodedData.size(); }

    ~ChannelData();
 
private:
    template<typename T, typename... Args>
    friend fl::shared_ptr<T> fl::adl_barrier::make_shared(Args&&... args) FL_NO_EXCEPT;  // see fl/stl/adl_barrier.h

    ChannelData(
        const ChipsetVariant& chipset,
        fl::vector_psram<u8>&& encodedData,
        ChannelPixelFormat pixelFormat
    ) FL_NO_EXCEPT;

    ChannelData(
        int pin,
        const ChipsetTimingConfig& timing,
        fl::vector_psram<u8>&& encodedData,
        ChannelPixelFormat pixelFormat
    ) FL_NO_EXCEPT;
 
    // Non-copyable (move-only via shared_ptr)
    ChannelData(const ChannelData&) FL_NO_EXCEPT = delete;
    ChannelData& operator=(const ChannelData&) FL_NO_EXCEPT = delete;
 
    ChipsetVariant mChipset;                
    ChannelPixelFormat mPixelFormat;        
    PaddingGenerator mPaddingGenerator;     
    fl::vector_psram<u8> mEncodedData; 
    u8 mExtraZeroBits = 0;                  
    fl::atomic_bool mInUse{false};           
};
 
}  // namespace fl