Files
ComfyUI-H3-Continuum-Tiled/tools/audio_continuity_output_analyze.py
T

195 lines
6.4 KiB
Python

"""Analyze finalized Audio Continuity research outputs without changing them."""
from __future__ import annotations
import argparse
import hashlib
import importlib.util
import json
from pathlib import Path
import subprocess
import sys
from typing import Any
import numpy as np
import torch
from v36_r2_audio_boundary_analyze import _decode_audio, boundary_metrics
ROOT = Path(__file__).resolve().parents[1]
PACKAGE_NAME = "ComfyUI_H3_Continuum_Join"
def _load_package() -> None:
if PACKAGE_NAME in sys.modules:
return
spec = importlib.util.spec_from_file_location(
PACKAGE_NAME,
ROOT / "__init__.py",
submodule_search_locations=[str(ROOT)],
)
if spec is None:
raise RuntimeError("could not create the Continuum package spec")
module = importlib.util.module_from_spec(spec)
module.__path__ = [str(ROOT)]
sys.modules[PACKAGE_NAME] = module
_load_package()
from ComfyUI_H3_Continuum_Join.v2.seam_guard import _correlation # noqa: E402
def _window_rms_floor(value: np.ndarray, *, sample_rate: int) -> float:
frame = max(1, int(round(sample_rate * 0.010)))
usable = len(value) // frame * frame
if usable <= 0:
return 0.0
blocks = value[:usable].reshape(-1, frame, value.shape[1])
rms = np.sqrt(np.mean(np.square(blocks), axis=(1, 2)))
return float(np.percentile(rms, 10))
def _adjacent_alignment(
audio: np.ndarray,
*,
sample_rate: int,
boundary_sample: int,
) -> dict[str, Any]:
mono = torch.from_numpy(audio.mean(axis=1).astype(np.float32, copy=False))
window = max(8, int(round(sample_rate * 0.080)))
max_lag = max(1, int(round(sample_rate * 0.020)))
before = mono[:boundary_sample]
after = mono[boundary_sample:]
if before.numel() < window + max_lag or after.numel() < window + max_lag:
raise ValueError("insufficient decoded audio for adjacent-window alignment")
def correlation_at(lag: int) -> float:
if lag >= 0:
left = before[-window:]
right = after[lag : lag + window]
else:
stop = int(before.numel()) + lag
left = before[stop - window : stop]
right = after[:window]
return float(_correlation(left, right))
baseline = correlation_at(0)
candidates = [(lag, correlation_at(lag)) for lag in range(-max_lag, max_lag + 1)]
best_lag, best_correlation = max(candidates, key=lambda item: item[1])
return {
"window_ms": 80.0,
"search_ms": 20.0,
"correlation_at_zero": baseline,
"best_correlation": best_correlation,
"best_lag_samples": int(best_lag),
"best_lag_ms": float(best_lag * 1000.0 / sample_rate),
}
def _probe(path: Path, ffprobe: Path) -> dict[str, Any]:
completed = subprocess.run(
[
str(ffprobe),
"-v",
"error",
"-count_frames",
"-show_entries",
"stream=index,codec_type,width,height,nb_read_frames,duration,sample_rate,channels",
"-show_entries",
"format=duration",
"-of",
"json",
str(path),
],
check=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
)
return json.loads(completed.stdout)
def analyze(
path: Path,
*,
ffmpeg: Path,
ffprobe: Path,
sample_rate: int,
fps: float,
boundary_frames: list[int],
expected_frames: int,
) -> dict[str, Any]:
audio = _decode_audio(path, ffmpeg, sample_rate)
pcm = audio.astype("<f4", copy=False).tobytes(order="C")
boundaries: list[dict[str, Any]] = []
long = max(1, int(round(sample_rate * 0.250)))
for frame in boundary_frames:
sample = int(round(frame * sample_rate / fps))
before = audio[max(0, sample - long) : sample]
after = audio[sample : min(len(audio), sample + long)]
boundaries.append(
{
"frame": int(frame),
**boundary_metrics(audio, sample_rate=sample_rate, boundary_sample=sample),
**_adjacent_alignment(
audio,
sample_rate=sample_rate,
boundary_sample=sample,
),
"rms_floor_before_250ms_p10_10ms": _window_rms_floor(
before, sample_rate=sample_rate
),
"rms_floor_after_250ms_p10_10ms": _window_rms_floor(
after, sample_rate=sample_rate
),
}
)
expected_duration = expected_frames / fps
decoded_duration = len(audio) / sample_rate
return {
"format": "h3-continuum-audio-continuity-output-analysis-v1",
"path": str(path),
"sample_rate": int(sample_rate),
"fps": float(fps),
"expected_frames": int(expected_frames),
"expected_duration_seconds": expected_duration,
"decoded_samples_per_channel": int(len(audio)),
"decoded_duration_seconds": decoded_duration,
"decoded_duration_error_seconds": decoded_duration - expected_duration,
"pcm_f32le_md5": hashlib.md5(pcm).hexdigest(),
"finite": bool(np.isfinite(audio).all()),
"probe": _probe(path, ffprobe),
"boundaries": boundaries,
}
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--input", type=Path, required=True)
parser.add_argument("--result", type=Path, required=True)
parser.add_argument("--ffmpeg", type=Path, default=Path(r"C:\FFmpeg\bin\ffmpeg.exe"))
parser.add_argument("--ffprobe", type=Path, default=Path(r"C:\FFmpeg\bin\ffprobe.exe"))
parser.add_argument("--sample-rate", type=int, default=32000)
parser.add_argument("--fps", type=float, default=24.0)
parser.add_argument("--expected-frames", type=int, default=360)
parser.add_argument("--boundary-frames", type=int, nargs="+", default=[124, 243])
args = parser.parse_args()
result = analyze(
args.input,
ffmpeg=args.ffmpeg,
ffprobe=args.ffprobe,
sample_rate=args.sample_rate,
fps=args.fps,
boundary_frames=list(args.boundary_frames),
expected_frames=args.expected_frames,
)
args.result.parent.mkdir(parents=True, exist_ok=True)
args.result.write_text(json.dumps(result, indent=2), encoding="utf-8")
print(json.dumps(result))
return 0
if __name__ == "__main__":
raise SystemExit(main())