app.py

"""
app.py — 主旋律 / ハモリ 分離 & L/R パンニング プロトタイプ
=====================================================================
使い方:
    python app.py <入力ファイル> [--output output_panned.wav] [--inst-vol 0.15]

入力: mp3 / wav / mp4 / mov など ffmpeg が対応する任意フォーマット
出力: 左ch=主旋律(メインボーカル) / 右ch=ハモリ(コーラス) のステレオ WAV

アルゴリズム概要:
    1. subprocess で ffmpeg を直接呼び出し → 安定した音声抽出
    2. Demucs (htdemucs_6s) で6音源分離
         → vocals / other / drums / bass / guitar / piano
    3. パンニング
         - vocals → 左ch 100%
         - other  → 右ch 100% (コーラス/ハモリ)
         - 伴奏   → センター & 音量縮小 (--inst-vol で調整, 0=ミュート)
    4. ミックスして output_panned.wav を出力
"""

import argparse
import os
import sys
import tempfile
import shutil
import subprocess
from pathlib import Path

import numpy as np
import soundfile as sf

# ── torchaudio.save モンキーパッチ ─────────────────────────────
# Windows 環境で torchcodec の DLL が読み込めず torchaudio.save が
# 失敗する問題を回避するため、soundfile ベースの保存処理で置き換える。
# これにより Demucs の内部での WAV 書き出しが正常に動作する。
def _patched_torchaudio_save(uri, src, sample_rate, **kwargs):
    """torchaudio.save を soundfile で代替する"""
    import numpy as np
    import soundfile as sf
    data = src.detach().cpu().numpy()
    # torchaudio は (C, T) 形式、soundfile は (T, C) を期待する
    if data.ndim == 2:
        data = data.T  # (T, C) に変換
    elif data.ndim == 1:
        pass  # モノラルはそのまま
    sf.write(str(uri), data, sample_rate, subtype="PCM_16")

try:
    import torchaudio
    torchaudio.save = _patched_torchaudio_save
    # 新しいバージョンの内部モジュールもパッチ
    try:
        import torchaudio.backend.soundfile_backend as _sfb
        _sfb.save = _patched_torchaudio_save
    except Exception:
        pass
    try:
        import torchaudio._backend.utils as _bu
        # save 関数が複数箇所に散在するため torchaudio 本体だけで十分
    except Exception:
        pass
except ImportError:
    pass  # torchaudio がない場合は無視


# ── UVR MDX-NET によるリード/バッキングボーカル分離 ────────────
# UVR_MDXNET_KARA_2 モデル: ボーカルステムから
#   Lead (リードボーカル) と Backing (バッキング/ハモリ) を分離する

MDX_MODEL_REPO = "seanghay/uvr_models"
MDX_MODEL_FILE = "UVR_MDXNET_KARA_2.onnx"

# モデルの設定値 (UVR_MDXNET_KARA_2: 入力形状 [batch, 4, 2048, 256])
MDX_CONFIG = {
    "dim_f": 2048,    # 周波数ビン数（モデルの入力チャネル / 2）
    "dim_t": 256,     # 時間フレーム数
    "n_fft": 6144,    # STFT ウィンドウサイズ
    "hop_length": 1024,
    "sample_rate": 44100,
    "overlap": 0.75,
}


def download_mdx_model(cache_dir: Path) -> Path:
    """HuggingFace から UVR MDX-NET KARA モデルを取得する"""
    model_path = cache_dir / MDX_MODEL_FILE
    if model_path.exists():
        print(f"[INFO] MDX モデルはキャッシュ済み: {model_path}")
        return model_path

    print(f"[INFO] UVR MDX-NET KARA モデルをダウンロード中... (初回のみ・約53MB)")
    try:
        from huggingface_hub import hf_hub_download
        downloaded = hf_hub_download(
            repo_id=MDX_MODEL_REPO,
            filename=MDX_MODEL_FILE,
            local_dir=str(cache_dir),
        )
        return Path(downloaded)
    except Exception as e:
        raise RuntimeError(
            f"MDX モデルのダウンロードに失敗しました: {e}\n"
            "インターネット接続を確認してください。"
        )


def mdx_separate_lead_backing(
    vocals_wav: np.ndarray,
    sr: int,
    model_path: Path,
) -> tuple[np.ndarray, np.ndarray]:
    """
    UVR MDX-NET KARA モデルを使ってボーカルを
    リードボーカル と バッキング/ハモリ に分離する。

    モデル入力形状: [1, 4, dim_f, dim_t] = [1, 4, 2048, 256]
    vocals_wav: (samples, 2) float32 のステレオ配列
    戻り値: (lead, backing) それぞれ (samples, 2) float32
    """
    import onnxruntime as ort

    print("[INFO] UVR MDX-NET KARA でリード/バッキング分離を開始...")

    dim_f      = MDX_CONFIG["dim_f"]       # 2048
    dim_t      = MDX_CONFIG["dim_t"]       # 256
    n_fft      = MDX_CONFIG["n_fft"]       # 6144
    hop_length = MDX_CONFIG["hop_length"]  # 1024
    overlap    = MDX_CONFIG["overlap"]     # 0.75

    # ONNX セッション
    sess_opts = ort.SessionOptions()
    sess_opts.log_severity_level = 3
    session = ort.InferenceSession(
        str(model_path),
        sess_options=sess_opts,
        providers=["CPUExecutionProvider"],
    )
    input_name = session.get_inputs()[0].name

    # 入力: (samples, 2) → (2, T)
    mix = vocals_wav.T.astype(np.float32)  # (2, T)
    n_channels, T = mix.shape

    # チャンクサイズ = dim_t フレーム分のサンプル数
    chunk_samples = hop_length * dim_t
    step_samples  = int(chunk_samples * (1 - overlap))
    pad_size      = chunk_samples   # 前後にゼロパディング

    mix_padded = np.pad(mix, ((0, 0), (pad_size, pad_size + chunk_samples)))

    # 出力バッファ
    out_sum   = np.zeros((n_channels, mix_padded.shape[1]), dtype=np.float64)
    out_count = np.zeros(mix_padded.shape[1], dtype=np.float64)

    # ハン窓フェード
    fade_len = step_samples
    fade_in  = np.linspace(0.0, 1.0, fade_len)
    fade_out = fade_in[::-1]
    win      = np.ones(chunk_samples)
    win[:fade_len]  = fade_in
    win[-fade_len:] = fade_out

    starts = range(0, mix_padded.shape[1] - chunk_samples, step_samples)
    total  = len(list(starts))
    print(f"[INFO] {total} チャンクを処理中...")

    for idx, start in enumerate(range(0, mix_padded.shape[1] - chunk_samples, step_samples)):
        chunk = mix_padded[:, start: start + chunk_samples]  # (2, chunk_samples)

        # STFT → (2, n_fft//2+1, dim_t)
        stft_l = _np_stft(chunk[0], n_fft, hop_length, dim_t)
        stft_r = _np_stft(chunk[1], n_fft, hop_length, dim_t)

        # 上位 dim_f ビンだけ使う
        sl = stft_l[:dim_f, :]   # (dim_f, dim_t)
        sr_ = stft_r[:dim_f, :]

        # real/imag → (1, 4, dim_f, dim_t)
        model_input = np.stack([
            sl.real, sl.imag,
            sr_.real, sr_.imag,
        ], axis=0)[np.newaxis].astype(np.float32)  # (1,4,dim_f,dim_t)

        # 推論 → (1, 4, dim_f, dim_t)
        pred = session.run(None, {input_name: model_input})[0][0]  # (4, dim_f, dim_t)

        # マスクをそのまま分離マスクとして適用
        sep_l_stft = (pred[0] + 1j * pred[1]) * sl
        sep_r_stft = (pred[2] + 1j * pred[3]) * sr_

        # 周波数ビンを元の長さに戻す (残りはゼロ)
        full_l = np.zeros((n_fft // 2 + 1, dim_t), dtype=np.complex64)
        full_r = np.zeros((n_fft // 2 + 1, dim_t), dtype=np.complex64)
        full_l[:dim_f] = sep_l_stft
        full_r[:dim_f] = sep_r_stft

        # iSTFT
        sig_l = _np_istft(full_l, n_fft, hop_length, chunk_samples)
        sig_r = _np_istft(full_r, n_fft, hop_length, chunk_samples)
        sep = np.stack([sig_l, sig_r])  # (2, chunk_samples)

        # オーバーラップ加算
        out_sum[:, start: start + chunk_samples]  += sep * win
        out_count[start: start + chunk_samples]   += win

        if (idx + 1) % max(1, total // 10) == 0:
            print(f"  {idx+1}/{total} チャンク完了")

    np.maximum(out_count, 1e-8, out_count)
    result = out_sum / out_count

    # パディング除去
    lead    = result[:, pad_size: pad_size + T]   # (2, T)
    backing = mix - lead                           # 残差

    print("[INFO] リード/バッキング分離完了")
    return lead.T.astype(np.float32), backing.T.astype(np.float32)


def _np_stft(signal: np.ndarray, n_fft: int, hop_length: int, n_frames: int) -> np.ndarray:
    """
    NumPy で STFT を計算する。
    signal: (T,) float32
    戻り値: (n_fft//2+1, n_frames) complex64
    """
    window = np.hanning(n_fft).astype(np.float32)
    # 必要なサンプル数になるようにパディング
    required = n_fft + hop_length * (n_frames - 1)
    if signal.shape[0] < required:
        signal = np.pad(signal, (0, required - signal.shape[0]))
    else:
        signal = signal[:required]

    out = np.zeros((n_fft // 2 + 1, n_frames), dtype=np.complex64)
    for i in range(n_frames):
        s = i * hop_length
        frame = signal[s: s + n_fft] * window
        out[:, i] = np.fft.rfft(frame, n=n_fft).astype(np.complex64)
    return out


def _np_istft(stft: np.ndarray, n_fft: int, hop_length: int, length: int) -> np.ndarray:
    """
    NumPy で iSTFT を計算する。
    stft: (n_fft//2+1, T) complex64
    戻り値: (length,) float32
    """
    window = np.hanning(n_fft).astype(np.float32)
    n_frames = stft.shape[1]
    out  = np.zeros(length + n_fft, dtype=np.float64)
    wsum = np.zeros(length + n_fft, dtype=np.float64)
    for i in range(n_frames):
        frame = np.fft.irfft(stft[:, i], n=n_fft).real * window
        s = i * hop_length
        e = s + n_fft
        if s >= length:
            break
        out[s:e]  += frame
        wsum[s:e] += window ** 2
    np.maximum(wsum, 1e-8, wsum)
    return (out / wsum)[:length].astype(np.float32)




def download_mdx_model(cache_dir: Path) -> Path:
    """HuggingFace から UVR MDX-NET KARA モデルを取得する"""
    model_path = cache_dir / MDX_MODEL_FILE
    if model_path.exists():
        print(f"[INFO] MDX モデルはキャッシュ済み: {model_path}")
        return model_path

    print(f"[INFO] UVR MDX-NET KARA モデルをダウンロード中... (初回のみ)")
    try:
        from huggingface_hub import hf_hub_download
        downloaded = hf_hub_download(
            repo_id=MDX_MODEL_REPO,
            filename=MDX_MODEL_FILE,
            local_dir=str(cache_dir),
        )
        return Path(downloaded)
    except Exception as e:
        raise RuntimeError(
            f"MDX モデルのダウンロードに失敗しました: {e}\n"
            "インターネット接続を確認してください。"
        )




# ── ユーティリティ ──────────────────────────────────────────────


VIDEO_EXTENSIONS = {".mp4", ".mov", ".avi", ".mkv", ".m4v", ".flv", ".webm", ".ts"}
AUDIO_EXTENSIONS = {".mp3", ".wav", ".flac", ".aac", ".ogg", ".m4a"}


def is_url(text: str) -> bool:
    """http:// or https:// で始まる文字列を URL と判定する"""
    return text.startswith("http://") or text.startswith("https://")


def download_audio_from_url(url: str, tmp_dir: Path) -> Path:
    """
    yt-dlp で YouTube などの URL から音声をダウンロードし WAV に変換する。
    YouTube 以外にも yt-dlp が対応するサイトは利用可能。
    戻り値: 一時 WAV ファイルの Path
    """
    try:
        import yt_dlp
    except ImportError:
        raise ImportError(
            "yt-dlp が見つかりません。\n"
            "pip install yt-dlp でインストールしてください。"
        )

    out_wav = tmp_dir / "source.wav"
    print(f"[INFO] URL を検出。yt-dlp で音声をダウンロード中...")
    print(f"       URL: {url}")

    ydl_opts = {
        # WAV に直接変換して一時ディレクトリに保存
        "format": "bestaudio/best",
        "outtmpl": str(tmp_dir / "ydl_download.%(ext)s"),
        "postprocessors": [
            {
                "key": "FFmpegExtractAudio",
                "preferredcodec": "wav",
                "preferredquality": "0",
            }
        ],
        "quiet": False,
        "no_warnings": False,
        "noplaylist": True,   # プレイリストでなく先頭の1曲のみ取得
    }

    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
        info = ydl.extract_info(url, download=True)
        title = info.get("title", "unknown")
        print(f"[INFO] ダウンロード完了: {title}")

    # yt-dlp が生成した WAV を探す
    wav_candidates = list(tmp_dir.glob("ydl_download*.wav"))
    if not wav_candidates:
        raise FileNotFoundError(
            "yt-dlp の変換後 WAV が見つかりません。"
            "ffmpeg が正しくインストールされているか確認してください。"
        )
    downloaded_wav = wav_candidates[0]

    # ffmpeg でサンプルレートを 44100Hz に統一
    ffmpeg = find_ffmpeg()
    result = subprocess.run(
        [
            ffmpeg, "-y",
            "-i", str(downloaded_wav),
            "-ar", "44100",
            "-ac", "2",
            str(out_wav),
        ],
        capture_output=True, text=True, encoding="utf-8", errors="replace",
    )
    if result.returncode != 0:
        print(f"[ffmpeg stderr]\n{result.stderr[-2000:]}")
        raise RuntimeError("音声変換に失敗しました")

    print(f"[INFO] 音声変換完了 → {out_wav.name}")
    return out_wav


def find_ffmpeg() -> str:
    """ffmpeg の実行パスを返す。見つからなければ例外を投げる"""
    ffmpeg_cmd = shutil.which("ffmpeg")
    if ffmpeg_cmd:
        return ffmpeg_cmd
    candidates = [
        r"C:\ffmpeg\bin\ffmpeg.exe",
        r"C:\Program Files\ffmpeg\bin\ffmpeg.exe",
        r"C:\ProgramData\chocolatey\bin\ffmpeg.exe",
    ]
    for c in candidates:
        if Path(c).exists():
            return c
    raise FileNotFoundError(
        "ffmpeg が見つかりません。\n"
        "Windows: winget install Gyan.FFmpeg\n"
        "Mac:     brew install ffmpeg\n"
        "Linux:   sudo apt install ffmpeg"
    )


def check_audio_stream(input_path: Path) -> None:
    """
    ffprobe で音声ストリームの有無を確認する。
    音声がない場合は分かりやすいエラーメッセージを出して終了する。
    """
    ffprobe_cmd = shutil.which("ffprobe")
    if not ffprobe_cmd:
        # ffprobe がない場合はスキップ（ffmpegで失敗させる）
        return

    result = subprocess.run(
        [
            ffprobe_cmd,
            "-v", "quiet",
            "-select_streams", "a",   # 音声ストリームのみ
            "-show_entries", "stream=codec_type",
            "-of", "csv=p=0",
            str(input_path),
        ],
        capture_output=True, text=True, encoding="utf-8", errors="replace",
    )
    if not result.stdout.strip():
        raise ValueError(
            f"'{input_path.name}' に音声トラックが見つかりません。\n"
            "このファイルには映像のみが含まれているため処理できません。\n"
            "音声トラック付きのファイル（mp3/wav/mp4など）を指定してください。"
        )


def extract_audio(input_path: Path, out_wav: Path) -> None:
    """
    subprocess で ffmpeg を直接呼び出して音声を WAV に変換。
    動画・音声どちらにも対応。事前に音声ストリームの有無を確認する。
    """
    ffmpeg = find_ffmpeg()
    # 音声トラックの有無を事前確認
    check_audio_stream(input_path)
    print(f"[INFO] ffmpeg で音声変換中: {input_path.name} → {out_wav.name}")

    cmd = [
        ffmpeg,
        "-y",                    # 上書き確認をスキップ
        "-i", str(input_path),
        "-vn",                   # 映像トラックを除外
        "-acodec", "pcm_s16le",  # 16bit PCM
        "-ar", "44100",          # サンプルレート
        "-ac", "2",              # ステレオ
        str(out_wav),
    ]

    result = subprocess.run(cmd, capture_output=True, text=True, encoding="utf-8", errors="replace")
    if result.returncode != 0:
        print(f"[ffmpeg stderr]\n{result.stderr[-2000:]}")  # 末尾2000文字だけ表示
        raise RuntimeError(f"ffmpeg が失敗しました (returncode={result.returncode})")

    print(f"[INFO] 音声変換完了 → {out_wav}")


def prepare_audio(input_path_or_url: str | Path, tmp_dir: Path) -> Path:
    """URL もしくはファイルパスを受け取り、WAV に変換して返す"""
    # URLの場合は yt-dlp でダウンロード
    if isinstance(input_path_or_url, str) and is_url(input_path_or_url):
        return download_audio_from_url(input_path_or_url, tmp_dir)

    input_path = Path(input_path_or_url)
    ext = input_path.suffix.lower()
    out_wav = tmp_dir / "source.wav"

    if ext == ".wav":
        # WAV でもサンプルレートが異なる場合があるため ffmpeg で統一する
        extract_audio(input_path, out_wav)
        return out_wav

    if ext in VIDEO_EXTENSIONS or ext in AUDIO_EXTENSIONS:
        extract_audio(input_path, out_wav)
        return out_wav

    # 不明な拡張子でも ffmpeg に渡してみる
    print(f"[WARN] 未知の拡張子 '{ext}'。ffmpeg で変換を試みます。")
    extract_audio(input_path, out_wav)
    return out_wav


# ── Demucs 分離 ──────────────────────────────────────────────────


def run_demucs(wav_path: Path, out_dir: Path, model: str) -> tuple[dict, int]:
    """
    Demucs でステム分離を実行。
    戻り値: (stems_dict, sample_rate)
        stems_dict = {stem_name: np.ndarray(shape=[samples, 2], dtype=float32)}
    """
    print(f"\n[INFO] Demucs ({model}) で音源分離を開始...")
    print("       初回実行時はモデルのダウンロードが発生します（数百MB）。しばらくお待ちください。\n")

    cmd = [
        sys.executable, "-m", "demucs",
        "-n", model,
        "-o", str(out_dir),
        str(wav_path),
    ]

    # リアルタイムで進捗を表示しながら実行
    proc = subprocess.Popen(
        cmd,
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        text=True,
        encoding="utf-8",
        errors="replace",
    )
    output_lines = []
    for line in proc.stdout:
        line_stripped = line.rstrip()
        output_lines.append(line_stripped)
        print(f"  {line_stripped}")
    proc.wait()

    if proc.returncode != 0:
        raise RuntimeError(
            f"Demucs が失敗しました (returncode={proc.returncode})\n"
            + "\n".join(output_lines[-20:])
        )

    # ── 出力ディレクトリを特定 ──
    # Demucs の出力構造: <out_dir>/<model>/<入力ファイル名(拡張子なし)>/
    stem_dir = out_dir / model / wav_path.stem
    if not stem_dir.exists():
        # ディレクトリ名が一致しない場合はざっくり検索
        found = list(out_dir.rglob("*.wav"))
        if not found:
            raise FileNotFoundError(
                f"Demucs の出力ファイルが見つかりません。出力先: {out_dir}\n"
                f"分離されたモデル名のフォルダを確認してください。"
            )
        stem_dir = found[0].parent
        print(f"[INFO] ステムディレクトリを自動検出: {stem_dir}")

    # ── WAV ファイルを読み込む ──
    stems: dict[str, np.ndarray] = {}
    sr = 44100
    for wav_file in sorted(stem_dir.glob("*.wav")):
        data, sr = sf.read(str(wav_file), always_2d=True)
        stems[wav_file.stem] = data.astype(np.float32)
        print(f"  [stem] {wav_file.stem:12s}: {data.shape} @ {sr}Hz")

    if not stems:
        raise FileNotFoundError(f"ステム WAV が見つかりません: {stem_dir}")

    print(f"\n[INFO] 分離完了。検出ステム: {list(stems.keys())}")
    return stems, sr


# ── ハモリ推定フォールバック ──────────────────────────────────────


def fallback_split_vocals(vocals: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
    """
    htdemucs_6s で 'other' が得られない場合のフォールバック。
    ステレオの Mid/Side 分解でハモリ成分を推定する。
    - Mid (L+R)/2 → 主旋律（モノラル中心成分）
    - Side (L-R)/2 → ハモリ候補（ステレオ広がり成分）
    """
    print("[INFO] フォールバック: Mid/Side 分解でハモリを推定します")
    L = vocals[:, 0]
    R = vocals[:, 1] if vocals.shape[1] > 1 else vocals[:, 0]

    mid = ((L + R) / 2.0).astype(np.float32)
    side = ((L - R) / 2.0).astype(np.float32)

    main_vocal = np.stack([mid, mid], axis=1)
    harmony = np.stack([side, side], axis=1)
    return main_vocal, harmony


# ── パンニング & ミックス ─────────────────────────────────────────


def to_stereo(audio: np.ndarray) -> np.ndarray:
    """入力を (samples, 2) のステレオ配列に整形"""
    if audio.ndim == 1:
        audio = np.stack([audio, audio], axis=1)
    elif audio.shape[1] == 1:
        audio = np.concatenate([audio, audio], axis=1)
    return audio[:, :2]  # 3ch以上は最初の2chだけ使う


def pan_to_left(audio: np.ndarray) -> np.ndarray:
    """ステレオ音源を左チャンネルのみに振る (Rch=0)"""
    stereo = to_stereo(audio)
    mono = np.mean(stereo, axis=1, keepdims=True)
    return np.concatenate([mono, np.zeros_like(mono)], axis=1)


def pan_to_right(audio: np.ndarray) -> np.ndarray:
    """ステレオ音源を右チャンネルのみに振る (Lch=0)"""
    stereo = to_stereo(audio)
    mono = np.mean(stereo, axis=1, keepdims=True)
    return np.concatenate([np.zeros_like(mono), mono], axis=1)


def mid_side_split(vocals: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
    """
    vocals ステムを Mid/Side 分解して主旋律とハモリを推定する。

    Mid  = (L + R) / 2  → センターに定位したメインボーカル → 左ch
    Side = (L - R) / 2  → 左右にパンされたハモリ/コーラス  → 右ch

    プロの録音では：
    - メインボーカルはセンター（Mid 成分が大きい）
    - ハモリやコーラスは左右にパン（Side 成分に現れる）
    """
    L = vocals[:, 0].astype(np.float32)
    R = vocals[:, 1].astype(np.float32) if vocals.shape[1] > 1 else L.copy()

    mid  = (L + R) / 2.0
    side = (L - R) / 2.0

    # Side 成分が極端に小さい場合（ほぼモノラル録音）は警告
    mid_rms  = float(np.sqrt(np.mean(mid  ** 2)) + 1e-9)
    side_rms = float(np.sqrt(np.mean(side ** 2)) + 1e-9)
    ratio = side_rms / mid_rms
    print(f"[INFO] Mid/Side 比率: Mid={mid_rms:.4f}, Side={side_rms:.4f}, Side/Mid={ratio:.3f}")
    if ratio < 0.05:
        print("[WARN] Side 成分が非常に小さいです。元音源がモノラル録音の可能性があります。")
        print("       左右の差が小さいため、ハモリ分離の効果が限定的になる場合があります。")

    main_vocal = np.stack([mid, mid], axis=1)   # モノ → ステレオ
    harmony    = np.stack([side, side], axis=1)
    return main_vocal, harmony


def mix_stems(
    stems: dict[str, np.ndarray],
    model: str,
    inst_vol: float,
    mdx_model_path: Path | None = None,
    sr: int = 44100,
) -> np.ndarray:
    """
    分離済みステムを L/R パンニングしてミックスする。

    mdx_model_path が指定されている場合:
        UVR MDX-NET KARA で vocals を Lead/Backing に AI 分離
        Lead（主旋律）→ 左ch, Backing（ハモリ）→ 右ch
    未指定の場合:
        Mid/Side 分解（フォールバック）
    """
    n_samples = max(s.shape[0] for s in stems.values())

    def pad(arr: np.ndarray) -> np.ndarray:
        arr = to_stereo(arr)
        if arr.shape[0] < n_samples:
            arr = np.pad(arr, ((0, n_samples - arr.shape[0]), (0, 0)))
        return arr[:n_samples]

    mix = np.zeros((n_samples, 2), dtype=np.float32)

    if "vocals" in stems:
        vocals_padded = pad(stems["vocals"])

        if mdx_model_path is not None:
            try:
                lead, backing = mdx_separate_lead_backing(vocals_padded, sr, mdx_model_path)
                # 長さを揃える
                L = min(lead.shape[0], n_samples)
                lead_out    = np.zeros((n_samples, 2), dtype=np.float32)
                backing_out = np.zeros((n_samples, 2), dtype=np.float32)
                lead_out[:L]    = lead[:L]
                backing_out[:L] = backing[:L]
                print("[INFO] パンニング: Lead(主旋律) → L, Backing(ハモリ) → R")
                mix += pan_to_left(lead_out)
                mix += pan_to_right(backing_out)
            except Exception as e:
                print(f"[WARN] UVR 推論失敗 ({e})。Mid/Side にフォールバックします。")
                main_vocal, harmony = mid_side_split(vocals_padded)
                mix += pan_to_left(main_vocal)
                mix += pan_to_right(harmony)
        else:
            print("[INFO] vocals を Mid/Side 分解: Mid → L（主旋律）, Side → R（ハモリ）")
            main_vocal, harmony = mid_side_split(vocals_padded)
            mix += pan_to_left(main_vocal)
            mix += pan_to_right(harmony)

        # vocals 以外はすべて伴奏としてセンターに縮小
        inst_keys = [k for k in stems if k != "vocals"]
        if inst_vol > 0 and inst_keys:
            print(f"[INFO] 伴奏ステム {inst_keys} → センター x {inst_vol}")
            for k in inst_keys:
                mix += pad(stems[k]) * inst_vol
        elif inst_keys:
            print(f"[INFO] 伴奏ステム {inst_keys} → ミュート (inst-vol=0)")
    else:
        print("[WARN] 'vocals' ステムが見つかりません。全ステムをセンター出力します。")
        for k, arr in stems.items():
            mix += pad(arr)

    # ピーク正規化（クリッピング防止）
    peak = float(np.max(np.abs(mix)))
    if peak > 1e-6:
        mix = mix / peak * 0.95
    return mix



# ── メインフロー ──────────────────────────────────────────────────


def main():
    parser = argparse.ArgumentParser(
        description="主旋律 / ハモリ 分離 & L/R パンニング ツール",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
例:
  python app.py song.mp3
  python app.py movie.mp4 --output result.wav
  python app.py https://www.youtube.com/watch?v=XXXXXXXXXXX
  python app.py song.mp3 --inst-vol 0.0   # 伴奏ミュート
  python app.py song.mp3 --model htdemucs  # 軽量モデル
        """,
    )
    parser.add_argument("input", help="入力ファイル (mp3/wav/mp4/mov など) または URL (YouTube など)")
    parser.add_argument(
        "--output", default="output_panned.wav",
        help="出力 WAV ファイル名 (デフォルト: output_panned.wav)",
    )
    parser.add_argument(
        "--inst-vol", type=float, default=0.15,
        help="伴奏の音量係数 0.0(ミュート)〜1.0 (デフォルト: 0.15)",
    )
    parser.add_argument(
        "--model",
        default="htdemucs_6s",
        choices=["htdemucs_6s", "htdemucs", "mdx_extra", "mdx"],
        help="Demucs モデル (デフォルト: htdemucs_6s)",
    )
    parser.add_argument(
        "--no-mdx", action="store_true",
        help="UVR MDX-NET によるリード/バッキング分離をスキップし Mid/Side 分解を使用",
    )
    args = parser.parse_args()

    # URL かファイルパスか判定
    input_arg = args.input
    if is_url(input_arg):
        # URL の場合はファイル存在チェック不要
        input_for_process = input_arg
    else:
        input_path = Path(input_arg).resolve()
        if not input_path.exists():
            print(f"[ERROR] ファイルが見つかりません: {input_path}")
            sys.exit(1)
        input_for_process = input_path

    tmp_dir = Path(tempfile.mkdtemp(prefix="musicbot_"))
    demucs_out = tmp_dir / "demucs_out"
    demucs_out.mkdir(parents=True, exist_ok=True)

    try:
        # Step 1: 音声準備（URL またはファイル）
        wav_path = prepare_audio(input_for_process, tmp_dir)

        # Step 2: Demucs 分離
        model = args.model
        stems, sr = run_demucs(wav_path, demucs_out, model)

        # htdemucs_6s で 'other' がない場合は htdemucs にフォールバック
        if model == "htdemucs_6s" and "other" not in stems:
            print("\n[WARN] htdemucs_6s で 'other' ステムが見つかりません。htdemucs に切り替えます。")
            shutil.rmtree(demucs_out)
            demucs_out.mkdir(parents=True, exist_ok=True)
            model = "htdemucs"
            stems, sr = run_demucs(wav_path, demucs_out, model)

        # Step 3: UVR MDX-NET モデルを取得(必要なら)
        mdx_model_path = None
        if not args.no_mdx:
            mdx_cache = Path.home() / ".cache" / "musicbot" / "models"
            mdx_cache.mkdir(parents=True, exist_ok=True)
            try:
                mdx_model_path = download_mdx_model(mdx_cache)
            except Exception as e:
                print(f"[WARN] MDX モデルの取得に失敗しました: {e}")
                print("       Mid/Side 分解コードにフォールバックします。")

        # Step 4: パンニング & ミックス
        print("\n[INFO] L/R パンニング & ミックス処理中...")
        mixed = mix_stems(stems, model, args.inst_vol, mdx_model_path=mdx_model_path, sr=sr)

        # Step 4: 出力
        output_path = Path(args.output).resolve()
        sf.write(str(output_path), mixed, sr, subtype="PCM_16")

        print(f"""
╔══════════════════════════════════════╗
║  ✅  処理完了！                      ║
╠══════════════════════════════════════╣
║  出力: {output_path.name:<31}║
║  左チャンネル (L): 主旋律             ║
║  右チャンネル (R): ハモリ/コーラス    ║
║  伴奏音量係数  : {args.inst_vol:<22.2f}║
╚══════════════════════════════════════╝
→ {output_path}
""")

    except KeyboardInterrupt:
        print("\n[INFO] ユーザーによって中断されました。")
        sys.exit(0)
    except Exception as e:
        print(f"\n[ERROR] 処理中にエラーが発生しました: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)
    finally:
        shutil.rmtree(tmp_dir, ignore_errors=True)


if __name__ == "__main__":
    main()