transpose4()

bool fl::SPITransposer::transpose4 ( const fl::optional< LaneData > & lane0, const fl::optional< LaneData > & lane1, const fl::optional< LaneData > & lane2, const fl::optional< LaneData > & lane3, fl::span< u8 > output, const char ** error = nullptr )

static

Transpose 4 lanes of data into interleaved quad-SPI format.

Parameters

lane0	Lane 0 data (use fl::nullopt for unused lane)
lane1	Lane 1 data (use fl::nullopt for unused lane)
lane2	Lane 2 data (use fl::nullopt for unused lane)
lane3	Lane 3 data (use fl::nullopt for unused lane)
output	Output buffer to write interleaved data (size must be divisible by 4)
error	Optional pointer to receive error message (set to nullptr if unused)

Returns

true on success, false if output buffer size is invalid

Note

Output buffer size determines max lane size: max_size = output.size() / 4

Shorter lanes are padded at the beginning with repeating padding_frame pattern

Empty lanes (nullopt) are filled with zeros or first lane's padding

Examples

/home/runner/work/FastLED/FastLED/src/fl/math/transposition.h.

Definition at line 114 of file transposition.cpp.hpp.

                                                    {
    // Validate output buffer size (must be divisible by 4)
    if (output.size() % 4 != 0) {
        if (error) {
            *error = "Output buffer size must be divisible by 4";
        }
        return false;
    }
 
    // Calculate max lane size from output buffer
    const size_t max_size = output.size() / 4;
 
    // Handle empty case
    if (max_size == 0) {
        if (error) {
            *error = nullptr;  // No error, just empty
        }
        return true;
    }
 
    // Create array of lane references for easier iteration
    const fl::optional<LaneData>* lanes[4] = {&lane0, &lane1, &lane2, &lane3};
 
    // Determine default padding byte from first available lane
    u8 default_padding = 0x00;
    for (size_t i = 0; i < 4; i++) {
        if (lanes[i]->has_value() && !(*lanes[i])->padding_frame.empty()) {
            default_padding = (*lanes[i])->padding_frame[0];
            break;
        }
    }
 
    // Gather all bytes from each lane into temporary buffers
    fl::vector<u8> lane_buffers[4];
    const u8* lane_ptrs[4];
 
    for (size_t lane = 0; lane < 4; lane++) {
        lane_buffers[lane].resize(max_size);
        lane_ptrs[lane] = lane_buffers[lane].data();
 
        for (size_t byte_idx = 0; byte_idx < max_size; byte_idx++) {
            lane_buffers[lane][byte_idx] = lanes[lane]->has_value() ?
                getLaneByte(**lanes[lane], byte_idx, max_size) : default_padding;
        }
    }
 
    // Perform transposition using ISR-safe primitive
    transpose_4lane_inline(lane_ptrs, output.data(), max_size);
 
    if (error) {
        *error = nullptr;  // Success, no error
    }
    return true;
}

References fl::vector< T >::data(), fl::Optional< T >::empty(), getLaneByte(), fl::Optional< T >::has_value(), fl::vector< T >::resize(), and fl::transpose_4lane_inline().

Referenced by fl::spi::MultiLaneDevice::flush().

Here is the call graph for this function:

Here is the caller graph for this function: