cortico-world-fish-sing 0.1.3 → 0.1.4

package/README.md

@@ -232,6 +232,21 @@ fish_sing(song="晴天 女声翻唱", pick=3)        # 指定第 3 条
 > 男声原调的歌她唱不了（模型只学过女声音域）。遇到就找女声翻唱版，
 > 别用 `pitch` 硬顶——那只会把音色拉走样。
 
+### 变调推荐（0.1.4）
+
+`pitch` 支持 `"auto"`：分离出源曲人声后，自动对比源曲音域与模型音域
+（来自训练数据，缓存在 `logs/<实验>/range.json`），算出该移几个半音。
+唱完的返回里带 `pitchSuggest.reason`，说明为什么推荐这个值。
+
+### 完成通知（0.1.4）
+
+训练完成/中断时主动说一声。配置 → 完成通知：
+
+- 渠道 `auto`：配了 QQ 目标就走 QQ 文本，失败自动退桌宠
+- `pet`：只走桌宠（`pushEvent`，她会自己接话）
+- `qq`：只走 QQ（失败同样退桌宠）
+- QQ 目标：`group:<群号>` 或 `private:<QQ号>`，留空 = 只用桌宠
+
 ## 命令行（不起桌宠也能用）
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortico-world-fish-sing",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "让她真的开口唱：B 站点歌或本地文件 → 分离 → 换声 → 混音，本机出声或发 QQ 语音条",
   "type": "module",
   "main": "./src/index.ts",

package/src/config.ts

@@ -50,6 +50,14 @@ export interface FishSingConfigSection {
     /** 多条之间的间隔（毫秒），防风控 */
     gapMs: number;
   };
+  notify?: {
+    /** 训练/长任务结束时主动说一声；默认开 */
+    enabled?: boolean;
+    /** auto=配了 QQ 目标就走 QQ（失败退桌宠），否则桌宠 */
+    channel?: 'auto' | 'pet' | 'qq';
+    /** QQ 通知发到哪：group:<群号> 或 private:<QQ号>；空 = 只用桌宠 */
+    qqTarget?: string;
+  };
   worker: {
     /** 自托管根目录；留空 = <数据目录>/runtime（推荐） */
     runtimeRoot: string;
@@ -115,6 +123,11 @@ export const FISHSING_DEFAULTS: FishSingConfigSection = {
     autoStart: true,
     startTimeoutMs: 240000,
   },
+  notify: {
+    enabled: true,
+    channel: 'auto',
+    qqTarget: '',
+  },
 };
 
 const at = (path: string): string => `worlds.${FISHSING_ID}.${path}`;
@@ -297,6 +310,32 @@ export function fishsingConfigGroups(): ConfigGroup[] {
         },
       },
     },
+    {
+      id: `world:${FISHSING_ID}.notify`,
+      owner: `world:${FISHSING_ID}`,
+      schema: {
+        type: 'object',
+        title: '完成通知（训练/长任务结束时主动说一声）',
+        properties: {
+          [at('notify.enabled')]: {
+            type: 'boolean',
+            title: '启用通知',
+            description: '训练完成或中断时主动告知。默认开。',
+          },
+          [at('notify.channel')]: {
+            type: 'string',
+            enum: ['auto', 'pet', 'qq'],
+            title: '渠道',
+            description: 'auto=配了 QQ 目标就走 QQ（失败退桌宠），否则桌宠；pet=只桌宠；qq=只 QQ（失败也退桌宠）。',
+          },
+          [at('notify.qqTarget')]: {
+            type: 'string',
+            title: 'QQ 通知目标',
+            description: 'group:<群号> 或 private:<QQ号>；留空 = 只用桌宠。',
+          },
+        },
+      },
+    },
     {
       id: `world:${FISHSING_ID}.worker`,
       owner: `world:${FISHSING_ID}`,

package/src/library.ts

@@ -16,7 +16,8 @@ export interface SingParams {
   index: string;
   indexRate: number;
   protect: number;
-  pitch: number;
+  /** 半音数；'auto' = worker 分离后按模型音域自动推荐 */
+  pitch: number | 'auto';
   mode: string;
 }
 

package/src/notify.ts

@@ -0,0 +1,68 @@
+/**
+ * 长任务（训练、数据集）结束时的主动通知。
+ *
+ * 渠道：
+ *  · 桌宠 —— host.pushEvent 把事件送进上下文，Coo 会自己接话（她的人设还能顺便营业）；
+ *  · QQ   —— OneBot 文本消息，发到 notify.qqTarget 指定的群/私聊。
+ *
+ * 兜底规则（用户定的）：auto=配了 qqTarget 先走 QQ，失败退桌宠；没配 qqTarget 直接桌宠。
+ * 显式 channel='qq' 时 QQ 失败同样退桌宠——通知这种事，宁可多嘴不能哑火。
+ */
+import { parseTarget, sendText, type OneBotOptions } from './deliver.ts';
+import type { LoggerLike } from './worker.ts';
+
+export interface NotifyConfig {
+  enabled?: boolean;
+  channel?: 'auto' | 'pet' | 'qq';
+  /** QQ 通知发到哪：group:<群号> 或 private:<QQ号>；空 = 只用桌宠 */
+  qqTarget?: string;
+}
+
+export interface NotifyDeps {
+  cfg: NotifyConfig;
+  /** WorldHost.pushEvent 的薄封装；事件进上下文，桌宠自己决定怎么说 */
+  pushEvent: (e: Record<string, unknown>) => unknown;
+  onebot: OneBotOptions;
+  log: LoggerLike;
+}
+
+export interface NotifyOutcome {
+  via: 'pet' | 'qq' | 'off' | 'none';
+  note: string;
+}
+
+export async function notify(deps: NotifyDeps, title: string, body = ''): Promise<NotifyOutcome> {
+  if (deps.cfg.enabled === false) return { via: 'off', note: '通知已关' };
+  const text = body ? `${title}\n${body}` : title;
+
+  const channel = deps.cfg.channel ?? 'auto';
+  const target = parseTarget(String(deps.cfg.qqTarget ?? ''));
+  const wantQQ = channel === 'qq' || (channel === 'auto' && Boolean(target) && Boolean(deps.onebot.httpUrl));
+  if (wantQQ) {
+    if (target && deps.onebot.httpUrl) {
+      try {
+        await sendText(deps.onebot, target, text);
+        return { via: 'qq', note: `已发到${target.label}` };
+      } catch (e) {
+        deps.log.warn(`QQ 通知失败，退回桌宠：${e instanceof Error ? e.message : String(e)}`);
+      }
+    } else {
+      deps.log.warn(`QQ 通知发不了（${!target ? '目标没配' : 'OneBot 地址没配'}），退回桌宠`);
+    }
+  }
+
+  try {
+    await deps.pushEvent({
+      type: 'fishsing.notify',
+      origin: 'internal',
+      source: 'fish-sing',
+      senderKey: 'fish-sing:notify',
+      ts: new Date().toISOString(),
+      text,
+      meta: { title },
+    });
+    return { via: 'pet', note: '已告诉桌宠' };
+  } catch (e) {
+    return { via: 'none', note: `桌宠通知也失败：${e instanceof Error ? e.message : String(e)}` };
+  }
+}

package/src/sing.ts

@@ -52,7 +52,8 @@ export interface SingRequest {
   song: string;
   to?: string;
   mode?: 'full' | 'vocals';
-  pitch?: number;
+  /** 半音数；'auto' = 分离后按模型音域自动推荐（推荐，能挡住"男歌女唱忘移调"的翻车） */
+  pitch?: number | 'auto';
   indexRate?: number;
   protect?: number;
   start?: number;
@@ -222,7 +223,7 @@ export async function singSong(req: SingRequest, deps: SingDeps): Promise<SingRe
     index: deps.voice.index,
     indexRate: Number(req.indexRate ?? deps.voice.indexRate),
     protect: Number(req.protect ?? deps.voice.protect),
-    pitch: Number(req.pitch ?? deps.voice.pitch),
+    pitch: req.pitch === 'auto' ? 'auto' : Number(req.pitch ?? deps.voice.pitch),
     mode: req.mode ?? deps.voice.mode,
   };
 
@@ -273,6 +274,8 @@ export async function singSong(req: SingRequest, deps: SingDeps): Promise<SingRe
         }
       });
       info = job.result ?? {};
+      const suggest = info.pitchSuggest as { pitch: number; reason: string } | undefined;
+      if (suggest?.reason) deps.log.info(`变调推荐：${suggest.reason}`);
       const raw = String(info.output ?? '');
       if (!raw) throw new Error('worker 没给出输出文件');
 
@@ -345,7 +348,11 @@ export async function singSong(req: SingRequest, deps: SingDeps): Promise<SingRe
     }
 
     const elapsed = Math.round((Date.now() - t0) / 1000);
-    const head = `唱完了《${src.title}》，${human(totalSec)}${cached ? '（走缓存）' : `，用了 ${elapsed} 秒`}`;
+    const suggest = info.pitchSuggest as { pitch: number; reason: string } | undefined;
+    const autoNote = params.pitch === 'auto' && suggest
+      ? `；变调 ${suggest.pitch >= 0 ? '+' : ''}${suggest.pitch}（${suggest.reason}）`
+      : '';
+    const head = `唱完了《${src.title}》，${human(totalSec)}${cached ? '（走缓存）' : `，用了 ${elapsed} 秒`}${autoNote}`;
     const tail = delivered.length ? `；${delivered.join('，')}` : '；没投递（文件进了作品库，可以用 fish_sing_library 回放）';
     const warn = problems.length ? `；但${problems.join('；')}` : '';
     return {
@@ -354,6 +361,7 @@ export async function singSong(req: SingRequest, deps: SingDeps): Promise<SingRe
       detail: {
         title: src.title, bvid: src.bvid, duration: totalSec, segments: Math.ceil(totalSec / deps.maxSegmentSec),
         cached, elapsed, file: mp3, params, delivered, problems,
+        pitchSuggest: info.pitchSuggest,
       },
     };
   } catch (e) {

package/src/world.ts

@@ -68,6 +68,7 @@ import { duration, type FfmpegDeps } from './audio.ts';
 import { Player } from './deliver.ts';
 import { dropFromLibrary, listLibrary, loadLibrary, pruneCache, renameInLibrary, type LibraryOptions } from './library.ts';
 import { singSong, type SingDeps } from './sing.ts';
+import { notify } from './notify.ts';
 import { WorkerClient } from './worker.ts';
 
 const ENV_PROMPT_FILE = fileURLToPath(new URL('../ENV_PROMPT.md', import.meta.url));
@@ -291,6 +292,23 @@ export class FishSingWorld implements World {
     return String(this.opts.cfg.send?.token ?? '').trim();
   }
 
+  /** 长任务结果主动说一声：QQ 配了走 QQ（失败退桌宠），没配就桌宠。详见 notify.ts。 */
+  private notifyEvent(title: string, body = ''): Promise<unknown> {
+    return notify(
+      {
+        cfg: this.opts.cfg.notify ?? {},
+        pushEvent: (e) => this.host?.pushEvent(e as never),
+        onebot: { httpUrl: String(this.opts.cfg.send?.httpUrl ?? ''), token: this.onebotToken() },
+        log: this.host?.log ?? { info: () => undefined, warn: () => undefined },
+      },
+      title,
+      body,
+    ).then((r) => {
+      if (r.via !== 'off') this.host?.log.info(`[fish-sing] 通知（${r.via}）：${r.note}`);
+      return r;
+    });
+  }
+
   private deps(): SingDeps {
     const cfg = this.opts.cfg;
     return {
@@ -394,7 +412,7 @@ export class FishSingWorld implements World {
           song: { type: 'string', description: '歌名（可带歌手）、BV 号、B 站链接，或本机音频文件绝对路径' },
           to: { type: 'string', description: 'local / group:<群号> / private:<QQ号> / both；不填按配置默认' },
           mode: { type: 'string', enum: ['full', 'vocals'], description: 'full=带伴奏；vocals=清唱（更容易听出音色）' },
-          pitch: { type: 'number', description: '移调半音；男歌女唱常要 +2~+4，默认 0' },
+          pitch: { type: ['number', 'string'], description: "移调半音；'auto'=按模型音域自动推荐（推荐，默认选项）；男歌女唱常要 +2~+4" },
           indexRate: { type: 'number', description: '音色检索强度 0~1；越大越像本人，0.9 以上咬字可能歪' },
           protect: { type: 'number', description: '气声保护 0~0.5；齿音发毛就调高到 0.4~0.45' },
           start: { type: 'number', description: '从第几秒开始唱（只想唱副歌时用）' },
@@ -423,7 +441,8 @@ export class FishSingWorld implements World {
             song: String(args.song ?? ''),
             to: args.to === undefined ? undefined : String(args.to),
             mode: args.mode === 'vocals' ? 'vocals' : args.mode === 'full' ? 'full' : undefined,
-            pitch: args.pitch === undefined ? undefined : Number(args.pitch),
+            pitch: args.pitch === undefined ? undefined
+              : String(args.pitch).toLowerCase() === 'auto' ? 'auto' : Number(args.pitch),
             indexRate: args.indexRate === undefined ? undefined : Number(args.indexRate),
             protect: args.protect === undefined ? undefined : Number(args.protect),
             start: args.start === undefined ? undefined : Number(args.start),
@@ -963,12 +982,14 @@ export class FishSingWorld implements World {
               this.host?.log.info(`[fish-sing] 已清理中间档：${done.remove.length} 个 / ${done.freedMb} MB`);
             }
           }
+          void this.notifyEvent(`训练完成：${exp}`, `${epochs} 轮全部完成。${job.msg}`);
         })
         .catch((e: unknown) => {
           job.state = 'error';
           job.error = e instanceof Error ? e.message : String(e);
           job.msg = job.error;
           this.host?.log.warn(`[fish-sing] 训练中断：${job.error}`);
+          void this.notifyEvent(`训练中断：${exp}`, job.error);
         });
       return {
         text: `开始训练「${exp}」：${epochs} 轮 / batch ${batch} / ${m.stats.kept} 片${

package/worker/engine.py

@@ -16,6 +16,7 @@ fish-sing worker 的核心：常驻 RVC + 切片换声 + 分离/混音。
 """
 
 import json
+import math
 import os
 import re
 import shutil
@@ -522,19 +523,100 @@ class SingEngine:
 
     # -- 一键流程 --------------------------------------------------
 
+    # -- 音域与变调推荐 ---------------------------------------------
+
+    def _f0_stats(self, path: Path) -> Optional[dict]:
+        """一段人声的音域统计。分析失败或人声太少返回 None。"""
+        try:
+            import librosa
+            y, sr = librosa.load(str(path), sr=16000, mono=True)
+            f0, vflag, _ = librosa.pyin(y, fmin=80.0, fmax=800.0, sr=sr, frame_length=1024)
+            v = f0[vflag & ~np.isnan(f0)]
+            if v.size < 50:
+                return None
+            q = lambda p: float(np.percentile(v, p))
+            return {"p5": q(5), "p25": q(25), "median": q(50), "p95": q(95), "frames": int(v.size)}
+        except Exception as e:  # noqa: BLE001
+            log(f"音域分析失败（{path.name}）：{e}")
+            return None
+
+    def model_range(self, model: str) -> Optional[dict]:
+        """模型（训练数据）的音域。缓存在 logs/<exp>/range.json，训完第一次唱歌时现算一次。"""
+        exp = str(model).removesuffix(".pth")
+        log_dir = RVC_ROOT / "logs" / exp
+        cache = log_dir / "range.json"
+        try:
+            if cache.is_file():
+                d = json.loads(cache.read_text(encoding="utf-8"))
+                if d.get("frames", 0) > 0:
+                    return d
+        except Exception:  # noqa: BLE001
+            pass
+        gt = log_dir / "0_gt_wavs"
+        if not gt.is_dir():
+            return None
+        files = sorted(gt.glob("*.wav"))
+        if not files:
+            return None
+        # 隔段采样，覆盖整首歌而不是只听开头
+        step = max(1, len(files) // 8)
+        picked = files[::step][:8]
+        stats = [s for s in (self._f0_stats(f) for f in picked) if s]
+        if not stats:
+            return None
+        merged = {k: sum(s[k] for s in stats) / len(stats) for k in ("p5", "p25", "median", "p95")}
+        merged["frames"] = sum(s["frames"] for s in stats)
+        merged["files"] = len(stats)
+        merged["computedAt"] = time.time()
+        try:
+            cache.write_text(json.dumps(merged, ensure_ascii=False), encoding="utf-8")
+        except Exception:  # noqa: BLE001
+            pass
+        return merged
+
+    @staticmethod
+    def suggest_pitch(source: Optional[dict], model: Optional[dict]) -> dict:
+        """按低音端（P5）对齐：源曲比模型能唱的更低就往上抬，更高就往下压。"""
+        out = {"pitch": 0, "reason": "", "source": source, "model": model}
+        if not source or not model:
+            out["reason"] = "缺音域数据，保持 0"
+            return out
+        sp, mp = source.get("p5", 0), model.get("p5", 0)
+        if sp <= 0 or mp <= 0:
+            out["reason"] = "音域数据无效，保持 0"
+            return out
+        semi = 12 * math.log2(mp / sp)  # >0：源曲低音低于模型下限
+        if semi > 1.0:
+            pitch = min(6, math.ceil(semi))
+            out["reason"] = f"源曲低音 {sp:.0f}Hz 低于模型下限 {mp:.0f}Hz（差 {semi:.1f} 半音），建议 +{pitch}"
+        elif semi < -1.5:
+            pitch = max(-6, math.floor(semi))
+            out["reason"] = f"源曲低音 {sp:.0f}Hz 高于模型下限 {mp:.0f}Hz（差 {-semi:.1f} 半音），建议 {pitch}"
+        else:
+            pitch = 0
+            out["reason"] = f"音域匹配（差 {semi:.1f} 半音），保持 0"
+        out["pitch"] = pitch
+        return out
+
     def song(self, src: Path, work: Path, *, separate: bool = True, mode: str = "full",
-             pitch: int = 0, index_rate: float = 0.75, protect: float = 0.33,
+             pitch: "int | str" = 0, index_rate: float = 0.75, protect: float = 0.33,
              progress: Optional[Callable[[float, str], None]] = None,
              cancel: Optional[threading.Event] = None) -> dict:
         """
         整首歌：分离 → 换声 → 混音。
         mode: full=带伴奏 / vocals=只要人声（清唱）/ mixed 同 full 但保留中间文件
+        pitch: 半音数；'auto' = 分离后按源曲与模型音域自动推荐。
         """
         cancel = cancel or threading.Event()
         work.mkdir(parents=True, exist_ok=True)
         t0 = time.time()
         report = progress or (lambda p, m: None)
 
+        auto_pitch = isinstance(pitch, str) and pitch.strip().lower() == "auto"
+        suggestion: Optional[dict] = None
+        if auto_pitch:
+            pitch = 0
+
         vocal_src = src
         inst = None
         if separate:
@@ -544,6 +626,12 @@ class SingEngine:
         else:
             vocal_src = to_wav(src, work / "src.wav")
 
+        if auto_pitch:
+            report(0.15, "分析音域，推荐变调")
+            suggestion = self.suggest_pitch(self._f0_stats(vocal_src), self.model_range(self.model))
+            pitch = int(suggestion["pitch"])
+            log(f"变调推荐：{suggestion['reason']}")
+
         report(0.2, "加载模型" if not self.ready else "开始换声")
         conv = work / "vocals_converted.wav"
         info = self.convert(vocal_src, conv, pitch=pitch, index_rate=index_rate,
@@ -560,7 +648,7 @@ class SingEngine:
             mix_info = self.mix(conv, inst, out)
 
         report(1.0, "完成")
-        return {
+        result = {
             "output": str(out),
             "vocals": str(conv),
             "inst": str(inst) if inst else "",
@@ -569,6 +657,9 @@ class SingEngine:
             "samplerate": mix_info.get("sr", info["sr"]),
             "elapsedSec": round(time.time() - t0, 1),
         }
+        if suggestion is not None:
+            result["pitchSuggest"] = suggestion
+        return result
 
 
 # ---------------------------------------------------------------- 自检

package/worker/server.py

@@ -121,7 +121,7 @@ def run_job(jid: str, kind: str, params: dict, cancel: threading.Event) -> dict:
             src, work,
             separate=bool(params.get("separate", True)),
             mode=str(params.get("mode", "full")),
-            pitch=int(params.get("pitch", 0)),
+            pitch=params.get("pitch", 0),
             index_rate=float(params.get("index_rate", 0.75)),
             protect=float(params.get("protect", 0.33)),
             progress=progress,