lessampler: Shine 模块 - 合成管道与 UTAU 集成

class ShinePara {
public:
    // 基础变换参数
    std::string input_file_name = {};
    std::string output_file_name = {};
    int time_percent = 0;            // UTAU 传递的时间百分比
    double velocity = 0.0;           // 计算后的速度系数
    double offset = 0.0;             // 音频偏移（毫秒）
    double required_length = 0.0;    // 目标长度（毫秒）
    int required_frame = 0;          // 目标帧数
    double first_half_fixed_part = 0.0;  // 固定部分长度
    double last_unused_part = 0.0;   // 空白部分长度
    double volumes = 0;              // 音量系数
    int modulation = 0;              // 调制系数（0-100）
    double wave_length = 0.0;        // 原音频长度
    double pre_cross_length = 0.0;   // 预交叉长度
    double base_length = 0.0;        // 基础长度
    double cross_length = 0.0;       // 交叉长度
    double stretch_length = 0.0;     // 拉伸系数
    int output_samples = 0;          // 输出采样数
    double scale_num = 0.0;          // 目标频率（Hz）
    int tempo_num = 0;               // BPM

public:
    // Pitch Bend 参数
    std::vector<int> pitch_bend = {};  // 弯音数组（cents）
    int pitch_length = 0;              // 弯音长度
    int pitch_step = 256;              // 弯音步长

public:
    // 扩展选项（预留）
    bool is_custom_pitch = false;
    bool is_gender = false;
    bool is_breath = false;
    bool is_opening = false;

public:
    // 选项数据
    double gender_value = 0.0;
    double breath_value = 0.0;
    double opening = 0.0;
};

class UTAUPara {
public:
    // 基础变换参数（直接对应 argv）
    std::string local_name;         // argv[0] - 程序名
    std::string input_file_name;    // argv[1] - 输入文件
    std::string output_file_name;   // argv[2] - 输出文件
    std::string scale_name;         // argv[3] - 音名（如 C4）
    int time_percent;               // argv[4] - 时间百分比
    double velocity;                // 计算：pow(2, percent/100 - 1)
    std::string flags;              // argv[5] - Flags 字符串
    double offset;                  // argv[6] - 偏移（毫秒）
    double required_length;         // argv[7] - 目标长度（毫秒）
    double first_half_fixed_part;   // argv[8] - 固定部分
    double last_unused_part;        // argv[9] - 空白部分
    double volumes;                 // argv[10] - 音量（百分比）
    int modulation;                 // argv[11] - 调制
    std::string tempo;              // argv[12] - BPM 字符串
    std::string pitch;              // argv[13] - Pitch Bend 字符串

public:
    // 计算参数
    double wave_length = 0.0;
    double pre_cross_length = 0.0;
    double base_length = 0.0;
    double cross_length = 0.0;
    double stretch_length = 0.0;
    int output_samples = 0;
    double scale_num = 0.0;
    int tempo_num = 0;
    bool is_custom_pitch = false;
};

UTAUParameterParser::UTAUParameterParser(int argc, char *argv[]) {
    // argv[0]: 程序名
    utauPara.local_name = argv[0];

    // argv[1]: 输入文件路径
    utauPara.input_file_name = argv[1];

    // argv[2]: 输出文件路径
    utauPara.output_file_name = argv[2];

    // argv[3]: 音名（如 C4、D#5）
    utauPara.scale_name = argv[3];
    ScaleConvert scaleConvert(utauPara.scale_name);
    utauPara.scale_num = scaleConvert.GetScaleNum();

    // argv[4]: 时间百分比 → velocity
    if (argc > 4) {
        std::istringstream sstream(argv[4]);
        sstream >> utauPara.time_percent;
        utauPara.velocity = pow(2, utauPara.time_percent / 100.0 - 1.0);
    }

    // argv[5]: Flags 字符串
    if (argc > 5) {
        std::istringstream sstream(argv[5]);
        sstream >> utauPara.flags;
    }

    // argv[6]: 偏移（毫秒）
    if (argc > 6) {
        std::istringstream sstream(argv[6]);
        sstream >> utauPara.offset;
    }

    // argv[7]: 目标长度（毫秒）
    if (argc > 7) {
        std::istringstream sstream(argv[7]);
        sstream >> utauPara.required_length;
    }

    // argv[8]: 固定部分长度
    if (argc > 8) {
        std::istringstream sstream(argv[8]);
        sstream >> utauPara.first_half_fixed_part;
    }

    // argv[9]: 空白部分长度
    if (argc > 9) {
        std::istringstream sstream(argv[9]);
        sstream >> utauPara.last_unused_part;
    }

    // argv[10]: 音量百分比
    if (argc > 10) {
        std::istringstream sstream(argv[10]);
        sstream >> utauPara.volumes;
        utauPara.volumes *= 0.01;  // 转换为系数
    }

    // argv[11]: 调制系数
    if (argc > 11) {
        std::istringstream sstream(argv[11]);
        sstream >> utauPara.modulation;
    }

    // argv[12]: BPM（可能带 ! 前缀）
    if (argc > 12) {
        std::istringstream sstream(argv[12]);
        sstream >> utauPara.tempo;
        if (utauPara.tempo.find('!') != std::string::npos) {
            utauPara.tempo_num = std::stoi(utauPara.tempo.substr(1));
        } else {
            utauPara.tempo_num = std::stoi(utauPara.tempo.substr(2));
        }
    }

    // argv[13]: Pitch Bend 字符串
    if (argc > 13) {
        utauPara.is_custom_pitch = true;
        std::istringstream sstream(argv[13]);
        sstream >> utauPara.pitch;
    }
}

bool ScaleConvert::ScaleConvertToDouble(std::string scaleName) {
    int bias = 0;

    // 检测是否为升号（#）
    if (scaleName[1] == '#') {
        bias = 1;
    }

    // 音名偏移计算（相对于 A）
    int scale;
    switch (scaleName[0]) {
        case 'C': scale = -9 + bias; break;
        case 'D': scale = -7 + bias; break;
        case 'E': scale = -5; break;        // 无升号
        case 'F': scale = -4 + bias; break;
        case 'G': scale = -2 + bias; break;
        case 'A': scale = bias; break;
        case 'B': scale = 2; break;         // 无升号
        default: return false;
    }

    // 计算八度数（相对于 A4）
    double octave = scaleName[1 + bias] - '0' - 4;

    // 频率计算公式：A4 = 440Hz
    scaleNum = pow(2.0, octave) * pow(2.0, scale / 12.0) * 440.0;

    return true;
}

int PitchBendDecoder::GetDataFromUTAU64(char i) {
    if (i >= '0' && i <= '9') {
        return i - '0' + 52;
    } else if (i >= 'A' && i <= 'Z') {
        return i - 'A';
    } else if (i >= 'a' && i <= 'z') {
        return i - 'a' + 26;
    } else if (i == '+') {
        return 62;
    } else if (i == '/') {
        return 63;
    } else {
        return 0;
    }
}

void PitchBendDecoder::PitchBendDecode() {
    int i, n = 0;
    int k = 0, num, ii;
    std::stringstream ss;
    char *str = const_cast<char *>(pitch.c_str());

    for (i = 0; i < pitch_string_length; i += 2) {
        if (str[i] == '#') {
            // Run-Length Encoding: #N# 表示重复前值 N 次
            i++;
            ss << pitch.substr(pitch.find('#', i - 1) + 1, 
                pitch.find('#', i + pitch.find('#')) - 1);
            ss >> num;
            for (ii = 0; ii < num && k < count; ii++) {
                pitch_bend[k++] = n;
            }
            while (str[i] != '#' && str[i] != 0)
                i++;
            i--;
        } else {
            // 正常解码
            n = GetDataFromUTAU64(str[i]) * 64 
                + GetDataFromUTAU64(str[i + 1]);
            if (n > 2047)
                n -= 4096;  // 转为负值
            if (k < count) {
                pitch_bend[k++] = n;
            }
        }
    }
}

void libUTAU::CheckPara(const lessAudioModel& audioModel) {
    // 计算原音频长度（毫秒）
    utauPara.wave_length = static_cast<double>(audioModel.x.size()) 
        / static_cast<double>(audioModel.fs) * 1000;

    // 处理负的 blank 值（从音频末尾计算）
    if (utauPara.last_unused_part < 0) {
        utauPara.last_unused_part = utauPara.wave_length 
            - utauPara.offset + utauPara.last_unused_part;
        if (utauPara.last_unused_part < 0)
            utauPara.last_unused_part = 0;
    }

    // 验证：offset + blank 不能超过音频长度
    if (utauPara.offset + utauPara.last_unused_part >= utauPara.wave_length)
        throw parameter_error("音频偏移和空白超过音频长度");

    // 验证：固定部分不能超过可用音频
    if (utauPara.offset + utauPara.last_unused_part + utauPara.first_half_fixed_part >= utauPara.wave_length)
        utauPara.first_half_fixed_part = utauPara.wave_length 
            - utauPara.offset + utauPara.last_unused_part;

    // 计算预交叉长度
    utauPara.pre_cross_length = utauPara.wave_length 
        - utauPara.offset 
        - utauPara.first_half_fixed_part 
        - utauPara.last_unused_part;

    // 计算基础长度（固定部分除以 velocity）
    utauPara.base_length = utauPara.first_half_fixed_part / utauPara.velocity;

    // 计算交叉长度
    utauPara.cross_length = utauPara.required_length - utauPara.base_length;

    // 验证：预交叉长度不能为负
    if (utauPara.pre_cross_length <= 0 && utauPara.cross_length > 0)
        throw parameter_error("输入音频长度不足以进行交叉变换");

    // 计算拉伸系数
    utauPara.stretch_length = utauPara.pre_cross_length / utauPara.cross_length;

    // 限制拉伸系数不超过 1.0
    if (utauPara.stretch_length > 1.0)
        utauPara.stretch_length = 1.0;

    // 计算输出采样数
    utauPara.output_samples = static_cast<int>(utauPara.required_length * 0.001 * audioModel.fs) + 1;
}

Shine::Shine(int argc, char *argv[], const lessAudioModel &audioModel, SHINE_MODE mode) {
    if (mode == SHINE_MODE::UTAU) {
        // 解析 UTAU 参数
        libUTAU utau(argc, argv);

        // 验证并计算参数
        utau.CheckPara(audioModel);

        // 设置 ShinePara
        SetShine(utau.GetUTAUPara(), utau.GetUTAUFlags(), audioModel);
    }
}

void Shine::SetShine(const UTAUPara &utau_para, UTAUFlags utau_flags, 
    const lessAudioModel &audioModel) {
    // 复制基础参数
    shine_para.input_file_name = utau_para.input_file_name;
    shine_para.output_file_name = utau_para.output_file_name;
    shine_para.time_percent = utau_para.time_percent;
    shine_para.velocity = utau_para.velocity;
    shine_para.offset = utau_para.offset;
    shine_para.required_length = utau_para.required_length;
    shine_para.first_half_fixed_part = utau_para.first_half_fixed_part;
    shine_para.last_unused_part = utau_para.last_unused_part;
    shine_para.volumes = utau_para.volumes;
    shine_para.modulation = utau_para.modulation;
    shine_para.wave_length = utau_para.wave_length;
    shine_para.pre_cross_length = utau_para.pre_cross_length;
    shine_para.base_length = utau_para.base_length;
    shine_para.cross_length = utau_para.cross_length;
    shine_para.stretch_length = utau_para.stretch_length;
    shine_para.output_samples = utau_para.output_samples;
    shine_para.scale_num = utau_para.scale_num;
    shine_para.tempo_num = utau_para.tempo_num;
    shine_para.is_custom_pitch = utau_para.is_custom_pitch;

    // 解码 Pitch Bend
    DecodePitchBend(audioModel.fs, audioModel.frame_period, utau_para.pitch);
}

void Shine::DecodePitchBend(int fs, double frame_period, std::string pitch) {
    // 默认 BPM
    if (shine_para.tempo_num == 0)
        shine_para.tempo_num = 120;

    if (shine_para.is_custom_pitch) {
        // 计算 Pitch Bend 采样步长
        shine_para.pitch_step = static_cast<int>(lround(
            60.0 / 96.0 / shine_para.tempo_num * fs));

        // 计算 Pitch Bend 长度
        shine_para.pitch_length = shine_para.output_samples / shine_para.pitch_step + 1;

        // 解码 Pitch Bend 字符串
        PitchBendDecoder pitchBendDecoder(pitch, shine_para.pitch_length);
        shine_para.pitch_bend = std::move(pitchBendDecoder.GetPitchBend());
    } else {
        // 无自定义弯音：填充零
        shine_para.pitch_bend.resize(shine_para.pitch_length + 1);
        std::fill(shine_para.pitch_bend.begin(), shine_para.pitch_bend.end(), 0);
    }

    // 计算目标帧数
    shine_para.required_frame = static_cast<int>(
        1000.0 * shine_para.output_samples / fs / frame_period) + 1;
}

#include "Shine/Shine.h"

// UTAU 调用方式
// lessampler.exe input.wav output.wav C4 100 "" 0 200 50 20 100 50 !120 AA

int main(int argc, char *argv[]) {
    // 加载音频模型
    lessAudioModel audioModel = LoadAudioModel(argv[1]);

    // 创建 Shine 管道
    Shine shine(argc, argv, audioModel, Shine::SHINE_MODE::UTAU);
    ShinePara params = shine.GetShine();

    // 使用参数进行音频处理
    AudioProcess processor(audioModel, params);
    lessAudioModel transformed = processor.GetTransAudioModel();

    // 合成并输出
    Synthesis synth(transformed, params.output_samples);
    AutoAMP amp(params, synth.GetWavData());

    WavIO::WriteWav(params.output_file_name, amp.GetAMP(), 
        params.output_samples, audioModel.fs);
}