wave8Untranspose_8()

void fl::wave8Untranspose_8	(	const u8(&)	transposed[8 *sizeof(Wave8Byte)],
		u8(&)	output[8 *sizeof(Wave8Byte)] )

Definition at line 418 of file wave8.cpp.hpp.

                                                                               {
    // Reverse the 8-lane transposition
    // Input: 64 bytes of interleaved data (8 bytes per symbol, 8 symbols)
    // Output: 8 Wave8Byte structures (64 bytes total, de-interleaved)
 
    Wave8Byte lane_waves[8];
 
    // Process each of the 8 symbols
    for (int symbol_idx = 0; symbol_idx < 8; symbol_idx++) {
        u8 lane_bytes[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 
        // Process 8 input bytes (1 pulse per byte)
        // After transpose+reversal: byte 0 = bit 7 (first pulse, MSB),
        // byte 7 = bit 0 (last pulse, LSB)
        for (int byte_idx = 0; byte_idx < 8; byte_idx++) {
            u8 input_byte = transposed[symbol_idx * 8 + byte_idx];
 
            // Calculate which pulse bit this corresponds to
            // byte 0 = bit 7, byte 7 = bit 0 (reversed order)
            int pulse_bit = 7 - byte_idx;
 
            // De-interleave 8 lanes from this byte
            // Bit layout: [L7, L6, L5, L4, L3, L2, L1, L0]
            for (int lane = 0; lane < 8; lane++) {
                // Extract bit for this lane (lane 0 = LSB, lane 7 = MSB)
                u8 pulse = (input_byte >> lane) & 1;
 
                // Reconstruct lane byte
                lane_bytes[lane] |= (pulse << pulse_bit);
            }
        }
 
        // Store de-interleaved bytes
        for (int lane = 0; lane < 8; lane++) {
            lane_waves[lane].symbols[symbol_idx].data = lane_bytes[lane];
        }
    }
 
    // Copy de-interleaved data to output
    for (int lane = 0; lane < 8; lane++) {
        fl::isr::memcpy(output + lane * sizeof(Wave8Byte), &lane_waves[lane], sizeof(Wave8Byte));
    }
}

References FL_RESTRICT_PARAM, and fl::isr::memcpy().

Here is the call graph for this function: