Method transpose2

src/fl/math/transposition.cpp.hpp:43–106

}

FL_DISABLE_WARNING_POP

// ============================================================================
// SPI Multi-Lane Transposer Implementation
// ============================================================================

// ----------------------------------------------------------------------------
// 2-Way Transpose (Dual-SPI)
// ----------------------------------------------------------------------------

bool SPITransposer::transpose2(const fl::optional<LaneData>& lane0,
                                const fl::optional<LaneData>& lane1,
                                fl::span<u8> output,
                                const char** error) {
    // Validate output buffer size (must be divisible by 2)
    if (output.size() % 2 != 0) {
        if (error) {
            *error = "Output buffer size must be divisible by 2";
        }
        return false;
    }

    // Calculate max lane size from output buffer
    const size_t max_size = output.size() / 2;

    // 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[2] = {&lane0, &lane1};

    // Determine default padding byte from first available lane
    u8 default_padding = 0x00;
    for (size_t i = 0; i < 2; 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> lane0_buffer(max_size);
    fl::vector<u8> lane1_buffer(max_size);

    for (size_t byte_idx = 0; byte_idx < max_size; byte_idx++) {
        lane0_buffer[byte_idx] = lanes[0]->has_value() ?
            getLaneByte(**lanes[0], byte_idx, max_size) : default_padding;
        lane1_buffer[byte_idx] = lanes[1]->has_value() ?
            getLaneByte(**lanes[1], byte_idx, max_size) : default_padding;
    }

    // Perform transposition using ISR-safe primitive
    transpose_2lane_inline(lane0_buffer.data(), lane1_buffer.data(), output.data(), max_size);