hyper-animator-codex 0.1.0 → 0.3.0

package/skills/hyper-animator-codex/vendor/music-beat-detector/beat_detector/beat.py

@@ -0,0 +1,133 @@
+"""节拍检测模块"""
+from dataclasses import dataclass
+from typing import List, Callable, Optional
+from enum import Enum
+import numpy as np
+import librosa
+
+from .utils import ms_to_frame
+
+
+class EnergyLevel(Enum):
+    """节拍能量级别"""
+    WEAK = "weak"
+    MEDIUM = "medium"
+    STRONG = "strong"
+
+
+@dataclass
+class Beat:
+    """单个节拍"""
+    time_ms: int
+    frame: int
+    beat_in_bar: int
+    energy_level: EnergyLevel = EnergyLevel.MEDIUM
+
+
+@dataclass
+class BeatResult:
+    """节拍检测结果"""
+    bpm: float
+    beats: List[Beat]
+    time_signature: str = "4/4"
+
+
+def detect_beats(
+    y: np.ndarray,
+    sr: int,
+    fps: int = 30,
+    on_progress: Optional[Callable[[float], None]] = None
+) -> BeatResult:
+    """检测节拍"""
+
+    if on_progress:
+        on_progress(10.0)
+
+    # 使用 librosa 检测节拍
+    tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr)
+    bpm = float(np.asarray(tempo).reshape(-1)[0])
+
+    if on_progress:
+        on_progress(40.0)
+
+    # 转换为时间（毫秒）
+    beat_times = librosa.frames_to_time(beat_frames, sr=sr)
+    beat_times_ms = [int(t * 1000) for t in beat_times]
+
+    # 计算每个beat的能量
+    beat_energies = _compute_beat_energies(y, sr, beat_frames)
+
+    if on_progress:
+        on_progress(70.0)
+
+    # 根据能量分布分级
+    energy_levels = _classify_energy_levels(beat_energies)
+
+    if on_progress:
+        on_progress(80.0)
+
+    # 构建 Beat 列表
+    beats = []
+    beats_per_bar = 4  # 假设 4/4 拍
+    for i, time_ms in enumerate(beat_times_ms):
+        frame = ms_to_frame(time_ms, fps)
+        beat_in_bar = (i % beats_per_bar) + 1
+        beats.append(Beat(
+            time_ms=time_ms,
+            frame=frame,
+            beat_in_bar=beat_in_bar,
+            energy_level=energy_levels[i]
+        ))
+
+    if on_progress:
+        on_progress(100.0)
+
+    return BeatResult(bpm=bpm, beats=beats)
+
+
+def _compute_beat_energies(
+    y: np.ndarray,
+    sr: int,
+    beat_frames: np.ndarray,
+    window_ms: int = 50
+) -> np.ndarray:
+    """计算每个beat时刻的局部能量"""
+    window_samples = int(sr * window_ms / 1000)
+    energies = []
+
+    for frame in beat_frames:
+        # 将librosa帧转换为样本索引
+        sample = librosa.frames_to_samples(frame)
+        start = max(0, sample - window_samples // 2)
+        end = min(len(y), sample + window_samples // 2)
+
+        if end > start:
+            # 使用RMS作为能量度量
+            segment = y[start:end]
+            rms = np.sqrt(np.mean(segment ** 2))
+            energies.append(rms)
+        else:
+            energies.append(0.0)
+
+    return np.array(energies)
+
+
+def _classify_energy_levels(energies: np.ndarray) -> List[EnergyLevel]:
+    """根据能量分布分类为弱/中/强三档"""
+    if len(energies) == 0:
+        return []
+
+    # 使用百分位数划分阈值
+    weak_threshold = np.percentile(energies, 33)
+    strong_threshold = np.percentile(energies, 66)
+
+    levels = []
+    for energy in energies:
+        if energy <= weak_threshold:
+            levels.append(EnergyLevel.WEAK)
+        elif energy >= strong_threshold:
+            levels.append(EnergyLevel.STRONG)
+        else:
+            levels.append(EnergyLevel.MEDIUM)
+
+    return levels

package/skills/hyper-animator-codex/vendor/music-beat-detector/beat_detector/cli.py

@@ -0,0 +1,74 @@
+"""命令行接口"""
+import json
+import sys
+import click
+
+from .analyzer import analyze
+from .errors import (
+    BeatDetectorError,
+    FileNotFoundError,
+    UnsupportedFormatError,
+    AnalysisError,
+    FFmpegRequiredError
+)
+
+
+@click.command()
+@click.argument('input_file', type=click.Path(exists=False))
+@click.option('-o', '--output', type=click.Path(), help='Output file path')
+@click.option('--fps', default=30, help='Frame rate (default: 30)')
+@click.option('--log-level', default='info',
+              type=click.Choice(['debug', 'info', 'warning', 'error']),
+              help='Log level (default: info)')
+@click.option('--pretty', is_flag=True, help='Pretty print JSON')
+def main(input_file: str, output: str, fps: int, log_level: str, pretty: bool) -> None:
+    """
+    Music beat detector CLI
+
+    Analyze audio file and output beat detection results in JSON format.
+
+    Supported formats (no extra dependencies):
+        .wav, .flac, .ogg
+
+    Formats requiring ffmpeg:
+        .mp3, .m4a, .aac, .wma
+
+    Usage:
+        beat-detector input.mp3 -o output.json
+        beat-detector input.wav --pretty
+    """
+    try:
+        result = analyze(input_file, fps=fps, log_level=log_level)
+        json_output = result.to_json(pretty=pretty)
+
+        if output:
+            result.save(output, pretty=pretty)
+            click.echo(f"Output saved to: {output}")
+        else:
+            click.echo(json_output)
+
+        sys.exit(0)
+
+    except FileNotFoundError as e:
+        click.echo(f"Error: {e.message}", err=True)
+        sys.exit(1)
+
+    except UnsupportedFormatError as e:
+        click.echo(f"Error: {e.message}", err=True)
+        sys.exit(2)
+
+    except FFmpegRequiredError as e:
+        click.echo(f"Error: {e.message}", err=True)
+        sys.exit(4)
+
+    except AnalysisError as e:
+        click.echo(f"Error: {e.message}", err=True)
+        sys.exit(3)
+
+    except Exception as e:
+        click.echo(f"Unexpected error: {str(e)}", err=True)
+        sys.exit(3)
+
+
+if __name__ == '__main__':
+    main()

package/skills/hyper-animator-codex/vendor/music-beat-detector/beat_detector/errors.py

@@ -0,0 +1,49 @@
+"""错误类型"""
+from typing import Optional
+
+
+class BeatDetectorError(Exception):
+    """基础异常类"""
+
+    def __init__(self, message: str, code: int = 1):
+        self.message = message
+        self.code = code
+        super().__init__(self.message)
+
+
+class FileNotFoundError(BeatDetectorError):
+    """文件不存在"""
+
+    def __init__(self, path: str):
+        super().__init__(f"File not found: {path}", code=1)
+
+
+class UnsupportedFormatError(BeatDetectorError):
+    """不支持的音频格式"""
+
+    def __init__(self, format: str):
+        super().__init__(f"Unsupported audio format: {format}", code=2)
+
+
+class FFmpegRequiredError(BeatDetectorError):
+    """需要安装 ffmpeg"""
+
+    def __init__(self, format: str):
+        message = (
+            f"Format '{format}' requires ffmpeg. "
+            f"Please install ffmpeg:\n"
+            f"  Ubuntu/Debian: sudo apt install ffmpeg\n"
+            f"  macOS: brew install ffmpeg\n"
+            f"  Windows: choco install ffmpeg\n"
+            f"\n"
+            f"Or use native formats: .wav, .flac, .ogg"
+        )
+        super().__init__(message, code=4)
+
+
+class AnalysisError(BeatDetectorError):
+    """分析失败"""
+
+    def __init__(self, message: str, cause: Optional[Exception] = None):
+        self.cause = cause
+        super().__init__(message, code=3)

package/skills/hyper-animator-codex/vendor/music-beat-detector/beat_detector/structure.py

@@ -0,0 +1,171 @@
+"""结构检测模块"""
+from dataclasses import dataclass
+from typing import List, Callable, Optional
+import numpy as np
+import librosa
+
+from .utils import ms_to_frame
+
+
+@dataclass
+class Segment:
+    """音乐段落"""
+    type: str
+    start_ms: int
+    end_ms: int
+    start_frame: int
+    end_frame: int
+    confidence: float
+
+
+@dataclass
+class EnergyPeak:
+    """能量高峰"""
+    time_ms: int
+    frame: int
+    intensity: float
+
+
+@dataclass
+class SilenceRegion:
+    """静音区域"""
+    start_ms: int
+    end_ms: int
+    start_frame: int
+    end_frame: int
+
+
+@dataclass
+class StructureResult:
+    """结构检测结果"""
+    segments: List[Segment]
+    energy_peaks: List[EnergyPeak]
+    silence_regions: List[SilenceRegion]
+
+
+def detect_structure(
+    y: np.ndarray,
+    sr: int,
+    fps: int = 30,
+    on_progress: Optional[Callable[[float], None]] = None
+) -> StructureResult:
+    """检测音乐结构"""
+
+    if on_progress:
+        on_progress(10.0)
+
+    # 计算能量
+    rms = librosa.feature.rms(y=y)[0]
+    rms_frames = librosa.frames_to_time(range(len(rms)), sr=sr)
+
+    if on_progress:
+        on_progress(30.0)
+
+    # 检测能量高峰
+    energy_peaks = _detect_energy_peaks(rms, rms_frames, fps)
+
+    if on_progress:
+        on_progress(50.0)
+
+    # 检测静音区域
+    silence_regions = _detect_silence_regions(rms, rms_frames, fps, sr)
+
+    if on_progress:
+        on_progress(70.0)
+
+    # 简单的段落检测（基于能量变化）
+    segments = _detect_segments(y, sr, rms, rms_frames, fps)
+
+    if on_progress:
+        on_progress(100.0)
+
+    return StructureResult(
+        segments=segments,
+        energy_peaks=energy_peaks,
+        silence_regions=silence_regions
+    )
+
+
+def _detect_energy_peaks(rms: np.ndarray, times: np.ndarray, fps: int) -> List[EnergyPeak]:
+    """检测能量高峰"""
+    peaks = []
+    threshold = np.mean(rms) + np.std(rms)
+
+    for i in range(1, len(rms) - 1):
+        if rms[i] > threshold and rms[i] > rms[i-1] and rms[i] > rms[i+1]:
+            time_ms = int(times[i] * 1000)
+            frame = ms_to_frame(time_ms, fps)
+            intensity = float(rms[i] / np.max(rms)) if np.max(rms) > 0 else 0.0
+            peaks.append(EnergyPeak(
+                time_ms=time_ms,
+                frame=frame,
+                intensity=intensity
+            ))
+
+    return peaks
+
+
+def _detect_silence_regions(rms: np.ndarray, times: np.ndarray, fps: int, sr: int) -> List[SilenceRegion]:
+    """检测静音区域"""
+    regions = []
+    threshold = np.mean(rms) * 0.1  # 静音阈值
+    min_silence_duration = 0.5  # 最小静音时长（秒）
+
+    in_silence = False
+    silence_start = 0
+
+    for i, energy in enumerate(rms):
+        if energy < threshold:
+            if not in_silence:
+                in_silence = True
+                silence_start = i
+        else:
+            if in_silence:
+                silence_duration = times[i] - times[silence_start]
+                if silence_duration >= min_silence_duration:
+                    start_ms = int(times[silence_start] * 1000)
+                    end_ms = int(times[i] * 1000)
+                    regions.append(SilenceRegion(
+                        start_ms=start_ms,
+                        end_ms=end_ms,
+                        start_frame=ms_to_frame(start_ms, fps),
+                        end_frame=ms_to_frame(end_ms, fps)
+                    ))
+                in_silence = False
+
+    return regions
+
+
+def _detect_segments(y: np.ndarray, sr: int, rms: np.ndarray, times: np.ndarray, fps: int) -> List[Segment]:
+    """简单的段落检测"""
+    segments = []
+    duration_ms = int(len(y) / sr * 1000)
+
+    # 简单策略：将音频分成 intro, main, outro
+    num_sections = 3
+    section_duration = duration_ms // num_sections
+
+    # 计算每个部分的平均能量
+    rms_per_section = np.array_split(rms, num_sections)
+    avg_energies = [np.mean(s) for s in rms_per_section]
+
+    section_types = ['intro', 'verse', 'outro']
+
+    for i in range(num_sections):
+        start_ms = i * section_duration
+        end_ms = (i + 1) * section_duration if i < num_sections - 1 else duration_ms
+
+        # 根据相对能量计算置信度
+        max_energy = max(avg_energies) if max(avg_energies) > 0 else 1
+        confidence = float(avg_energies[i] / max_energy)
+
+        segments.append(Segment(
+            type=section_types[i],
+            start_ms=start_ms,
+            end_ms=end_ms,
+            start_frame=ms_to_frame(start_ms, fps),
+            end_frame=ms_to_frame(end_ms, fps),
+            confidence=confidence
+        ))
+
+    return segments

package/skills/hyper-animator-codex/vendor/music-beat-detector/beat_detector/utils.py

@@ -0,0 +1,73 @@
+"""工具函数"""
+from typing import Tuple
+import os
+import logging
+import numpy as np
+
+from .errors import FileNotFoundError, UnsupportedFormatError, FFmpegRequiredError
+
+# 原生支持的格式（无需额外依赖）
+NATIVE_FORMATS = {'.wav', '.flac', '.ogg'}
+
+# 需要 ffmpeg 的格式
+FFMPEG_FORMATS = {'.mp3', '.m4a', '.aac', '.wma'}
+
+# 所有支持的格式
+SUPPORTED_FORMATS = NATIVE_FORMATS | FFMPEG_FORMATS
+
+
+def ms_to_frame(ms: int, fps: int) -> int:
+    """毫秒转帧号"""
+    return int(ms * fps / 1000)
+
+
+def frame_to_ms(frame: int, fps: int) -> int:
+    """帧号转毫秒"""
+    return int(frame * 1000 / fps)
+
+
+def check_ffmpeg_available() -> bool:
+    """检查 ffmpeg 是否可用"""
+    import shutil
+    return shutil.which('ffmpeg') is not None
+
+
+def load_audio(file_path: str) -> Tuple[np.ndarray, int]:
+    """加载音频文件
+
+    原生支持: .wav, .flac, .ogg (无需额外依赖)
+    需要 ffmpeg: .mp3, .m4a, .aac, .wma
+    """
+    import librosa
+
+    # 检查文件是否存在
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(file_path)
+
+    # 检查格式
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext not in SUPPORTED_FORMATS:
+        raise UnsupportedFormatError(ext)
+
+    # 检查是否需要 ffmpeg
+    if ext in FFMPEG_FORMATS and not check_ffmpeg_available():
+        raise FFmpegRequiredError(ext)
+
+    # 加载音频
+    y, sr = librosa.load(file_path, sr=None)
+    return y, sr
+
+
+def setup_logging(level: str = "info") -> None:
+    """配置日志"""
+    level_map = {
+        "debug": logging.DEBUG,
+        "info": logging.INFO,
+        "warning": logging.WARNING,
+        "error": logging.ERROR,
+    }
+    logging.basicConfig(
+        level=level_map.get(level, logging.INFO),
+        format="[%(levelname)s] %(message)s",
+        force=True
+    )