render.hpp

Go to the documentation of this file.

// sbl/dsp/host/render.hpp — Writing a render to disk (Cross-cutting — host only)
//
// The two writers every host tool and golden test copied (RPT-035 Part 4):
// a 24-bit WAV and a raw float32 file in the layout analyst reads. File
// I/O; never included from audio code.
 
#ifndef SBL_DSP_HOST_RENDER_HPP_
#define SBL_DSP_HOST_RENDER_HPP_
 
#include <cstdint>
#include <cstdio>
 
namespace sbl::dsp::host {
 
/// Interleaved float samples to a 24-bit PCM WAV, clamped to ±1.
inline bool write_wav(const char* path, const float* data, int samples, int sample_rate, int channels) {
    FILE* f = fopen(path, "wb");
    if (!f) return false;
 
    const int bytes_per_sample = 3;
    const int data_size = samples * channels * bytes_per_sample;
    const int fmt_chunk_size = 16;
 
    fwrite("RIFF", 1, 4, f);
    const uint32_t file_size = 36 + static_cast<uint32_t>(data_size);
    fwrite(&file_size, 4, 1, f);
    fwrite("WAVE", 1, 4, f);
 
    fwrite("fmt ", 1, 4, f);
    fwrite(&fmt_chunk_size, 4, 1, f);
    const uint16_t audio_format = 1;   // PCM
    fwrite(&audio_format, 2, 1, f);
    const uint16_t num_channels = static_cast<uint16_t>(channels);
    fwrite(&num_channels, 2, 1, f);
    const uint32_t sr = static_cast<uint32_t>(sample_rate);
    fwrite(&sr, 4, 1, f);
    const uint32_t byte_rate = sr * num_channels * bytes_per_sample;
    fwrite(&byte_rate, 4, 1, f);
    const uint16_t block_align = static_cast<uint16_t>(num_channels * bytes_per_sample);
    fwrite(&block_align, 2, 1, f);
    const uint16_t bits_per_sample = 24;
    fwrite(&bits_per_sample, 2, 1, f);
 
    fwrite("data", 1, 4, f);
    const uint32_t ds = static_cast<uint32_t>(data_size);
    fwrite(&ds, 4, 1, f);
 
    constexpr float SCALE = 8388607.0f;
    for (int i = 0; i < samples * channels; ++i) {
        float clamped = data[i];
        if (clamped > 1.0f) clamped = 1.0f;
        if (clamped < -1.0f) clamped = -1.0f;
        const int32_t s = static_cast<int32_t>(clamped * SCALE);
        const uint8_t bytes[3] = {
            static_cast<uint8_t>(s & 0xFF),
            static_cast<uint8_t>((s >> 8) & 0xFF),
            static_cast<uint8_t>((s >> 16) & 0xFF),
        };
        fwrite(bytes, 1, 3, f);
    }
 
    fclose(f);
    return true;
}
 
/// Raw float32, native endianness: what `analyst measure` reads.
inline bool write_float_bin(const char* path, const float* data, int samples) {
    FILE* f = fopen(path, "wb");
    if (!f) return false;
    fwrite(data, sizeof(float), static_cast<size_t>(samples), f);
    fclose(f);
    return true;
}
 
} // namespace sbl::dsp::host
 
#endif // SBL_DSP_HOST_RENDER_HPP_