transpose8()

bool fl::SPITransposer::transpose8 ( const fl::optional< LaneData > lanes[8], fl::span< u8 > output, const char ** error = nullptr )

static

Transpose 8 lanes of data into interleaved octal-SPI format.

Parameters

lanes	Array of 8 lane data (use fl::nullopt for unused lanes)
output	Output buffer to write interleaved data (size must be divisible by 8)
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() / 8

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 180 of file transposition.cpp.hpp.

                                                    {
    // Validate output buffer size (must be divisible by 8)
    if (output.size() % 8 != 0) {
        if (error) {
            *error = "Output buffer size must be divisible by 8";
        }
        return false;
    }
 
    // Calculate max lane size from output buffer
    const size_t max_size = output.size() / 8;
 
    // Handle empty case
    if (max_size == 0) {
        if (error) {
            *error = nullptr;  // No error, just empty
        }
        return true;
    }
 
    // Determine default padding byte from first available lane
    u8 default_padding = 0x00;
    for (size_t i = 0; i < 8; 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[8];
    const u8* lane_ptrs[8];
 
    for (size_t lane = 0; lane < 8; 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_8lane_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_8lane_inline().

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

Here is the call graph for this function:

Here is the caller graph for this function: