lessampler: ConfigUnit 模块 - 配置系统的设计

class lessConfigure {
public:
    std::string get_version();  // 获取校验版本号

public:
    // F0 估计算法选择
    enum class F0_MODE {
        F0_MODE_UNKNOWN = 0,
        F0_MODE_HARVEST = 1,  // 高精度，慢
        F0_MODE_DIO = 2,      // 快速，中等精度
    };

    // 配置参数
    std::string version;
    bool debug_mode = false;
    double model_amp = 0.85;                      // AutoAMP 强度
    double audio_model_frame_period = (1000.0 * 256 / 44100);  // 帧周期
    bool custom_fft_size = false;                 // 是否自定义 FFT
    int fft_size = 1024;                          // FFT 大小
    F0_MODE f0_mode = F0_MODE::F0_MODE_HARVEST;  // F0 算法
    int f0_speed = 1;                             // DIO 速度系数
    double f0_dio_floor = 40.0;                   // DIO F0 下限
    double f0_harvest_floor = 40.0;               // Harvest F0 下限
    double f0_cheap_trick_floor = 71.0;           // CheapTrick F0 下限
    double f0_allow_range = 0.1;                  // DIO 允许范围
    double ap_threshold = 0.10;                   // D4C 阈值

public:
    static std::string get_f0_mode_str(F0_MODE f0_mode);

private:
    std::string version_data;
    void make_ver();  // 生成版本校验码
};

void lessConfigure::make_ver() {
    // 将所有关键参数拼接为字符串
    version_data = std::to_string(audio_model_frame_period)
                   + std::to_string(fft_size)
                   + std::to_string(model_amp)
                   + std::to_string(f0_speed)
                   + std::to_string(f0_dio_floor)
                   + std::to_string(f0_harvest_floor)
                   + std::to_string(f0_cheap_trick_floor)
                   + std::to_string(f0_allow_range)
                   + std::to_string(ap_threshold)
                   + get_f0_mode_str(f0_mode);

    // 使用 SHA-1 生成校验码
    SHA1 checksum;
    checksum.update(version_data);
    version_data = checksum.final();  // 返回 40 字符十六进制字符串
}

class SHA1 {
public:
    SHA1();

    void update(const std::string &s);  // 添加数据
    void update(std::istream &is);      // 从流添加
    std::string final();                // 完成并返回哈希

    static std::string from_file(const std::string &filename);  // 文件哈希

private:
    uint32_t digest[5]{};      // 5 个 32 位哈希值（共 160 位）
    std::string buffer;        // 输入缓冲区
    uint64_t transforms{};     // 变换次数
};

void transform(uint32_t digest[], uint32_t block[16], uint64_t &transforms) {
    // 复制当前哈希值到工作变量
    uint32_t a = digest[0];
    uint32_t b = digest[1];
    uint32_t c = digest[2];
    uint32_t d = digest[3];
    uint32_t e = digest[4];

    // 80 轮变换（分为 4 组，每组 20 轮）
    // R0: 轮 0-15（使用原始数据）
    // R1: 轮 16-19（使用扩展数据）
    // R2: 轮 20-39
    // R3: 轮 40-59
    // R4: 轮 60-79

    // ... 80 轮处理 ...

    // 更新哈希值
    digest[0] += a;
    digest[1] += b;
    digest[2] += c;
    digest[3] += d;
    digest[4] += e;

    transforms++;
}

std::string SHA1::final() {
    // 计算总位数
    uint64_t total_bits = (transforms * 64 + buffer.size()) * 8;

    // 填充：添加 0x80，然后补零
    buffer += (char) 0x80;
    while (buffer.size() < 64) {
        buffer += (char) 0x00;
    }

    // 处理填充块
    uint32_t block[16];
    buffer_to_block(buffer, block);

    // 如果填充超出一个块，处理两个块
    if (orig_size > 64 - 8) {
        transform(digest, block, transforms);
        for (size_t i = 0; i < 16 - 2; i++) {
            block[i] = 0;
        }
    }

    // 在最后 8 字节存储总位数
    block[16 - 1] = (uint32_t) total_bits;
    block[16 - 2] = (uint32_t) (total_bits >> 32);
    transform(digest, block, transforms);

    // 输出十六进制字符串
    std::ostringstream result;
    for (unsigned int i: digest) {
        result << std::hex << std::setfill('0') << std::setw(8);
        result << i;
    }

    return result.str();  // 40 字符十六进制
}

class ConfigUnit {
public:
    explicit ConfigUnit(const std::filesystem::path &exec_path);

    void SetConfig(const std::filesystem::path &exec_path);
    ~ConfigUnit();

    lessConfigure GetConfig() const;

private:
    std::filesystem::path config_file_path;
    std::string config_file_data_string;
    inicpp::config config;
    inicpp::schema config_schema;
    lessConfigure configure;

private:
    void make_schema();           // 创建配置结构
    void create_default_config(); // 生成默认配置
    void parse_config();          // 解析配置文件
};

void ConfigUnit::SetConfig(const std::filesystem::path &exec_path) {
    // 构建配置文件路径
    this->config_file_path = exec_path / CONFIGFILENAME;  // "lessconfig.ini"

    // 创建配置结构（定义有效参数）
    make_schema();

    // 检查配置文件是否存在
    if (std::filesystem::exists(config_file_path)) {
        // 存在：读取并解析
        config_file_data_string = ConfigFileIO::read_config_file(config_file_path);
        parse_config();
    } else {
        // 不存在：生成默认配置
        create_default_config();
        ConfigFileIO::save_config_file(config_file_path, config_file_data_string);
        parse_config();
    }
}

void ConfigUnit::make_schema() {
    // [config] 全局设置部分
    inicpp::section_schema_params section_config_params{};
    section_config_params.name = "config";
    section_config_params.comment = "\n============ Gobal Settings ===========\n";
    section_config_params.requirement = inicpp::item_requirement::mandatory;
    config_schema.add_section(section_config_params);

    // version: 软件版本号
    inicpp::option_schema_params<inicpp::string_ini_t> version{};
    version.name = "version";
    version.default_value = PROJECT_GIT_HASH;
    config_schema.add_option("config", version);

    // debug: 调试模式开关
    inicpp::option_schema_params<inicpp::boolean_ini_t> debug{};
    debug.name = "debug";
    debug.default_value = "0";
    config_schema.add_option("config", debug);

    // [audio_model] 音频模型部分
    inicpp::section_schema_params section_audio_model_params{};
    section_audio_model_params.name = "audio_model";
    section_audio_model_params.comment = 
        "\n========= Audio Model Settings ========\n"
        "Note: modifying any of the parameters here will require remodeling the voice db\n";
    config_schema.add_section(section_audio_model_params);

    // frame_period: 帧周期
    inicpp::option_schema_params<inicpp::float_ini_t> frame_period{};
    frame_period.name = "frame_period";
    frame_period.default_value = std::to_string(configure.audio_model_frame_period);
    config_schema.add_option("audio_model", frame_period);

    // fft_size: FFT 大小（支持 "auto" 或数值）
    inicpp::option_schema_params<inicpp::float_ini_t> fft_size{};
    fft_size.name = "fft_size";
    fft_size.default_value = "auto";
    config_schema.add_option("audio_model", fft_size);

    // model_amp: AutoAMP 强度
    inicpp::option_schema_params<inicpp::float_ini_t> model_amp{};
    model_amp.name = "model_amp";
    model_amp.default_value = std::to_string(configure.model_amp);
    model_amp.comment = "Apply AutoAMP before Modeling...";
    config_schema.add_option("audio_model", model_amp);

    // [f0] F0 估计部分
    // ... 类似结构定义 f0_mode, f0_speed, f0_floor 等参数

    // [ap] 非周期性部分
    // ... 定义 ap_threshold 参数
}

void ConfigUnit::parse_config() {
    // 使用 inicpp 解析 INI 文件
    config = inicpp::parser::load(config_file_data_string);

    // 解析 [config] 部分
    auto config_section = config["config"];
    configure.version = config_section["version"].get<inicpp::string_ini_t>();
    if (configure.version != PROJECT_GIT_HASH) {
        YALL_WARN_ << "Configure file version does not match software version.";
    }
    configure.debug_mode = config_section["debug"].get<inicpp::boolean_ini_t>();

    // 解析 [audio_model] 部分
    auto audio_model_section = config["audio_model"];
    configure.audio_model_frame_period = 
        audio_model_section["frame_period"].get<inicpp::float_ini_t>();
    configure.model_amp = 
        audio_model_section["model_amp"].get<inicpp::float_ini_t>();

    // FFT 大小：特殊处理 "auto" 字符串
    if (audio_model_section["fft_size"].get<inicpp::string_ini_t>() == "auto") {
        configure.fft_size = 0;
        configure.custom_fft_size = false;
    } else {
        std::stringstream ss;
        ss << audio_model_section["fft_size"].get<inicpp::string_ini_t>();
        ss >> configure.fft_size;
        configure.custom_fft_size = true;
    }

    // 解析 [f0] 部分
    auto f0_section = config["f0"];
    
    // F0 算法：字符串转枚举
    configure.f0_mode = [&]() -> lessConfigure::F0_MODE {
        auto f0_mode = f0_section["f0_mode"].get<inicpp::string_ini_t>();
        std::transform(f0_mode.begin(), f0_mode.end(), f0_mode.begin(), ::toupper);
        if (f0_mode == "DIO")
            return lessConfigure::F0_MODE::F0_MODE_DIO;
        else if (f0_mode == "HARVEST")
            return lessConfigure::F0_MODE::F0_MODE_HARVEST;
        else
            return lessConfigure::F0_MODE::F0_MODE_UNKNOWN;
    }();

    configure.f0_speed = static_cast<int>(f0_section["f0_speed"].get<inicpp::signed_ini_t>());
    configure.f0_dio_floor = f0_section["f0_dio_floor"].get<inicpp::float_ini_t>();
    configure.f0_harvest_floor = f0_section["f0_harvest_floor"].get<inicpp::float_ini_t>();
    configure.f0_cheap_trick_floor = f0_section["f0_cheap_trick_floor"].get<inicpp::float_ini_t>();
    configure.f0_allow_range = f0_section["f0_allow_range"].get<inicpp::float_ini_t>();

    // 解析 [ap] 部分
    auto ap_section = config["ap"];
    configure.ap_threshold = ap_section["ap_threshold"].get<inicpp::float_ini_t>();
}

