Function wave8Untranspose_16

src/fl/channels/wave8.cpp.hpp:463–506

}

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

    Wave8Byte lane_waves[16];

    // Process each of the 8 symbols
    for (int symbol_idx = 0; symbol_idx < 8; symbol_idx++) {
        u8 lane_bytes[16] = {0};

        // Process 8 pulses (16 bytes total: 2 bytes per pulse)
        for (int pulse_idx = 0; pulse_idx < 8; pulse_idx++) {
            int pulse_bit = 7 - pulse_idx;

            // Read 16-bit word for this pulse
            int input_offset = symbol_idx * 16 + pulse_idx * 2;
            u16 input_word = (u16)transposed[input_offset] |
                                  ((u16)transposed[input_offset + 1] << 8);

            // De-interleave 16 lanes from this word
            // Bit layout: [L15, L14, L13, ..., L1, L0]
            for (int lane = 0; lane < 16; lane++) {
                // Extract bit for this lane (lane 0 = LSB, lane 15 = MSB)
                u8 pulse = (input_word >> lane) & 1;

                // Reconstruct lane byte
                lane_bytes[lane] |= (pulse << pulse_bit);
            }
        }

        // Store de-interleaved bytes
        for (int lane = 0; lane < 16; lane++) {
            lane_waves[lane].symbols[symbol_idx].data = lane_bytes[lane];
        }
    }

    // Copy de-interleaved data to output
    for (int lane = 0; lane < 16; lane++) {
        fl::isr::memcpy(output + lane * sizeof(Wave8Byte), &lane_waves[lane], sizeof(Wave8Byte));
    }
}

} // namespace fl