Function wave8Untranspose_2

src/fl/channels/wave8.cpp.hpp:330–369

// ============================================================================

FL_OPTIMIZE_FUNCTION
void wave8Untranspose_2(const u8 (&FL_RESTRICT_PARAM transposed)[2 * sizeof(Wave8Byte)],
                        u8 (&FL_RESTRICT_PARAM output)[2 * sizeof(Wave8Byte)]) {
    // Reverse the 2-lane transposition
    // Input: 16 bytes of interleaved data (2 bytes per symbol, 8 symbols)
    // Output: 2 Wave8Byte structures (16 bytes total, de-interleaved)

    Wave8Byte lane_waves[2];

    // Process each of the 8 symbols
    for (int symbol_idx = 0; symbol_idx < 8; symbol_idx++) {
        // Read the 2 interleaved bytes for this symbol
        u16 interleaved = ((u16)transposed[symbol_idx * 2] << 8) |
                               transposed[symbol_idx * 2 + 1];

        // De-interleave bits back to lanes
        u8 lane0_bits = 0;
        u8 lane1_bits = 0;

        // Extract bits: interleaved format has alternating bits [L0, L1, L0, L1, ...]
        // Bits are ordered: [L1_b7, L0_b7, L1_b6, L0_b6, L1_b5, L0_b5, L1_b4, L0_b4, ...]
        for (int bit = 0; bit < 8; bit++) {
            // Lane 0 bits are at odd positions (shifted left by 1)
            if (interleaved & (1 << (bit * 2 + 1))) {
                lane0_bits |= (1 << bit);
            }
            // Lane 1 bits are at even positions
            if (interleaved & (1 << (bit * 2))) {
                lane1_bits |= (1 << bit);
            }
        }

        lane_waves[0].symbols[symbol_idx].data = lane0_bits;
        lane_waves[1].symbols[symbol_idx].data = lane1_bits;
    }

    // Copy de-interleaved data to output
    fl::isr::memcpy(output, &lane_waves[0], sizeof(Wave8Byte));
    fl::isr::memcpy(output + sizeof(Wave8Byte), &lane_waves[1], sizeof(Wave8Byte));
}

FL_OPTIMIZE_FUNCTION
void wave8Untranspose_4(const u8 (&FL_RESTRICT_PARAM transposed)[4 * sizeof(Wave8Byte)],