encodeFrame()

void fl::Channel::encodeFrame ( PixelController< RGB, 1, 0xFFFFFFFF > & pixels )

private

Encode pixels into mChannelData and fire onChannelDataEncoded (#4566).

Definition at line 934 of file channel.cpp.hpp.

                                                                                  {
    // Build pixel iterator with optional addressing transformation
    // (#2558) Pass both Rgbw and Rgbww from the current rendering settings; the iterator
    // carries both, and the encoder dispatch below picks the right path based
    // on which white-channel variant the controller currently holds.
#if FL_COLOR_PROFILE_RUNTIME
    // Brightness reaches the pipeline as C4's flux scalar and nowhere else.
    // `premixed` is the brightness on this path: binding a profile sets
    // correction and temperature to identity, so nothing else is folded into
    // it -- and reading it rather than `ColorAdjustment::brightness` keeps
    // this working when FASTLED_HD_COLOR_MIXING is off, where that field
    // does not exist.
    //
    // The shared pipeline is never written after it is built (#4440): this
    // managed iterator takes a reference, copies it, and sets flux on the copy, so a
    // concurrent reader -- the power estimate copies the same pipeline --
    // never sees a half-written flux, and a reconfiguration replaces
    // `mPipeline` without touching what this frame encodes through. Small
    // tiers encode synchronously and keep single ownership, mutated in place.
#if FL_COLOR_PIPELINE_SHARED
    const ColorPipelineStorage pipeline_ref = mPipeline;
    const StreamingPipelineQ16* pipeline = pipeline_ref.get();
#else
    StreamingPipelineQ16* pipeline = mPipeline.get();
#endif
#else
    StreamingPipelineQ16* pipeline = nullptr;
#endif
    // Dither advances on presentation, not on attempt (#4347, R8): this
    // channel's phase moves only when its driver accepts a frame (submitFrame()), so
    // a dropped submission -- no driver, a disabled one, a busy buffer --
    // does not consume a phase and the cycle's average stays unbiased. Both
    // the legacy offsets and the colour-managed temporal dither read it.
    if (pixels.ditherActive()) {
        pixels.reseed_binary_dithering(mDitherPhase);
    }
#ifdef FL_IS_AVR
    // AVR omits base settings notifications, so base setters are authoritative.
    const auto& whiteSettings = mLegacySettings;
#else
    const auto& whiteSettings = mSettings;
#endif
    ReorderingPixelIteratorAny iterator(pixels, mScreenMap.getXYMap(), mRgbOrder,
                                        whiteSettings.rgbw(), whiteSettings.rgbww(),
                                        mName, pipeline, mDitherPhase,
                                        pixels.mColorAdjustment.premixed.r);
    PixelIterator& pixelIterator = iterator.get();
 
    // Encode pixels with the writer selected once from the immutable chipset.
    auto& data = mChannelData->getData();
    data.clear();
    const auto* rgbww = whiteSettings.mWhiteCfg.ptr<Rgbww>();
    const auto* rgbw = whiteSettings.mWhiteCfg.ptr<Rgbw>();
    if (rgbww != nullptr && rgbww->active()) {
        mChannelData->setPixelFormat(ChannelPixelFormat::RGBWW);
    } else if (rgbw != nullptr && rgbw->active()) {
        mChannelData->setPixelFormat(ChannelPixelFormat::RGBW);
    } else {
        mChannelData->setPixelFormat(ChannelPixelFormat::RGB);
    }
 
    if (mPixelEncoder != nullptr) {
        mPixelEncoder(*this, pixelIterator, iterator.isManaged(), data);
    }
 
    // Fire event after encoding completes
    {
        auto& events = ChannelEvents::instance();
        events.onChannelDataEncoded(*this, *mChannelData);
    }
}

References fl::FL_NO_EXCEPT, fl::ChannelEvents::instance(), mChannelData, mDitherPhase, fl::CLEDController::mLegacySettings, mName, mPixelEncoder, mRgbOrder, mScreenMap, mSettings, fl::RGB, fl::RGBW, rgbw, and fl::RGBWW.

Referenced by showPixels().

Here is the call graph for this function:

Here is the caller graph for this function: