RvcPyInfer 0.1.0__py3-none-any.whl

RvcPyInfer/audio/audio_utils.py

@@ -0,0 +1,346 @@
+from typing import Any, Literal
+
+import numpy as np
+import samplerate
+from numpy.typing import NDArray
+
+from ..type_alist import Audio
+
+
+def reSR(orig: Audio, 
+         target_sr: int, 
+         algorithm: Literal["sinc_best", "sinc_medium", "sinc_fastest", "linear", "zero_order_hold"] = "sinc_medium") -> Audio:
+    orig_data, orig_sr = orig
+    ratio = target_sr / orig_sr
+    if target_sr == orig_sr:
+        target_data = orig_data
+    else:
+        target_data: NDArray[Any] = samplerate.resample(orig_data, ratio, algorithm)
+        assert isinstance(target_data, np.ndarray), "这库不对吧？返回值不是 ndarray"
+    target_data = target_data.astype(np.float32)
+    return target_data, target_sr
+
+def frame_rms(audio: Audio, frame_len: int = 20, hop_len: int = 10) -> NDArray[np.float32]:
+    """
+    分帧计算RMS能量
+    
+    参数:
+        audio: 输入音频
+        frame_len: 帧长度(ms)
+        hop_len: 帧移(ms)
+        
+    返回:
+        rms_values: 每帧的RMS值
+    """
+    data, sr = audio
+
+    frame_size = int(round(frame_len * sr / 1000))
+    hop_size = int(round(hop_len * sr / 1000))
+
+    if len(data) < frame_size:
+        return np.array([np.sqrt(np.mean(data ** 2))], dtype=np.float32)
+
+    shape = ((len(data) - frame_size) // hop_size + 1, frame_size)
+    strides = (data.strides[0] * hop_size, data.strides[0])
+    frames = np.lib.stride_tricks.as_strided(data, shape=shape, strides=strides)
+    
+    rms_values = np.sqrt(np.mean(frames ** 2, axis=1))
+    
+    return rms_values
+
+def rms_frame_match(source: Audio,
+                    target: Audio,
+                    frame_len: int = 20,
+                    hop_len: int = 10,
+                    mix: float = 1.0,
+                    eps: float = 1e-8) -> Audio:
+    """
+    将 source 的逐帧 RMS 包络匹配到 target。
+
+    参数:
+        source:    源音频（将被增益调整）
+        target:    目标音频（提取 RMS 包络的参考）
+        frame_len: 帧长度(ms)
+        hop_len:   帧移(ms)
+        mix:       匹配系数，0.0=直接输出源音频，1.0=完全匹配目标RMS
+        eps:       防除零，和检测 mix 是否为0
+
+    返回:
+        Audio: RMS 匹配后的音频
+    """
+    def _smooth_gain[T: np.floating](gain: NDArray[T], smooth_window: int = 15) -> NDArray[T]:
+        """边缘延伸 padding 后卷积，常数增益卷积后仍为常数"""
+        if smooth_window <= 1 or len(gain) <= 1:
+            return gain
+        kernel = np.ones(smooth_window) / smooth_window
+        pad = smooth_window // 2
+        padded = np.concatenate([
+            np.full(pad, gain[0]),
+            gain,
+            np.full(pad, gain[-1])
+        ])
+        return np.convolve(padded, kernel, mode='valid').astype(gain.dtype)
+    
+    if mix < eps: # 因为太小了，几乎没有更改
+        return source
+
+    src_data, src_sr = source
+    _, tgt_sr = target
+
+    assert src_sr == tgt_sr, "采样率必须一致"
+
+    N = len(src_data)
+
+    # ---- 1. 逐帧 RMS ----
+    src_rms = frame_rms(source, frame_len, hop_len)
+    tgt_rms = frame_rms(target, frame_len, hop_len)
+    assert len(src_rms) == len(tgt_rms), "帧数必须一致"
+
+    # ---- 2. 逐帧增益 + 匹配系数混合 ----
+    gain = tgt_rms / (src_rms + eps)
+    gain = 1.0 + mix * (gain - 1.0)
+
+    # ---- 3. 增益曲线平滑（边缘延伸 padding，无边界失真）----
+    gain = _smooth_gain(gain)
+
+    # ---- 4. 帧参数 ----
+    frame_size = int(round(frame_len * src_sr / 1000))
+    hop_size = int(round(hop_len * src_sr / 1000))
+    n_frames = len(gain)
+
+    # ---- 5. 逐帧增益 → 逐样本增益（overlap-add 归一化）----
+    sample_gain = np.zeros(N, dtype=np.float64)
+    norm = np.zeros(N, dtype=np.float64)
+    for i in range(n_frames):
+        start = i * hop_size
+        end = min(start + frame_size, N)
+        sample_gain[start:end] += gain[i]
+        norm[start:end] += 1.0
+    norm[norm == 0] = 1.0
+    sample_gain /= norm
+
+    # ---- 6. 尾部 ----
+    if n_frames > 0:
+        last_end = (n_frames - 1) * hop_size + frame_size
+        if last_end < N:
+            sample_gain[last_end:] = gain[-1]
+
+    # ---- 7. 应用增益 ----
+    output = src_data * sample_gain
+    return (output.astype(np.float32), src_sr)
+
+def rms_to_db[T: np.floating](rms_values: NDArray[T], ref: float = 1.0) -> NDArray[T]:
+    """
+    将RMS值转换为dB
+    
+    参数:
+        rms_values: RMS值数组
+        ref: 参考值 (1.0 表示归一化音频的 dBFS)
+        min_db: 最小dB值 (防止静音时出现 -inf)
+        
+    返回:
+        db_values: 对应的dB值
+    """
+    # 防止 log(0) 错误：给一个极小值 epsilon
+    epsilon = 1e-10
+    
+    # 公式: 20 * log10(rms / ref)
+    db_values = 20 * np.log10(np.maximum(rms_values, epsilon) / ref)
+    
+    return db_values
+
+def split_by_silence(
+    audio: Audio,
+    *,
+    frame_len: int = 20,
+    hop_len: int = 10,
+    silence_thresh_db: float = -35,
+    ref: float = 1.0,
+    min_silence_duration_ms: float = 800.0,
+    max_transition_ms: float = 50
+) -> list[tuple[Audio, bool]]:
+    """
+    按静音切片，返回所有片段（含静音段）。
+
+    参数:
+        audio: 输入音频
+        frame_len: 帧长度
+        hop_len: 帧移
+        silence_thresh_db: 静音阈值
+        ref: RMS参考值
+        min_silence_duration_ms: 最短静音持续时间。小于此值的静音段将被忽略。请注意，这不代表返回的静音段一定大于这个值
+        max_transition_ms: 语音段的过渡时间，不得大于 0.5*min_silence_duration_ms
+        
+    返回: List[Tuple[Audio, bool]]
+        - Audio: 切片后的音频
+        - bool:  True = 该段为静音, False = 该段为语音
+    """
+    data, sr = audio
+    data = np.asarray(data)
+
+    # 1. 复用 frame_rms + rms_to_db
+    rms_values = frame_rms(audio, frame_len=frame_len, hop_len=hop_len)
+    db_values  = rms_to_db(rms_values, ref=ref)
+    is_silence = db_values < silence_thresh_db
+    n_frames   = len(is_silence)
+
+    # 2. 找静音区间起止帧（padding False 保证首尾闭合）
+    padded = np.concatenate([[False], is_silence, [False]])
+    diff   = np.diff(padded.astype(np.int8))
+    sil_starts = np.where(diff == 1)[0]    # 静音开始帧
+    sil_ends   = np.where(diff == -1)[0]   # 静音结束帧
+
+    if len(sil_starts) > 0 and min_silence_duration_ms > 0:
+        # 计算最短静音所需帧数 (向上取整，至少1帧)
+        min_silence_frames = max(1, int(np.ceil(min_silence_duration_ms / hop_len)))
+        
+        # 计算每个静音段的持续帧数
+        sil_lengths = sil_ends - sil_starts
+        
+        # 过滤出长度达标的静音段
+        valid_mask = sil_lengths >= min_silence_frames
+        sil_starts = sil_starts[valid_mask]
+        sil_ends = sil_ends[valid_mask]
+
+    # 3. 交错排列得到所有边界
+    #    bounds = [0, ss0, se0, ss1, se1, ..., n_frames]
+    #    偶数段索引 → 语音(False), 奇数段索引 → 静音(True)
+    bounds = np.empty(len(sil_starts) + len(sil_ends) + 2, dtype=np.int64)
+    bounds[0]  = 0
+    bounds[-1] = n_frames
+    if len(sil_starts) > 0:
+        bounds[1:-1:2] = sil_starts
+        bounds[2:-1:2] = sil_ends
+
+    # 4. 帧索引 → 采样索引
+    hop_size = int(round(hop_len * sr / 1000))
+    sample_bounds = bounds * hop_size
+    sample_bounds[-1] = len(data)  # 末尾对齐信号终点
+
+    if bounds[-1] == bounds[-2]:
+        sample_bounds[-2] = len(data) # 说明实际上没有这个段，这是靠 pad 出来的段
+
+    # 5. 调整索引形成过渡
+    max_transition_size = max_transition_ms * sr // 1000
+    s = sample_bounds[1:-1:2]  
+    e = sample_bounds[2::2]   
+    sil_size = e - s
+    voice_size = sample_bounds[1::2] - sample_bounds[0:-1:2]
+    # 因为前面修正 pad 逻辑的时候会产生 0 长切片，这里不能对 0 长切片调整（因为那没有意义）
+    voice_mask = voice_size > 0 
+    start_mask = voice_mask[:-1]
+    end_mask = voice_mask[1:]
+    transition_size = np.minimum(max_transition_size, sil_size // 2)
+    s[start_mask] = s[start_mask] + transition_size[start_mask]
+    e[end_mask] = e[end_mask] - transition_size[end_mask]
+
+    # 6. 切片前的合并
+    # 6.1 处理零长
+    is_sil = np.empty(len(sample_bounds) - 1, dtype=np.bool)
+    is_sil[1::2] = True
+    is_sil[0::2] = False
+    index_diff = np.diff(sample_bounds)
+    index_mask = index_diff > 0 # 0 长丢掉
+    index_mask = np.pad(index_mask, [1, 0], mode="constant", constant_values=True)
+    is_sil = is_sil[index_mask[1:]]
+    sample_bounds = sample_bounds[index_mask]
+    # 6.2 合并同类项
+    sil_mask = is_sil[:-1] != is_sil[1:] 
+    sil_mask = np.pad(sil_mask, [1, 1], mode="constant", constant_values=True)
+    is_sil = is_sil[sil_mask[:-1]]
+    sample_bounds = sample_bounds[sil_mask]
+
+    # 7. 切片！
+    return [((data[sample_bounds[i]:sample_bounds[i+1]], sr), is_sil[i]) for i in range(len(sample_bounds) - 1)]
+
+def split_by_max_len_with_overlap(
+        audio: Audio,
+        *,
+        max_len: int = 30,
+        overlap_len: int = 5
+    ) -> list[Audio]:
+    data, sr = audio
+    max_size = sr * max_len
+    
+    if overlap_len < 0 or overlap_len >= max_len or len(data) <= max_size:
+        return [audio]
+        
+    overlap_size = sr * overlap_len
+    step = max_size - overlap_size  # 每次向前推进的步长
+
+    res: list[Audio] = []
+    offset = 0
+    
+    while offset < len(data):
+        end = min(offset + max_size, len(data))
+        res.append((data[offset:end], sr))
+        
+        if end == len(data):
+            break
+            
+        offset += step
+        
+    return res
+
+def crossfade(
+        audios: list[Audio],
+        *,
+        overlap_len: int = 5
+    ) -> Audio:
+    if len(audios) == 0:
+        raise ValueError("音频列表为空")
+    elif len(audios) == 1:
+        return audios[0]
+
+    _, sr = audios[0]
+    datas = [d for d, _ in audios]
+    overlap_size = sr * overlap_len
+    fade_in = np.linspace(0.0, 1.0, overlap_size)
+    fade_out = np.linspace(1.0, 0.0, overlap_size)
+
+    data_list = []
+    # 第一个
+    data_list.append(datas[0][:-overlap_size])
+    data_list.append(datas[0][-overlap_size:] * fade_out + datas[1][:overlap_size] * fade_in)
+
+    # 中间
+    for i in range(1, len(datas) - 1):
+        curr = datas[i]
+        next = datas[i + 1]
+        data_list.append(curr[overlap_size:-overlap_size])
+        data_list.append(curr[-overlap_size:] * fade_out + next[:overlap_size] * fade_in)
+
+    # 最后一个
+    data_list.append(datas[-1][overlap_size:])
+
+    return np.concatenate(data_list), sr
+
+def copy_audio(audios: list[Audio]) -> list[Audio]:
+    for i in range(1, len(audios)):
+        audios[i] = (audios[i][0].copy(), audios[i][1])
+    return audios
+
+def print_segments_info(segments: list[tuple[Audio, bool]]) -> None:
+    """
+    打印切片结果的时间戳和静音标注。
+    
+    参数:
+        segments: split_by_silence 函数的返回结果
+    """
+    print(f"{'序号':<4} | {'开始时间 (s)':<12} | {'结束时间 (s)':<12} | {'时长 (s)':<10} | {'类型'}")
+    print("-" * 60)
+    
+    current_time = 0.0
+    
+    for i, ((seg_data, sr), is_sil) in enumerate(segments):
+        # 计算当前片段的时长
+        duration = len(seg_data) / sr
+        start_time = current_time
+        end_time = start_time + duration
+        
+        # 更新时间游标
+        current_time = end_time
+        
+        # 格式化输出
+        tag = "[静音]" if is_sil else "[语音]"
+        print(f"{i:<4} | {start_time:<12.3f} | {end_time:<12.3f} | {duration:<10.3f} | {tag}")

RvcPyInfer/cli.py

@@ -0,0 +1,112 @@
+import argparse
+import sys
+
+from .InferProviders import InferProviders
+from .RvcContext import RvcContext
+
+
+def str_to_provider(provider_str: str) -> InferProviders:
+    """将命令行字符串映射为 InferProviders 枚举"""
+    if provider_str == "default":
+        return InferProviders.default()
+    elif provider_str == "cuda":
+        return InferProviders.CUDA
+    elif provider_str == "dml":
+        return InferProviders.DML
+    elif provider_str == "ort_cpu":
+        return InferProviders.ORT_CPU
+    elif provider_str == "openvino_auto":
+        return InferProviders.OPENVINO_AUTO
+    elif provider_str == "openvino_cpu":
+        return InferProviders.OPENVINO_CPU
+    elif provider_str == "openvino_gpu":
+        return InferProviders.OPENVINO_GPU
+    else:
+        raise ValueError(f"未知的 Provider: {provider_str}")
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="RVC 语音转换命令行工具")
+    
+    # --- 必填参数 ---
+    parser.add_argument("--vec-model", type=str, required=True, help="ContentVec 特征提取模型路径 (.onnx)")
+    parser.add_argument("--gen-model", type=str, required=True, help="RVC 生成模型路径 (.onnx)")
+    parser.add_argument("--gen-model-sr", type=int, required=True, help="生成模型采样率 (如 40000, 48000)")
+    parser.add_argument("-i", "--inputs", nargs="+", type=str, required=True, help="输入音频文件路径 (可传入多个)")
+    parser.add_argument("-o", "--outputs", nargs="+", type=str, required=True, help="输出音频文件路径 (数量必须与输入一致)")
+    
+    # --- 推理引擎 ---
+    parser.add_argument("--provider", type=str, default="default", 
+                        choices=["default", "cuda", "dml", "ort_cpu", "openvino_auto", "openvino_cpu", "openvino_gpu"],
+                        help="推理后端 (默认自动检测)")
+    
+    # --- 基础设置 ---
+    parser.add_argument("--sid", type=int, default=0, help="说话人 ID")
+    parser.add_argument("--seed", type=int, default=1234, help="随机种子")
+    
+    # --- 特征索引 ---
+    parser.add_argument("--index-path", type=str, default=None, help="特征索引文件路径")
+    parser.add_argument("--index-rate", type=float, default=0.33, help="特征索引比率 (0-1)")
+    parser.add_argument("--index-k", type=int, default=8, help="检索的最近特征数量")
+    
+    # --- f0 提取 ---
+    parser.add_argument("--f0-method", type=str, default="dio", help="f0 提取算法 (如 dio, pm, rmvpe, fcpe 等)")
+    parser.add_argument("--pitch", type=float, default=0, help="升降调 (半音)")
+    parser.add_argument("--f0-min", type=float, default=50, help="最低 f0")
+    parser.add_argument("--f0-max", type=float, default=1100, help="最高 f0")
+    
+    # --- 强制切片与交叉淡化 ---
+    parser.add_argument("--slice-max-len", type=int, default=30, help="最大切片长度 (秒)")
+    parser.add_argument("--slice-overlap-len", type=int, default=5, help="切片交叉淡化长度 (秒)")
+    
+    # --- 静音切片 ---
+    parser.add_argument("--silence-thresh-db", type=float, default=-40, help="静音阈值")
+    parser.add_argument("--silence-min-duration", type=float, default=800.0, help="最小静音时长")
+    parser.add_argument("--silence-max-transition", type=float, default=100.0, help="最大过渡时长")
+    
+    args = parser.parse_args()
+
+    # 校验输入输出数量
+    if len(args.inputs) != len(args.outputs):
+        print("错误: 输入音频数量与输出音频数量不一致！", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        # 1. 初始化推理 Provider 和 Context
+        print(f"正在初始化推理环境，使用 Provider: {args.provider} ...")
+        providers = str_to_provider(args.provider)
+        context = RvcContext(providers=providers)
+        
+        # 2. 构建 InferTask
+        print("正在构建推理任务...")
+        task = context.build_task(
+            args.vec_model,
+            args.gen_model,
+            args.gen_model_sr,
+            *args.inputs,
+            sid=args.sid,
+            seed=args.seed,
+            index_path=args.index_path,
+            index_rate=args.index_rate,
+            index_k=args.index_k,
+            f0extract_algorithm=args.f0_method,
+            f0_up_semitone=args.pitch,
+            f0_min=args.f0_min,
+            f0_max=args.f0_max,
+            slice_max_len=args.slice_max_len,
+            slice_overlap_len=args.slice_overlap_len,
+            silence_thresh_db=args.silence_thresh_db,
+            silence_min_silence_duration_ms=args.silence_min_duration,
+            silence_max_transition_ms=args.silence_max_transition,
+        )
+        
+        # 3. 执行推理并保存
+        print("开始推理，请稍候...")
+        task.run_and_save(*args.outputs)
+        print(f"推理完成！音频已保存至: {', '.join(args.outputs)}")
+        
+    except Exception as e:
+        print(f"推理过程中发生错误: {e}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

RvcPyInfer/error/InferEnvError.py

@@ -0,0 +1,2 @@
+class InferEnvError(Exception):
+    pass

RvcPyInfer/error/NotSupportedAlgorithmError.py

@@ -0,0 +1,2 @@
+class NotSupportedAlgorithmError(Exception):
+    pass

RvcPyInfer/f0_utils.py

@@ -0,0 +1,125 @@
+import math
+from collections.abc import Callable
+from typing import overload
+
+import numpy as np
+import pyworld as pw
+from numpy.typing import NDArray
+
+from .error.NotSupportedAlgorithmError import NotSupportedAlgorithmError
+from .type_alist import Audio, F0ExtractAlgorithm
+
+
+def interpolate_f0[T: np.floating](f0: NDArray[T]) -> NDArray[T]:
+    """
+    对F0进行插值处理
+    """
+    nonzero_idx = np.where(f0 > 0.0)[0]
+    if len(nonzero_idx) == 0:
+        return f0
+    all_idx = np.arange(len(f0))
+    ip_data = np.interp(all_idx, nonzero_idx, f0[nonzero_idx])
+    ip_data = ip_data.astype(f0.dtype)
+    return ip_data
+
+def dio(audio: Audio, 
+        p_len: int, 
+        f0_min: float = 50.0, 
+        f0_max: float = 1100.0,
+        allowed_range: float = 0.1,
+        channels_in_octave: float = 2.0) -> NDArray[np.float32]:
+    data, sr = audio
+    data = data.astype(np.float64)
+    frame_period = len(data) * 1000 / sr / p_len
+    f0, t = pw.dio( # pyright: ignore[reportAttributeAccessIssue]
+        data,
+        sr,
+        f0_floor=f0_min,
+        f0_ceil=f0_max,
+        frame_period=frame_period,
+        allowed_range=allowed_range,
+        channels_in_octave=channels_in_octave
+    ) 
+    f0 = pw.stonemask( # pyright: ignore[reportAttributeAccessIssue]
+        data,
+        f0, t,
+        sr
+    )
+    assert isinstance(f0, np.ndarray) and isinstance(t, np.ndarray), "pyworld 输出类型应是 NDArray" # 给类型注解看的
+    f0, t = f0.astype(np.float32), t.astype(np.float32)
+    f0 = np.round(f0, 1) # 不知道，但原项目就是这么做了，我只是一个做 onnx 推理的我怎么知道为什么要这样做
+    f0 = interpolate_f0(f0)
+    # 一般来说不太可能会发生长度不匹配的情况，但防御性编程
+    pad_len = p_len - len(f0)
+    if pad_len == 0:
+        return f0
+    elif pad_len > 0:
+        return np.pad(f0, [0, pad_len], mode="constant", constant_values=f0[-1])
+    else:
+        return f0[:p_len]
+         
+
+def harvest(audio: Audio, 
+        p_len: int, 
+        f0_min: float = 50.0, 
+        f0_max: float = 1100.0) -> NDArray[np.float32]:
+    data, sr = audio
+    data = data.astype(np.float64)
+    frame_period = len(data) * 1000 / sr / p_len
+    f0, t = pw.harvest( # pyright: ignore[reportAttributeAccessIssue]
+        data,
+        sr,
+        f0_floor=f0_min,
+        f0_ceil=f0_max,
+        frame_period=frame_period
+    ) 
+    f0 = pw.stonemask( # pyright: ignore[reportAttributeAccessIssue]
+        data,
+        f0, t,
+        sr
+    )
+    assert isinstance(f0, np.ndarray) and isinstance(t, np.ndarray), "pyworld 输出类型应是 NDArray" # 给类型注解看的
+    f0, t = f0.astype(np.float32), t.astype(np.float32)
+    f0 = interpolate_f0(f0)
+    # 一般来说不太可能会发生长度不匹配的情况，但防御性编程
+    pad_len = p_len - len(f0)
+    if pad_len == 0:
+        return f0
+    elif pad_len > 0:
+        return np.pad(f0, [0, pad_len], mode="constant", constant_values=f0[-1])
+    else:
+        return f0[:p_len]
+    
+def build_f0extract_func(algorithm: F0ExtractAlgorithm,
+        f0_min: float = 50.0, 
+        f0_max: float = 1100.0,
+        allowed_range: float = 0.1,
+        channels_in_octave: float = 2.0) -> Callable[[Audio, int], NDArray[np.float32]]:
+    if algorithm == "dio":
+        return lambda a, p_l: dio(a, p_l, f0_min=f0_min, f0_max=f0_max, allowed_range=allowed_range, channels_in_octave=channels_in_octave)
+    elif algorithm == "harvest":
+        return lambda a, p_l: harvest(a, p_l, f0_min=f0_min, f0_max=f0_max)
+    else:
+        raise NotSupportedAlgorithmError(f"不支持的 f0 提取算法: {algorithm}")
+     
+def apply_rise_tone[T: np.floating](f0: NDArray[T], up_semitone: float) -> NDArray[T]:
+    return f0 * 2.0 ** (up_semitone / 12.0)
+
+@overload
+def f0_to_mel(f0: float) -> float:
+    ...
+@overload
+def f0_to_mel[T: np.floating](f0: NDArray[T]) -> NDArray[T]:
+    ...
+def f0_to_mel[T: np.floating](f0: float | NDArray[T]) -> float | NDArray[T]:
+    if isinstance(f0, float):
+        return 1127.0 * math.log(1 + f0 / 700.0)
+    else:
+        return 1127 * np.log(1 + f0 / 700)
+    
+def normalized_mel[T: np.floating](mel: NDArray[T], mel_min: float = f0_to_mel(50.0), mel_max: float = f0_to_mel(1100.0)) -> NDArray[T]:
+    mel[mel > 0.0] = (mel[mel > 0.0] - mel_min) * 254.0 / (
+        mel_max - mel_min
+    ) + 1.0
+    mel = np.clip(mel, 1, 255)
+    return mel

RvcPyInfer/index/RvcFeatIndex.py

@@ -0,0 +1,19 @@
+import numpy as np
+from numpy.typing import NDArray
+
+from ..path_utils import path
+from ..type_alist import PathLike
+
+
+class RvcFeatIndex:
+    def __init__(self, index: PathLike) -> None:
+        import faiss  # pyright: ignore[reportMissingImports]
+        self.faiss_index = faiss.read_index(str(path(index).resolve()))
+        self.faiss_data: NDArray = self.faiss_index.reconstruct_n(0, self.faiss_index.ntotal)
+
+    def apply_index(self, feats: NDArray[np.float32], index_rate: float = 0.66, k: int = 8) -> NDArray[np.float32]:
+        score, ix = self.faiss_index.search(feats, k=k)
+        weight = np.square(1 / score)
+        weight /= weight.sum(axis=1, keepdims=True)
+        index_feats = np.sum(self.faiss_data[ix] * np.expand_dims(weight, axis=2), axis=1)
+        return index_feats * index_rate + (1 - index_rate) * feats

RvcPyInfer/infer_env.py

@@ -0,0 +1,28 @@
+# pyright: reportUnusedImport=false
+
+import warnings
+
+from .warn.InferEnvWarn import InferEnvWarn
+
+try:
+    import onnxruntime  # pyright: ignore[reportMissingImports] # noqa: F401
+    HAS_ORT = True
+except ImportError:
+    HAS_ORT = False
+
+try:
+    import openvino  # pyright: ignore[reportMissingImports] # noqa: F401
+    HAS_OPENVINO = True
+except ImportError:
+    HAS_OPENVINO = False
+
+HAS_ONE = HAS_ORT or HAS_OPENVINO
+
+if not HAS_ONE:
+    warnings.warn("没有任意一个支持的推理引擎，请至少安装一个可选模块", InferEnvWarn)
+
+try:
+    import faiss  # pyright: ignore[reportMissingImports] # noqa: F401
+    HAS_FAISS = True
+except ImportError:
+    HAS_FAISS = False

RvcPyInfer/onnx/ContentVec.py

@@ -0,0 +1,38 @@
+import numpy as np
+from numpy.typing import NDArray
+
+from ..audio.audio_utils import reSR
+from ..error.InferEnvError import InferEnvError
+from ..InferProviders import InferProviders
+from ..path_utils import path as pathf
+from ..type_alist import Audio, PathLike
+from .model_loader import load_model
+
+
+class ContentVec:
+    def __init__(self, path: PathLike, providers: InferProviders) -> None:
+        self.session, self.compiled_model = load_model(pathf(path), providers)
+
+    def infer(self, audio: Audio) -> NDArray[np.float32]:
+        data, sr = audio
+        assert len(data.shape) == 1, "输入音频应为单通道"
+        data, sr = reSR(audio, target_sr=16000)
+        data = data.reshape(1, 1, -1)
+        input = {
+            "source": data
+        }
+        logits = None
+        if self.session is not None:
+            logits = self.session.run(
+                    output_names=["embed"], 
+                    input_feed=input)[0]
+            assert isinstance(logits, np.ndarray), "ort 输出应为 NDArray"
+        elif self.compiled_model is not None:
+            infer_request = self.compiled_model.create_infer_request()
+            result_dict = infer_request.infer(inputs=input)
+            logits = result_dict["embed"]
+            del infer_request, result_dict
+        else:
+            raise InferEnvError("没有任意一个支持的推理引擎，请至少安装一个可选模块")
+        # (1, frames, embed_size)
+        return np.repeat(logits, 2, axis=1).squeeze(axis=0).astype(np.float32) # 因为模型帧长为 320, 这里复制一份到 160