AI生成歌词功能

app.py

@@ -6,49 +6,19 @@ import sys
 import hashlib
 import time
 import math
-from typing import List, Dict, Optional, Tuple
+import re
+import zipfile
+from typing import Any, List, Dict, Optional, Tuple
 from pathlib import Path
 
 import numpy as np
 from pydub import AudioSegment
-# 引入与 sample.py 一致的组件
-try:
-    from diffsinger_utau.voice_bank import PredAll
-    from diffsinger_utau.voice_bank.commons.ds_reader import DSReader
-    from diffsinger_utau.voice_bank.commons.phome_num_counter import Phome
-    from pypinyin import pinyin, Style
-    from pypinyin.constants import RE_HANS
-except Exception:
-    PredAll = None
-    DSReader = None
-    Phome = None
-    Style = None
-    RE_HANS = None
-
-def get_opencpop_dict(path: str = str(Path("dictionaries") / "opencpop-extension.txt")) -> Dict[str, str]:
-    result = {"AP": "AP", "SP": "SP"}
-    p = Path(path)
-    if not p.exists():
-        return result
-    with p.open("r", encoding="utf-8") as f:
-        for line in f:
-            if "\t" in line:
-                k, v = line.split("\t", 1)
-                result[k.strip()] = v.strip()
-    return result
-
-def get_phonemes(text: str, opencpop_dict: Dict[str, str]) -> List[str]:
-    if Style is None:
-        # 无 pypinyin 时，退化为逐字符
-        return [opencpop_dict.get(ch, ch) for ch in list(text)]
-    pys = [x[0] for x in pinyin(text, style=Style.NORMAL)]
-    result: List[str] = []
-    for py in pys:
-        py = py.strip()
-        if not py:
-            continue
-        result.append(opencpop_dict.get(py, py))
-    return " ".join(result).split()
+
+from diffsinger_utau.voice_bank import PredAll
+from diffsinger_utau.voice_bank.commons.ds_reader import DSReader
+from diffsinger_utau.voice_bank.commons.phome_num_counter import Phome
+from pypinyin import pinyin, Style
+from pypinyin.constants import RE_HANS
 
 # —— 文本预处理：相邻纯汉字不加空格，其余保留空格 ——
 def _is_hans_token(s: str) -> bool:
@@ -73,6 +43,91 @@ def preprocess_zh_spaces(text: str) -> str:
                 out.append(" " + part)
     return "".join(out)
 
+
+def validate_lyric_format(modified_text: str, original_text: str) -> Tuple[bool, str]:
+    """
+    校验歌词格式是否与原始文本匹配
+    返回: (是否匹配, 渲染后的原始文本或空字符串)
+    """
+    if not original_text:
+        return True, ""
+    
+    # 去掉空格后比较
+    modified_clean = re.sub(r'\s+', '', modified_text)
+    original_clean = re.sub(r'\s+', '', original_text)
+    
+    # 长度检查
+    if len(modified_clean) != len(original_clean):
+        return False, render_original_with_highlights(original_text, modified_text)
+    
+    # AP/SP 位置检查
+    modified_ap_sp_positions = []
+    original_ap_sp_positions = []
+    
+    # 找到修改后文本中的 AP/SP 位置
+    for match in re.finditer(r'\b(AP|SP)\b', modified_text):
+        modified_ap_sp_positions.append((match.start(), match.group()))
+    
+    # 找到原始文本中的 AP/SP 位置  
+    for match in re.finditer(r'\b(AP|SP)\b', original_text):
+        original_ap_sp_positions.append((match.start(), match.group()))
+    
+    # 比较 AP/SP 的数量和类型
+    if len(modified_ap_sp_positions) != len(original_ap_sp_positions):
+        return False, render_original_with_highlights(original_text, modified_text)
+    
+    # 检查每个 AP/SP 的相对位置是否一致
+    for (mod_pos, mod_type), (orig_pos, orig_type) in zip(modified_ap_sp_positions, original_ap_sp_positions):
+        if mod_type != orig_type:
+            return False, render_original_with_highlights(original_text, modified_text)
+        
+        # 计算相对位置（在去空格后的字符串中）
+        mod_relative_pos = len(re.sub(r'\s+', '', modified_text[:mod_pos]))
+        orig_relative_pos = len(re.sub(r'\s+', '', original_text[:orig_pos]))
+        
+        if mod_relative_pos != orig_relative_pos:
+            return False, render_original_with_highlights(original_text, modified_text)
+    
+    return True, ""
+
+
+def render_original_with_highlights(original_text: str, modified_text: str) -> str:
+    """
+    渲染原始文本，用灰色字体显示，位置不一致的 AP/SP 用红色标记
+    """
+    # 找到修改后和原始文本中的 AP/SP 位置
+    modified_ap_sp = set()
+    original_ap_sp = set()
+    
+    for match in re.finditer(r'\b(AP|SP)\b', modified_text):
+        pos = len(re.sub(r'\s+', '', modified_text[:match.start()]))
+        modified_ap_sp.add((pos, match.group()))
+    
+    result_parts = []
+    i = 0
+    clean_pos = 0
+    
+    while i < len(original_text):
+        # 检查当前位置是否是 AP 或 SP
+        if original_text[i:i+2] in ['AP', 'SP'] and (i == 0 or not original_text[i-1].isalnum()) and (i+2 >= len(original_text) or not original_text[i+2].isalnum()):
+            ap_sp = original_text[i:i+2]
+            # 检查这个 AP/SP 在修改后的文本中是否在相同位置
+            if (clean_pos, ap_sp) not in modified_ap_sp:
+                result_parts.append(f'<span style="color: red;">{ap_sp}</span>')
+            else:
+                result_parts.append(ap_sp)
+            i += 2
+            clean_pos += 2
+        elif original_text[i].isspace():
+            result_parts.append(original_text[i])
+            i += 1
+        else:
+            result_parts.append(original_text[i])
+            i += 1
+            clean_pos += 1
+    
+    return f'<span style="color: gray;">{"".join(result_parts)}</span>'
+
 # 试图导入 diffsinger-utau（按要求使用该库，而非自行实现）
 try:
     import diffsinger_utau  # 类型: 忽略
@@ -135,28 +190,9 @@ def bgm_path_for(template_path: Path) -> Optional[Path]:
     return None
 
 
-def load_ds(template_path: Path) -> List[Dict]:
-    # ds: 一个 list，每个元素为 dict，至少包含 text；可包含 offset（秒）
-    with open(template_path, "r", encoding="utf-8") as f:
-        data = json.load(f)
-    if not isinstance(data, list):
-        raise ValueError("ds 模板需要是一个 list")
-    # 标准化
-    norm = []
-    for i, item in enumerate(data):
-        if not isinstance(item, dict):
-            raise ValueError(f"ds 第 {i+1} 个元素不是 dict")
-        text = item.get("text", "")
-        if not isinstance(text, str):
-            raise ValueError(f"ds 第 {i+1} 个元素的 text 不是字符串")
-        offset = item.get("offset", 0.0)
-        try:
-            offset = float(offset)
-        except Exception:
-            offset = 0.0
-        norm.append({"text": text, "offset": offset, **item})
-    return norm
-
+def load_ds(template_path: Path):
+    ds = DSReader(template_path).read_ds()
+    return ds
 
 def audiosegment_from_file(path: Path) -> AudioSegment:
     return AudioSegment.from_file(str(path))
@@ -167,7 +203,7 @@ def export_wav(seg: AudioSegment, path: Path):
     seg.export(str(path), format="wav")
 
 
-def overlay_bgm_snippet(vocal_wav: Path, bgm_audio: AudioSegment, offset_sec: float, bgm_volume: float = 1.0, vocal_gain_db: float = 0.0) -> AudioSegment:
+def overlay_bgm_snippet(vocal_wav: Path, bgm_audio: AudioSegment, offset_sec: float, bgm_volume: float = 0.3, vocal_gain_db: float = 0.0) -> AudioSegment:
     vocal = audiosegment_from_file(vocal_wav)
     if vocal_gain_db != 0.0:
         vocal = vocal + vocal_gain_db
@@ -184,7 +220,8 @@ def overlay_bgm_snippet(vocal_wav: Path, bgm_audio: AudioSegment, offset_sec: fl
         pad_ms = start_ms + len(vocal) - len(base)
         base = base + AudioSegment.silent(duration=pad_ms)
     mixed = base.overlay(vocal, position=start_ms)
-    return mixed[start_ms : start_ms + len(vocal)]
+
+    return mixed[start_ms : start_ms + len(vocal)]  # pyright: ignore[reportReturnType]
 
 
 def concat_with_offsets(clips: List[Tuple[AudioSegment, float]]) -> AudioSegment:
@@ -202,7 +239,7 @@ def concat_with_offsets(clips: List[Tuple[AudioSegment, float]]) -> AudioSegment
     return timeline
 
 
-def mix_full_song(vocal: AudioSegment, bgm: AudioSegment, bgm_volume: float = 1.0) -> AudioSegment:
+def mix_full_song(vocal: AudioSegment, bgm: AudioSegment, bgm_volume: float = 0.3) -> AudioSegment:
     # 保证两者同长度
     if len(bgm) < len(vocal):
         bgm = bgm + AudioSegment.silent(duration=(len(vocal) - len(bgm)))
@@ -217,6 +254,62 @@ def mix_full_song(vocal: AudioSegment, bgm: AudioSegment, bgm_volume: float = 1.
     return bgm_adj.overlay(vocal)
 
 
+def copy_prompt_to_clipboard(lyrics_text: str) -> str:
+    """生成AI歌词的prompt"""
+    processed_lyrics = preprocess_zh_spaces(lyrics_text) if lyrics_text else ""
+    
+    prompt = f"""这是原始歌词：
+```txt
+{processed_lyrics}
+```
+
+其中SP和AP分别代表停顿和呼吸。你应该保留原始格式，然后按照要求替换歌词。
+
+保留原始格式的意思是每句歌词字数应该保持不变。
+
+比如 "AP 试着 SP 掬一把星辰 SP 在手心 SP" 修改为 "AP 天空 SP 赤色的晚霞 SP 刚散去 SP" 就是符合要求的。如果有多字、少字或者AP, SP位置不对，都是不符合要求的。
+
+现在请帮我基于上述原始歌词模板，写一首歌曲《历史的进程推着人前进》，主题为：个人奋斗固然重要，但是历史进程更加浩浩汤汤。"""
+    
+    # 复制到剪切板
+    try:
+        import pyperclip
+        pyperclip.copy(prompt)
+        return "Prompt已复制到剪切板！"
+    except ImportError:
+        # 如果没有pyperclip，使用系统命令
+        try:
+            import subprocess
+            import platform
+            if platform.system() == "Darwin":  # macOS
+                subprocess.run(["pbcopy"], input=prompt.encode(), check=True)
+            elif platform.system() == "Linux":
+                subprocess.run(["xclip", "-selection", "clipboard"], input=prompt.encode(), check=True)
+            elif platform.system() == "Windows":
+                subprocess.run(["clip"], input=prompt.encode(), check=True)
+            return "Prompt已复制到剪切板！"
+        except Exception as e:
+            return f"复制��败：{e}"
+
+
+def apply_ai_lyrics(ai_lyrics: str, original_lyrics: str) -> Tuple[str, str]:
+    """应用AI生成的歌词到右侧文本框"""
+    if not ai_lyrics or not ai_lyrics.strip():
+        return original_lyrics, "请先输入回填歌词"
+    
+    # 分割歌词为行，保留空行
+    ai_lines = [line.strip() for line in ai_lyrics.split('\n')]
+    original_lines = [line.strip() for line in original_lyrics.split('\n')]
+    
+    # 检查行数是否一致
+    if len(ai_lines) != len(original_lines):
+        return original_lyrics, f"行数不匹配：AI歌词有{len(ai_lines)}行，原始歌词有{len(original_lines)}行"
+    
+    # 逐行替换
+    new_lyrics = '\n'.join(ai_lines)
+    return new_lyrics, "歌词应用成功！"
+
+
 def param_hash(model_sel: str, speaker: str, key_shift: int, steps: int, text: str) -> str:
     s = json.dumps(
         {
@@ -232,94 +325,16 @@ def param_hash(model_sel: str, speaker: str, key_shift: int, steps: int, text: s
     )
     return hashlib.md5(s.encode("utf-8")).hexdigest()[:16]
 
-
-class DiffSingerEngine:
-    def __init__(self):
-        self.impl = diffsinger_utau
-        self.entry = None
-        if self.impl is not None:
-            # 尝试发现可用入口函数（不同版本可能不同）
-            candidates = ["synthesize", "synth", "infer", "generate", "tts"]
-            for name in candidates:
-                fn = getattr(self.impl, name, None)
-                if callable(fn):
-                    self.entry = fn
-                    break
-
-    def is_ready(self) -> bool:
-        return self.impl is not None and self.entry is not None
-
-    def synth_once(
-        self,
-        model_path: Path,
-        text: str,
-        speaker: Optional[str],
-        key_shift: int,
-        steps: int,
-        out_wav: Path,
-    ) -> None:
-        """
-        使用 diffsinger-utau 渲染单句音频到 out_wav。
-        如果不同版本签名不同，将尝试多种参数形式。
-        """
-        if not self.is_ready():
-            raise RuntimeError(
-                "未找到可用的 diffsinger-utau 推理入口。请确认已安装并与 torch==1.13.1 兼容。"
-            )
-
-        out_wav.parent.mkdir(parents=True, exist_ok=True)
-
-        tried = []
-
-        def call_or_record(fn, kwargs):
-            tried.append({"fn": fn.__name__, "kwargs": list(kwargs.keys())})
-            return fn(**kwargs)
-
-        # 常见签名尝试
-        errors = []
-        for kwargs in [
-            dict(model=str(model_path), text=text, speaker=speaker, key_shift=key_shift, steps=steps, out=str(out_wav)),
-            dict(model=str(model_path), text=text, speaker=speaker, key_shift=key_shift, acoustic_steps=steps, out=str(out_wav)),
-            dict(model_path=str(model_path), text=text, speaker=speaker, key_shift=key_shift, steps=steps, output=str(out_wav)),
-            dict(model=str(model_path), text=text, key_shift=key_shift, steps=steps, out=str(out_wav)),
-            dict(model=str(model_path), text=text, out=str(out_wav)),
-        ]:
-            # 移除 None
-            kwargs = {k: v for k, v in kwargs.items() if v is not None}
-            try:
-                ret = call_or_record(self.entry, kwargs)
-                # 若函数返回波形和采样率，也直接落盘
-                if ret is not None and isinstance(ret, (tuple, list)) and len(ret) >= 2:
-                    wav, sr = ret[0], ret[1]
-                    import soundfile as sf  # 懒加载
-                    sf.write(str(out_wav), np.asarray(wav, dtype=np.float32), int(sr))
-                # 若 out_wav 成功生成，结束
-                if out_wav.exists() and out_wav.stat().st_size > 0:
-                    return
-            except Exception as e:
-                errors.append(f"{e}")
-
-        raise RuntimeError(
-            "调用 diffsinger-utau 失败。已尝试多种签名："
-            + json.dumps(tried, ensure_ascii=False)
-            + f"；错误示例：{errors[-1] if errors else '未知'}"
-        )
-
-
-engine = DiffSingerEngine()
-
 class DSUEngine:
     """
-    基于 voice_bank.PredAll 的推理引擎；若不可用则回退到 DiffSingerEngine。
+    基于 voice_bank.PredAll 的推理引擎；。
     """
-    def __init__(self, old_engine: DiffSingerEngine):
-        self.old = old_engine
+    def __init__(self):
         self.available = PredAll is not None and DSReader is not None
-        self.predictors: Dict[str, object] = {}  # model_path -> PredAll 实例
-        self.opencpop = get_opencpop_dict()
+        self.predictors: Dict[str, PredAll] = {}  # model_path -> PredAll 实例
 
     def is_ready(self) -> bool:
-        return self.available or self.old.is_ready()
+        return self.available
 
     def _get_predictor(self, model_path: Path):
         key = str(model_path.resolve())
@@ -341,17 +356,11 @@ class DSUEngine:
         if self.available:
             predictor = self._get_predictor(model_path)
             # 读取 ds，并替换目标行文本与必要的音素
-            ds_list = DSReader(str(template_path)).read_ds()
+            ds_list = DSReader(template_path).read_ds()
             if not (0 <= line_index < len(ds_list)):
                 raise IndexError("行索引越界")
             ds = ds_list[line_index]
-            old_text = ds.get("text", "")
-            ds["text"] = text
-            # 若文本变化或缺少音素信息，则基于新文本重算音素
-            if (text != old_text) or (not ds.get("ph_seq")) or (not ds.get("ph_num")):
-                phonemes = get_phonemes(text, self.opencpop)
-                ds["ph_seq"] = " ".join(phonemes)
-                ds["ph_num"] = " ".join(map(str, Phome(phonemes).get_ph_num())) if Phome else ""
+            ds.replace(text)
 
             # 选择说话人
             spk = speaker
@@ -387,11 +396,9 @@ class DSUEngine:
             if not out_wav.exists() or out_wav.stat().st_size == 0:
                 raise RuntimeError("未能生成音频文件")
         else:
-            # 回退旧引擎（不依赖 ds）
-            self.old.synth_once(model_path, text, speaker, key_shift, steps, out_wav)
+            pass
 
-# 用 DSUEngine 覆盖默认引擎
-engine = DSUEngine(engine)
+engine = DSUEngine()
 
 
 def get_template_choices_and_bgm_visible():
@@ -410,7 +417,7 @@ def on_select_template(template_name: str):
     ds = load_ds(p)
     lines = [preprocess_zh_spaces(item.get("text", "")) for item in ds]
     offsets = [float(item.get("offset", 0.0)) for item in ds]
-    bgm_update = gr.update(visible=(bgm is not None), value=(1.0 if bgm is not None else 0.0))
+    bgm_update = gr.update(visible=(bgm is not None), value=(0.3 if bgm is not None else 0.0))
     return bgm_update, lines, offsets
 
 
@@ -605,10 +612,10 @@ def build_ui():
                 template_sel = gr.Dropdown(choices=template_names, label="模板选择", value=(template_names[0] if template_names else None))
                 with gr.Row(elem_classes=["compact-row"]):
                     upload = gr.UploadButton("上传ds模板", file_types=[".ds"], elem_classes=["compact-btn"])
-                    download_btn = gr.DownloadButton(label="下载当前ds状态", elem_classes=["compact-btn"])
+                    download_btn = gr.DownloadButton(label="下载ds&lrc", elem_classes=["compact-btn"])
 
                 with gr.Row():
-                    bgm_volume = gr.Slider(0.0, 2.0, value=1.0, step=0.01, label="BGM音量倍率", visible=False)
+                    bgm_volume = gr.Slider(0.0, 2.0, value=0.3, step=0.01, label="BGM音量", visible=False)
                     key_shift = gr.Slider(-12, 12, value=0, step=1, label="音高偏移")
                     steps = gr.Slider(1, 50, value=4, step=1, label="渲染步数")
                 speaker = gr.Dropdown(label="演唱者", choices=[], value=None, interactive=True)
@@ -623,6 +630,18 @@ def build_ui():
                 full_vocal = gr.Audio(label="整首（人声）", autoplay=False)
                 full_mixed = gr.Audio(label="整首（混音）", autoplay=False, visible=False)
 
+                # AI歌词功能
+                with gr.Accordion("AI歌词", open=False):
+                    gr.Markdown("由于服务器限制，请复制prompt，到大模型APP粘贴，并将结果回填")
+                    copy_prompt_btn = gr.Button("复制prompt")
+                    ai_lyrics_input = gr.Textbox(
+                        label="回填歌词",
+                        lines=10,
+                        max_lines=15,
+                        placeholder="请将大模型生成的歌词粘贴到这里..."
+                    )
+                    apply_lyrics_btn = gr.Button("应用歌词")
+
             # 右栏：模板与歌词编辑
             with gr.Column(elem_id="right-panel", scale=2):
                 # 状态与歌词编辑容器（右栏仅歌词编辑）
@@ -633,8 +652,10 @@ def build_ui():
                 generating_flag = gr.State(False)
                 dyn = gr.Column()
 
-                # 预创建文本框，依据当前模板设置初始可见性和值
+                # 预创建文本框和错误提示，依据当前模板设置初始可见性和值
                 textboxes = []
+                error_markdowns = []
+                original_lines_state = gr.State([])  # 存储原始歌词用于校验
                 init_lines = []
                 init_offsets = []
                 if template_sel.value:
@@ -648,22 +669,29 @@ def build_ui():
                         val = init_lines[i] if visible else ""
                         tb = gr.Textbox(value=val, label=f"第 {i+1} 句", lines=1, max_lines=1, visible=visible)
                         textboxes.append(tb)
+                        # 为每个文本框添加对应的错误提示
+                        error_md = gr.Markdown("", visible=False)
+                        error_markdowns.append(error_md)
                 if template_sel.value:
                     lines_state.value = init_lines
                     offsets_state.value = init_offsets
+                    original_lines_state.value = init_lines.copy()
 
         # 事件：选择模板时，更新 BGM 开关、整首混音可见性与文本框内容
         def on_template_change(template_name):
             bgm_update, lines, offsets = on_select_template(template_name)
             has_bgm = bool(bgm_update.get("visible", False)) if isinstance(bgm_update, dict) else False
             tb_updates = []
+            error_updates = []
             n = len(lines)
             for i, tb in enumerate(textboxes):
                 if i < n:
                     tb_updates.append(gr.update(value=lines[i], visible=True))
+                    error_updates.append(gr.update(value="", visible=False))
                 else:
                     tb_updates.append(gr.update(value="", visible=False))
-            # 返回：BGM、模板下拉、状态、错误清空、整首混音可见性（按是否存在BGM），以及所有文本框更新
+                    error_updates.append(gr.update(value="", visible=False))
+            # 返回：BGM、模板下拉、状态、错误清空、整首混音可见性（按是否存在BGM），原始歌词状态，以及所有文本框和错误提示更新
             return (
                 bgm_update,
                 gr.update(choices=get_template_choices_and_bgm_visible(), value=template_name),
@@ -671,7 +699,9 @@ def build_ui():
                 offsets,
                 gr.update(value="", visible=False),
                 gr.update(visible=has_bgm),
+                lines.copy(),
                 *tb_updates,
+                *error_updates,
             )
 
         # 模型切换：动态更新 speaker 下拉项
@@ -717,7 +747,7 @@ def build_ui():
         template_sel.change(
             fn=on_template_change,
             inputs=[template_sel],
-            outputs=[bgm_volume, template_sel, lines_state, offsets_state, per_line_error, full_mixed, *textboxes],
+            outputs=[bgm_volume, template_sel, lines_state, offsets_state, per_line_error, full_mixed, original_lines_state, *textboxes, *error_markdowns],
         )
 
         # 上传模板：将用户 .ds 保存到 templates/user，并刷新模板下拉
@@ -758,21 +788,35 @@ def build_ui():
         # 文本提交事件：逐句渲染（为预创建文本框绑定）
         for idx, tb in enumerate(textboxes):
             def make_submit(i):
-                def _submit(new_text, lines_list, model_sel_v, template_sel_v, speaker_v, key_shift_v, steps_v, bgm_volume_v):
+                def _submit(new_text, lines_list, original_lines_list, model_sel_v, template_sel_v, speaker_v, key_shift_v, steps_v, bgm_volume_v):
                     # 仅处理当前可见范围内的行
                     if not isinstance(lines_list, list) or i >= max(len(lines_list), 0):
-                        return gr.update(), gr.update(), lines_list
+                        return gr.update(), gr.update(), gr.update(), lines_list
+                    
+                    # 校验歌词格式
+                    original_text = original_lines_list[i] if i < len(original_lines_list) else ""
+                    is_valid, rendered_original = validate_lyric_format(new_text, original_text)
+                    
+                    # 更新错误提示
+                    if not is_valid:
+                        error_msg = f"字数与原始文本不符：{rendered_original}"
+                        error_update = gr.update(value=error_msg, visible=True)
+                    else:
+                        error_update = gr.update(value="", visible=False)
+                    
+                    # 渲染音频
                     audio_path, err = render_single_line(model_sel_v, template_sel_v, i, new_text, speaker_v, key_shift_v, steps_v, bgm_volume_v)
                     if i < len(lines_list):
                         lines_list[i] = new_text
                     if err:
-                        return gr.update(value=None), gr.update(value=f"❌ {err}", visible=True), lines_list
-                    return gr.update(value=audio_path), gr.update(value="", visible=False), lines_list
+                        return gr.update(value=None), gr.update(value=f"❌ {err}", visible=True), error_update, lines_list
+                    return gr.update(value=audio_path), gr.update(value="", visible=False), error_update, lines_list
                 return _submit
+            
             tb.submit(
                 fn=make_submit(idx),
-                inputs=[tb, lines_state, model_sel, template_sel, speaker, key_shift, steps, bgm_volume],
-                outputs=[per_line_audio, per_line_error, lines_state],
+                inputs=[tb, lines_state, original_lines_state, model_sel, template_sel, speaker, key_shift, steps, bgm_volume],
+                outputs=[per_line_audio, per_line_error, error_markdowns[idx], lines_state],
             )
 
         # 生成整首（支持进度与中断）
@@ -858,7 +902,7 @@ def build_ui():
             outputs=[full_vocal, full_mixed, gen_btn, progress_md, stop_flag, generating_flag],
         )
 
-        # 下载当前编辑��的 ds
+        # 下载当前编辑后的 ds 和 lrc
         def build_current_ds(template_sel_v, lines, offsets):
             mapping = find_templates()
             if not template_sel_v or template_sel_v not in mapping:
@@ -868,17 +912,104 @@ def build_ui():
             # 覆盖 text，并基于最新文本重算 ph_seq / ph_num
             for i in range(min(len(ds), len(lines or []))):
                 new_text = lines[i] if lines and i < len(lines) else ds[i].get("text", "")
-                ds[i]["text"] = new_text
-                phonemes = get_phonemes(new_text, get_opencpop_dict())
-                ds[i]["ph_seq"] = " ".join(phonemes)
-                ds[i]["ph_num"] = " ".join(map(str, Phome(phonemes).get_ph_num())) if Phome else ds[i].get("ph_num", "")
+                ds[i].replace(new_text)
+            
             # 输出到 output/pred_all/<template>/edits
             ts_tag = time.strftime("%Y%m%d_%H%M%S")
             out_dir = OUTPUT_DIR / template_sel_v / "edits"
             out_dir.mkdir(parents=True, exist_ok=True)
-            out_path = out_dir / f"{template_sel_v}_edited_{ts_tag}.ds"
-            out_path.write_text(json.dumps(ds, ensure_ascii=False, indent=2), encoding="utf-8")
-            return str(out_path)
+            
+            # 生成DS文件
+            ds_path = out_dir / f"{template_sel_v}_edited_{ts_tag}.ds"
+            ds_path.write_text(json.dumps(ds, ensure_ascii=False, indent=2), encoding="utf-8")
+            
+            # 生成LRC文件
+            lrc_path = out_dir / f"{template_sel_v}_edited_{ts_tag}.lrc"
+            lrc_content = generate_lrc_content(ds, lines, offsets)
+            lrc_path.write_text(lrc_content, encoding="utf-8")
+            
+            # 生成纯字幕TXT文件
+            txt_path = out_dir / f"{template_sel_v}_edited_{ts_tag}.txt"
+            txt_content = generate_txt_content(ds, lines)
+            txt_path.write_text(txt_content, encoding="utf-8")
+            
+            # 创建包含DS、LRC和TXT的压缩包
+            zip_path = out_dir / f"{template_sel_v}_edited_{ts_tag}.zip"
+            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                zipf.write(ds_path, ds_path.name)
+                zipf.write(lrc_path, lrc_path.name)
+                zipf.write(txt_path, txt_path.name)
+            
+            return str(zip_path)
+        
+        def generate_lrc_content(ds_data, lines, offsets):
+            """生成LRC歌词文件内容"""
+            lrc_lines = []
+            
+            # 添加LRC文件头信息
+            lrc_lines.append("[ar:DiffSinger]")
+            lrc_lines.append("[ti:Generated Song]")
+            lrc_lines.append("[al:DiffSinger WebUI]")
+            lrc_lines.append("[by:DiffSinger WebUI]")
+            lrc_lines.append("")
+            
+            for i, sentence_data in enumerate(ds_data):
+                # 获取当前句子的歌词文本
+                if i < len(lines or []) and lines[i]:
+                    lyric_text = lines[i]
+                else:
+                    lyric_text = sentence_data.get("text", "")
+                
+                # 清理歌词文本，移除AP、SP等标记并去掉所有空格
+                display_text = clean_lyric_for_display(lyric_text)
+                
+                # 如果有实际歌词内容才添加到LRC
+                if display_text.strip():
+                    # 使用offset作为开始时间
+                    start_time = 0.0
+                    if i < len(offsets or []) and offsets[i] is not None:
+                        start_time = float(offsets[i])
+                    
+                    # 格式化时间戳 [mm:ss.xx]
+                    minutes = int(start_time // 60)
+                    seconds = start_time % 60
+                    time_stamp = f"[{minutes:02d}:{seconds:05.2f}]"
+                    
+                    lrc_lines.append(f"{time_stamp}{display_text}")
+            
+            return "\n".join(lrc_lines)
+        
+        def generate_txt_content(ds_data, lines):
+            """生成纯字幕TXT文件内容"""
+            txt_lines = []
+            
+            for i, sentence_data in enumerate(ds_data):
+                # 获取当前句子的歌词文本
+                if i < len(lines or []) and lines[i]:
+                    lyric_text = lines[i]
+                else:
+                    lyric_text = sentence_data.get("text", "")
+                
+                # 清理歌词文本，移除AP、SP等标记并去掉所有空格
+                display_text = clean_lyric_for_display(lyric_text)
+                
+                # 如果有实际歌词内容才添加到TXT
+                if display_text.strip():
+                    txt_lines.append(display_text)
+            
+            return "\n".join(txt_lines)
+        
+        def clean_lyric_for_display(lyric_text):
+            """清理歌词文本，移除AP、SP等标记并去掉所有空格，用于LRC显示"""
+            if not lyric_text:
+                return ""
+            
+            # 移除AP、SP标记
+            cleaned = re.sub(r'\b(AP|SP)\b', '', lyric_text)
+            # 去掉所有空格
+            cleaned = re.sub(r'\s+', '', cleaned)
+            
+            return cleaned
 
         download_btn.click(
             fn=build_current_ds,
@@ -906,10 +1037,86 @@ def build_ui():
             tpl_upds = on_template_change(template_name)
             return (spk_upd, *tpl_upds)
 
+        # AI歌词功能事件绑定
+        def handle_copy_prompt(lines_list):
+            """处理复制prompt"""
+            # 将当前歌词列表合并为文本
+            lyrics_text = '\n'.join(lines_list) if lines_list else ""
+            message = copy_prompt_to_clipboard(lyrics_text)
+            gr.Info(message)
+            return message
+        
+        def handle_apply_lyrics(ai_lyrics, lines_list, original_lines_list):
+            """处理应用歌词到文本框"""
+            if not ai_lyrics or not ai_lyrics.strip():
+                gr.Warning("请先输入回填歌词")
+                return [gr.update() for _ in textboxes] + [gr.update() for _ in error_markdowns] + [lines_list]
+            
+            # 分割歌词为行，保留空行以保持行数一致
+            ai_lines = [line.strip() for line in ai_lyrics.split('\n')]
+            
+            # 检查行数是否一致
+            if len(ai_lines) != len(lines_list):
+                gr.Warning(f"行数不匹配：AI歌词有{len(ai_lines)}行，原始歌词有{len(lines_list)}行")
+                return [gr.update() for _ in textboxes] + [gr.update() for _ in error_markdowns] + [lines_list]
+            
+            # 更新文本框和状态，同时校验每句格式
+            textbox_updates = []
+            error_updates = []
+            new_lines = ai_lines[:len(lines_list)]  # 直接使用AI歌词，截断到原始长度
+            
+            has_errors = False
+            
+            # 更新所有文本框并校验格式
+            for i in range(len(textboxes)):
+                if i < len(new_lines):
+                    textbox_updates.append(gr.update(value=new_lines[i]))
+                    
+                    # 校验当前句子格式
+                    if i < len(original_lines_list):
+                        original_text = original_lines_list[i]
+                        new_text = new_lines[i]
+                        is_valid, rendered_original = validate_lyric_format(new_text, original_text)
+                        
+                        if not is_valid:
+                            error_msg = f"字数与原始文本不符：{rendered_original}"
+                            error_updates.append(gr.update(value=error_msg, visible=True))
+                            has_errors = True
+                        else:
+                            error_updates.append(gr.update(value="", visible=False))
+                    else:
+                        error_updates.append(gr.update(value="", visible=False))
+                else:
+                    textbox_updates.append(gr.update())
+                    error_updates.append(gr.update(value="", visible=False))
+            
+            # 补齐剩余的错误提示更新
+            while len(error_updates) < len(error_markdowns):
+                error_updates.append(gr.update(value="", visible=False))
+            
+            if has_errors:
+                gr.Warning("歌词应用成功，但部分句子格式有误，请检查红色提示")
+            else:
+                gr.Info("歌词应用成功！所有句子格式正确")
+            
+            return textbox_updates + error_updates + [new_lines]
+        
+        copy_prompt_btn.click(
+            fn=handle_copy_prompt,
+            inputs=[lines_state],
+            outputs=[]
+        )
+        
+        apply_lyrics_btn.click(
+            fn=handle_apply_lyrics,
+            inputs=[ai_lyrics_input, lines_state, original_lines_state],
+            outputs=[*textboxes, *error_markdowns, lines_state]
+        )
+
         demo.load(
             fn=on_app_load,
             inputs=[model_sel, template_sel],
-            outputs=[speaker, bgm_volume, template_sel, lines_state, offsets_state, per_line_error, full_mixed, *textboxes],
+            outputs=[speaker, bgm_volume, template_sel, lines_state, offsets_state, per_line_error, full_mixed, original_lines_state, *textboxes, *error_markdowns],
         )
 
     return demo
@@ -917,7 +1124,7 @@ def build_ui():
 
 def main():
     demo = build_ui()
-    demo.launch(show_error=True)
+    demo.launch()
 
 
 if __name__ == "__main__":