transpose16()

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

static

Transpose 16 lanes of data into interleaved hex-SPI format.

Parameters

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

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

                                                                 {
    // Validate output buffer size (must be divisible by 16)
    if (output.size() % 16 != 0) {
        if (error) {
            *error = "Output buffer size must be divisible by 16";
        }
        return false;
    }
 
    // Calculate max lane size from output buffer
    const size_t max_size = output.size() / 16;
 
    // 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 < 16; 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[16];
    const u8* lane_ptrs[16];
 
    for (size_t lane = 0; lane < 16; 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_16lane_inline(lane_ptrs, output.data(), max_size);
 
    if (error) {
        *error = nullptr;  // Success, no error
    }
    return true;
}

References fl::vector< T >::data(), fl::FL_NO_EXCEPT, getLaneByte(), fl::vector< T >::resize(), and fl::transpose_16lane_inline().

Here is the call graph for this function: