#!/usr/bin/env python3 """ Visual picker for extraction settings. Shows video thumbnails, audio waveforms, and lets you set start/duration. Usage: make picker or .venv/bin/python picker.py --config config.toml """ from __future__ import annotations import os, sys, argparse, subprocess, json, math, signal import numpy as np try: import tomllib except ModuleNotFoundError: import tomli as tomllib try: import pyqtgraph as pg from PyQt6 import QtWidgets, QtCore, QtGui except ImportError: print("ERROR: pyqtgraph/PyQt6 not installed — run make install", file=sys.stderr) sys.exit(1) # Reuse dark theme from verify_sync from verify_sync import apply_dark_theme def probe_video_info(path: str) -> dict: """Get video duration, resolution, audio streams.""" try: r = subprocess.run( ["ffprobe", "-v", "error", "-show_entries", "format=duration:stream=index,codec_type,codec_name,width,height,sample_rate,channels", "-of", "json", path], capture_output=True, text=True, timeout=10 ) if r.returncode != 0: return {} data = json.loads(r.stdout) fmt = data.get("format", {}) streams = data.get("streams", []) video = next((s for s in streams if s.get("codec_type") == "video"), {}) audio = [s for s in streams if s.get("codec_type") == "audio"] return { "duration": float(fmt.get("duration", 0)), "width": video.get("width", 0), "height": video.get("height", 0), "fps": video.get("r_frame_rate", ""), "audio_streams": audio, } except Exception: return {} def extract_thumbnails(path: str, start: float, duration: float, count: int = 20, w: int = 160) -> list[np.ndarray]: """Extract evenly-spaced thumbnails from video segment.""" thumbs = [] if duration <= 0: return thumbs step = duration / count for i in range(count): t = start + i * step try: r = subprocess.run( ["ffmpeg", "-y", "-ss", str(t), "-i", path, "-vframes", "1", "-vf", f"scale={w}:-1", "-f", "rawvideo", "-pix_fmt", "gray", "-"], capture_output=True, timeout=5 ) if r.returncode == 0 and len(r.stdout) > 0: # decode gray image — we need dimensions, guess from size # ffmpeg -vf scale=160:-1 produces width=160, height varies # We'll decode as raw and reshape later thumbs.append((t, r.stdout, w)) except Exception: pass return thumbs def extract_audio_segment(path: str, start: float, duration: float, sr: int = 48000, stream_idx: int = 0) -> np.ndarray | None: """Extract a mono float32 PCM segment from video file.""" cmd = [ "ffmpeg", "-y", "-ss", str(start), "-i", path, "-t", str(duration), "-vn", "-map", f"0:a:{stream_idx}", "-ac", "1", "-ar", str(sr), "-f", "f32le", "-" ] try: r = subprocess.run(cmd, capture_output=True, timeout=30) if r.returncode != 0: return None return np.frombuffer(r.stdout, dtype=np.float32) except Exception: return None class PickerWindow(QtWidgets.QWidget): def __init__(self, file_a: str, file_b: str, start: float, duration: float, sr: int = 48000): super().__init__() self.file_a = file_a self.file_b = file_b self.sr = sr self.video_info = probe_video_info(file_a) self.total_duration = self.video_info.get("duration", 0) self.audio_streams = self.video_info.get("audio_streams", []) # Current selection self.start = max(0.0, min(start, self.total_duration)) self.duration = max(1.0, duration) self.setWindowTitle(f"picker — {os.path.basename(file_a)}") self.resize(1400, 700) self._setup_ui() self._load_waveforms() def _setup_ui(self): lay = QtWidgets.QVBoxLayout(self) lay.setSpacing(4) # ── Video info ── info = QtWidgets.QHBoxLayout() lay.addLayout(info) info.addWidget(QtWidgets.QLabel( f"Video: {self.video_info.get('width', '?')}x{self.video_info.get('height', '?')} | " f"{self.total_duration:.1f}s | {len(self.audio_streams)} audio stream(s)" )) info.addStretch() # ── Selection controls ── sel = QtWidgets.QHBoxLayout() lay.addLayout(sel) sel.addWidget(QtWidgets.QLabel("Start (s):")) self.start_spin = QtWidgets.QDoubleSpinBox() self.start_spin.setRange(0, max(0, self.total_duration - 1)) self.start_spin.setDecimals(3) self.start_spin.setSingleStep(0.1) self.start_spin.setValue(self.start) self.start_spin.setFixedWidth(90) sel.addWidget(self.start_spin) sel.addWidget(QtWidgets.QLabel("Duration (s):")) self.dur_spin = QtWidgets.QDoubleSpinBox() self.dur_spin.setRange(1, max(1, self.total_duration)) self.dur_spin.setDecimals(1) self.dur_spin.setSingleStep(1) self.dur_spin.setValue(self.duration) self.dur_spin.setFixedWidth(70) sel.addWidget(self.dur_spin) sel.addWidget(QtWidgets.QLabel("End:")) self.end_label = QtWidgets.QLabel(f"{self.start + self.duration:.1f}s") sel.addWidget(self.end_label) sel.addSpacing(20) self.start_spin.valueChanged.connect(self._on_start_changed) self.dur_spin.valueChanged.connect(self._on_dur_changed) # ── Audio stream selector ── if len(self.audio_streams) > 1: sel.addWidget(QtWidgets.QLabel("Audio stream:")) self.stream_combo = QtWidgets.QComboBox() for i, s in enumerate(self.audio_streams): lang = s.get("language", "?") ch = s.get("channels", "?") codec = s.get("codec_name", "?") self.stream_combo.addItem(f"Stream {i}: {lang} {ch}ch {codec}") self.stream_combo.setFixedWidth(200) sel.addWidget(self.stream_combo) self.stream_combo.currentIndexChanged.connect(lambda _: self._load_waveforms()) else: self.stream_combo = None sel.addStretch() btn_apply = QtWidgets.QPushButton("Save to config.toml") btn_apply.setFixedWidth(130) btn_apply.clicked.connect(self._save_config) sel.addWidget(btn_apply) # ── Plots ── # Row 0: Thumbnails self.thumb_label = QtWidgets.QLabel("Thumbnails (loading...)") self.thumb_label.setMinimumHeight(120) lay.addWidget(self.thumb_label, stretch=1) # Row 1: Waveform A self.plot_a = pg.PlotWidget(name="waveform_a") self.plot_a.setLabel("bottom", "Time", units="s") self.plot_a.setLabel("left", "A") self.plot_a.showGrid(x=True, y=True, alpha=0.3) lay.addWidget(self.plot_a, stretch=2) # Row 2: Waveform B self.plot_b = pg.PlotWidget(name="waveform_b") self.plot_b.setLabel("bottom", "Time", units="s") self.plot_b.setLabel("left", "B") self.plot_b.showGrid(x=True, y=True, alpha=0.3) lay.addWidget(self.plot_b, stretch=2) # Link x-axes self.plot_b.setXLink(self.plot_a) # Selection region (vertical span on both plots) self.sel_region = pg.LinearRegionItem([self.start, self.start + self.duration], movable=True) self.sel_region.setBrush(pg.mkBrush(100, 100, 255, 40)) self.sel_region.sigRegionChanged.connect(self._on_region_changed) self.plot_a.addItem(self.sel_region) self.plot_b.addItem(self.sel_region) self.curve_a = self.plot_a.plot(pen=pg.mkPen("c", width=1)) self.curve_b = self.plot_b.plot(pen=pg.mkPen("r", width=1)) def _on_start_changed(self, val): self.start = val self.sel_region.setRegion([self.start, self.start + self.duration]) self.end_label.setText(f"{self.start + self.duration:.1f}s") def _on_dur_changed(self, val): self.duration = val self.sel_region.setRegion([self.start, self.start + self.duration]) self.end_label.setText(f"{self.start + self.duration:.1f}s") def _on_region_changed(self): r = self.sel_region.getRegion() self.start = r[0] self.duration = r[1] - r[0] self.start_spin.blockSignals(True) self.start_spin.setValue(self.start) self.start_spin.blockSignals(False) self.dur_spin.blockSignals(True) self.dur_spin.setValue(self.duration) self.dur_spin.blockSignals(False) self.end_label.setText(f"{self.start + self.duration:.1f}s") def _load_waveforms(self): stream_idx = self.stream_combo.currentIndex() if self.stream_combo else 0 print(f"Loading waveform A (stream {stream_idx})...") a = extract_audio_segment(self.file_a, 0, self.total_duration, self.sr, stream_idx) print(f"Loading waveform B...") b = extract_audio_segment(self.file_b, 0, self.total_duration, self.sr, 0) if self.file_b and os.path.exists(self.file_b) else None max_pts = 200_000 if a is not None and len(a) > 0: t_a = np.arange(len(a), dtype=np.float64) / self.sr if len(a) > max_pts: stride = int(math.ceil(len(a) / max_pts)) a = a[::stride] t_a = t_a[::stride] self.curve_a.setData(t_a, a) y_max = np.max(np.abs(a)) * 1.1 self.plot_a.setYRange(-y_max, y_max) if b is not None and len(b) > 0: t_b = np.arange(len(b), dtype=np.float64) / self.sr if len(b) > max_pts: stride = int(math.ceil(len(b) / max_pts)) b = b[::stride] t_b = t_b[::stride] self.curve_b.setData(t_b, b) y_max_b = np.max(np.abs(b)) * 1.1 self.plot_b.setYRange(-y_max_b, y_max_b) self.plot_a.setXRange(0, self.total_duration) self.plot_b.setXRange(0, self.total_duration) # Load thumbnails in background self._load_thumbnails() def _load_thumbnails(self): print("Extracting thumbnails...") thumbs = extract_thumbnails(self.file_a, self.start, self.duration, count=20, w=160) if not thumbs: self.thumb_label.setText("Thumbnails unavailable") return # Stitch thumbnails horizontally into a pixmap imgs = [] for t, raw, w in thumbs: # Decode raw gray — need height. We'll use ffmpeg to produce png instead pass # Simpler: extract a sprite sheet with ffmpeg step = self.duration / 20 if self.duration > 0 else 1 try: r = subprocess.run( ["ffmpeg", "-y", "-ss", str(self.start), "-i", self.file_a, "-t", str(self.duration), "-vf", f"fps=1/{max(0.1, step):.2f},scale=160:-1,tile=20x1"], capture_output=True, timeout=30 ) if r.returncode == 0: # Write to temp file and load as pixmap import tempfile with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp: tmp.write(r.stdout) tmp_path = tmp.name pixmap = QtGui.QPixmap(tmp_path) self.thumb_label.setPixmap(pixmap.scaled( self.thumb_label.width(), self.thumb_label.height(), QtCore.Qt.AspectRatioMode.KeepAspectRatio, QtCore.Qt.TransformationMode.SmoothTransformation )) os.unlink(tmp_path) except Exception as e: self.thumb_label.setText(f"Thumbnail error: {e}") def _save_config(self): config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "config.toml") # Read existing config cfg = {} if os.path.exists(config_path): with open(config_path, "rb") as f: cfg = tomllib.load(f) # Update extract section if "extract" not in cfg: cfg["extract"] = {} cfg["extract"]["file_a"] = self.file_a cfg["extract"]["file_b"] = self.file_b cfg["extract"]["start"] = round(self.start, 3) cfg["extract"]["duration"] = round(self.duration, 1) # Write back import io lines = [] lines.append("# movie_sync base config — shared by extract.py and sync_audio_test.py") lines.append("# TOML is efficient: no yaml dep, stdlib tomllib (py3.11+) parses directly.\n") lines.append("[extract]") lines.append(f'file_a = {repr(cfg["extract"]["file_a"])}') lines.append(f'file_b = {repr(cfg["extract"]["file_b"])}') lines.append(f'# Window to extract (seconds). This is the ONLY duration needed.') lines.append(f'duration = {cfg["extract"]["duration"]}') lines.append(f'# Start offset in file (seconds, 0 = file start). ffmpeg -ss before -i for fast seek.') lines.append(f'start = {cfg["extract"]["start"]}') lines.append(f'out_dir = "extracted"') lines.append(f'target_fps = "24000/1001" # Blu-ray film 23.976') lines.append(f'target_fps_eps = 0.02\n') # Copy audio and sync sections from existing if present au = cfg.get("audio", {}) sy = cfg.get("sync", {}) lines.append("[audio]") lines.append(f'sample_rate = {au.get("sample_rate", 48000)}') lines.append(f'channels = {au.get("channels", 1)}') lines.append(f'normalize = {str(au.get("normalize", True)).lower()}') lines.append(f'target_lufs = {au.get("target_lufs", -14)}') lines.append(f'target_tp = {au.get("target_tp", -1.0)}') lines.append(f'target_lra = {au.get("target_lra", 11)}') lines.append(f'volume = {au.get("volume", 10)}\n') lines.append("[sync]") lines.append(f'method = {repr(sy.get("method", "phat"))}') lines.append(f'use_gpu = {repr(sy.get("use_gpu", "auto"))}') lines.append(f'out_dir = {repr(sy.get("out_dir", "output"))}') with open(config_path, "w") as f: f.write("\n".join(lines) + "\n") print(f"Saved start={self.start:.3f}s duration={self.duration:.1f}s to {config_path}") QtWidgets.QMessageBox.information(self, "Saved", f"Config updated:\nstart = {self.start:.3f}\nduration = {self.duration:.1f}") def main(): parser = argparse.ArgumentParser(description="Visual picker for extraction settings") parser.add_argument("--config", default="config.toml") parser.add_argument("--a", help="Override file_a") parser.add_argument("--b", help="Override file_b") args = parser.parse_args() cfg = {} config_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), args.config) if os.path.exists(config_path): with open(config_path, "rb") as f: cfg = tomllib.load(f) ext = cfg.get("extract", {}) au = cfg.get("audio", {}) file_a = args.a or ext.get("file_a", "") file_b = args.b or ext.get("file_b", "") start = float(ext.get("start", 0)) duration = float(ext.get("duration", 30)) sr = int(au.get("sample_rate", 48000)) if not file_a or not os.path.exists(file_a): print(f"ERROR: file_a not found: {file_a}", file=sys.stderr) sys.exit(1) app = QtWidgets.QApplication(sys.argv) signal.signal(signal.SIGINT, signal.SIG_DFL) apply_dark_theme(app) w = PickerWindow(file_a, file_b, start, duration, sr) w.show() sys.exit(app.exec()) if __name__ == "__main__": main()