class ConfigVoiceBank {
public:
    ConfigVoiceBank(std::filesystem::path _voice_path, lessConfigure _configure);
    explicit ConfigVoiceBank(lessConfigure _configure);

    void SetVoiceConfig();

private:
    lessConfigure configure;
    std::filesystem::path voice_path;
    std::filesystem::path voice_config_path;
    inicpp::config config;
    inicpp::schema config_schema;
    std::string config_file_data_string;

private:
    void parse_config();
};

void ConfigVoiceBank::SetVoiceConfig() {
    // 构建音源库配置文件路径
    voice_config_path = voice_path / VOIICEBANKCONFIGFILENAME;
    
    if (voice_config_path.empty()) {
        throw file_open_error("Configure file: " + voice_config_path.string());
    }
}

void ConfigVoiceBank::parse_config() {
    // 解析音源库配置（结构同全局配置）
    config = inicpp::parser::load(config_file_data_string);

    // 覆盖全局配置参数
    auto audio_model_section = config["audio_model"];
    configure.audio_model_frame_period = audio_model_section["frame_period"].get<inicpp::float_ini_t>();
    configure.model_amp = audio_model_section["model_amp"].get<inicpp::float_ini_t>();
    
    // ... 其他参数覆盖
}

void AudioModelIO::SaveAudioModel(...) {
    // 生成版本校验码
    std::string version = configure.get_version();

    // 写入文件头
    file.write("shine", 6);  // 文件标识

    // 写入版本校验码长度和内容
    size_t ver_size = version.size();
    file.write(reinterpret_cast<const char*>(&ver_size), sizeof(size_t));
    file.write(version.c_str(), ver_size);

    // 写入音频参数...
}

bool AudioModelIO::CheckAudioModelVersion(const lessConfigure &configure) {
    // 读取文件标识
    char header[6];
    file.read(header, 6);
    if (strcmp(header, "shine") != 0) {
        throw header_check_error("Header: ...");
    }

    // 读取存储的版本校验码
    size_t ver_size;
    file.read(reinterpret_cast<char*>(&ver_size), sizeof(size_t));
    std::string stored_version(ver_size, '\0');
    file.read(&stored_version[0], ver_size);

    // 计算当前配置的版本校验码
    std::string current_version = configure.get_version();

    // 比对
    if (stored_version != current_version) {
        throw file_version_error("Version Mismatch");
    }

    return true;
}

#include "ConfigUnit/ConfigUnit.h"
#include "ConfigUnit/ConfigVoiceBank.h"

// 获取可执行文件路径
std::filesystem::path exec_path = std::filesystem::weakly_canonical(argv[0]).parent_path();

// 加载全局配置
ConfigUnit configUnit(exec_path);
lessConfigure configure = configUnit.GetConfig();

// 加载音源库配置（可选）
std::filesystem::path voice_path = "path/to/voicebank";
ConfigVoiceBank voiceBank(voice_path, configure);
// configure 现在包含音源库覆盖后的参数

// 获取版本校验码
std::string version = configure.get_version();
// 如: "a1b2c3d4e5f6789012345678901234567890abcd"

// 验证音频模型版本
AudioModelIO audioModelIO(input_file);
if (!audioModelIO.CheckAudioModel(configure)) {
    // 版本不匹配，需要重新生成
    GenerateAudioModel(input_file, configure);
}