stretch_preset.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/signal/offline_stretch.hpp>
 
#include <sstream>
#include <string>
 
namespace pulp::signal {

struct StretchPreset {
    std::string name = "untitled";
    StretchCharacter character = StretchCharacter::clean;
    int fft_size = 0;                  
    int analysis_hop = 0;
    float transient_sensitivity = 0.0f;
    bool route_noise_stn = false;
    bool relocate_transients = false;
};
 
inline const char* to_string(StretchCharacter c) {
    switch (c) {
        case StretchCharacter::varispeed:     return "varispeed";
        case StretchCharacter::phase_vocoder: return "phase_vocoder";
        case StretchCharacter::granular:      return "granular";
        case StretchCharacter::clean:         default: return "clean";
    }
}
 
inline bool character_from_string(const std::string& s, StretchCharacter& out) {
    if (s == "clean")         { out = StretchCharacter::clean; return true; }
    if (s == "varispeed")     { out = StretchCharacter::varispeed; return true; }
    if (s == "phase_vocoder") { out = StretchCharacter::phase_vocoder; return true; }
    if (s == "granular")      { out = StretchCharacter::granular; return true; }
    return false;
}

inline StretchPreset capture_preset(const OfflineStretchOptions& o,
                                    const std::string& name = "untitled") {
    StretchPreset p;
    p.name = name;
    p.character = o.character;
    p.fft_size = o.fft_size;
    p.analysis_hop = o.analysis_hop;
    p.transient_sensitivity = o.transient_sensitivity;
    p.route_noise_stn = o.route_noise_stn;
    p.relocate_transients = o.relocate_transients;
    return p;
}

inline void apply_preset(OfflineStretchOptions& o, const StretchPreset& p) {
    o.character = p.character;
    o.fft_size = p.fft_size;
    o.analysis_hop = p.analysis_hop;
    o.transient_sensitivity = p.transient_sensitivity;
    o.route_noise_stn = p.route_noise_stn;
    o.relocate_transients = p.relocate_transients;
}
 
inline std::string preset_to_text(const StretchPreset& p) {
    std::ostringstream s;
    s << "# Pulp stretch preset\n"
      << "name = " << p.name << "\n"
      << "character = " << to_string(p.character) << "\n"
      << "fft_size = " << p.fft_size << "\n"
      << "analysis_hop = " << p.analysis_hop << "\n"
      << "transient_sensitivity = " << p.transient_sensitivity << "\n"
      << "route_noise_stn = " << (p.route_noise_stn ? "true" : "false") << "\n"
      << "relocate_transients = " << (p.relocate_transients ? "true" : "false") << "\n";
    return s.str();
}

inline bool preset_from_text(const std::string& text, StretchPreset& out,
                             std::string* err = nullptr) {
    auto trim = [](std::string v) {
        const auto a = v.find_first_not_of(" \t\r\n");
        const auto b = v.find_last_not_of(" \t\r\n");
        return a == std::string::npos ? std::string() : v.substr(a, b - a + 1);
    };
    auto as_bool = [](const std::string& v) { return v == "true" || v == "1" || v == "yes"; };
    std::istringstream in(text);
    std::string line;
    while (std::getline(in, line)) {
        const std::string t = trim(line);
        if (t.empty() || t[0] == '#') continue;
        const auto eq = t.find('=');
        if (eq == std::string::npos) continue;
        const std::string key = trim(t.substr(0, eq));
        const std::string val = trim(t.substr(eq + 1));
        if (key == "name") out.name = val;
        else if (key == "character") {
            if (!character_from_string(val, out.character)) {
                if (err) *err = "unknown character: " + val;
                return false;
            }
        }
        else if (key == "fft_size") out.fft_size = std::atoi(val.c_str());
        else if (key == "analysis_hop") out.analysis_hop = std::atoi(val.c_str());
        else if (key == "transient_sensitivity") out.transient_sensitivity = static_cast<float>(std::atof(val.c_str()));
        else if (key == "route_noise_stn") out.route_noise_stn = as_bool(val);
        else if (key == "relocate_transients") out.relocate_transients = as_bool(val);
        // unknown keys ignored (forward-compatible)
    }
    return true;
}
 
} // namespace pulp::signal