@renoise/video-maker 0.1.0

package/skills/short-film-editor/scripts/analyze-beats.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+"""
+Beat analysis for short film editing.
+Analyzes audio to extract BPM, beat positions, section boundaries,
+and suggests clip cut points within Seedance's 5-15s constraint.
+
+Usage: python3 analyze-beats.py <audio_file>
+Output: JSON to stdout
+
+Dependencies: pip3 install librosa soundfile numpy
+"""
+
+import json
+import sys
+from pathlib import Path
+
+try:
+    import librosa
+    import numpy as np
+except ImportError:
+    print(
+        json.dumps({
+            "error": "Missing dependencies. Install with: pip3 install librosa soundfile numpy"
+        }),
+        file=sys.stderr,
+    )
+    sys.exit(1)
+
+
+MIN_SEGMENT_S = 5.0
+MAX_SEGMENT_S = 15.0
+
+
+def analyze_beats(audio_path: str) -> dict:
+    """Analyze audio file and return beat/section/cut data."""
+    y, sr = librosa.load(audio_path, sr=22050)
+    total_duration = librosa.get_duration(y=y, sr=sr)
+
+    # Beat tracking
+    tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr)
+    beat_times = librosa.frames_to_time(beat_frames, sr=sr).tolist()
+    bpm = float(np.round(tempo, 1)) if np.ndim(tempo) == 0 else float(np.round(tempo[0], 1))
+
+    # Section boundary detection via spectral change
+    # Use a smaller number of segments for short audio
+    n_segments = max(4, min(10, int(total_duration / 10)))
+    boundaries = _detect_sections(y, sr, n_segments)
+
+    # Build sections with labels
+    section_labels = _label_sections(boundaries, total_duration)
+
+    # Generate suggested cuts respecting 5-15s constraint
+    suggested_cuts = _suggest_cuts(section_labels, beat_times, total_duration)
+
+    return {
+        "bpm": bpm,
+        "total_duration_s": round(total_duration, 2),
+        "beats": [round(b, 3) for b in beat_times],
+        "sections": section_labels,
+        "suggested_cuts": suggested_cuts,
+    }
+
+
+def _detect_sections(y, sr, n_segments: int) -> list[float]:
+    """Detect section boundaries using spectral features."""
+    # Compute spectral features
+    chroma = librosa.feature.chroma_cqt(y=y, sr=sr)
+    mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
+    features = np.vstack([chroma, mfcc])
+
+    # Use agglomerative clustering for boundary detection
+    try:
+        bound_frames = librosa.segment.agglomerative(features, k=n_segments)
+        bound_times = librosa.frames_to_time(bound_frames, sr=sr).tolist()
+    except Exception:
+        # Fallback: evenly spaced sections
+        duration = librosa.get_duration(y=y, sr=sr)
+        bound_times = [i * duration / n_segments for i in range(1, n_segments)]
+
+    # Remove boundaries too close to start/end
+    bound_times = [b for b in bound_times if 2.0 < b < (librosa.get_duration(y=y, sr=sr) - 2.0)]
+
+    return sorted(set(round(b, 2) for b in bound_times))
+
+
+def _label_sections(boundaries: list[float], total_duration: float) -> list[dict]:
+    """Assign labels to sections based on position in the track."""
+    labels_map = ["intro", "verse", "build", "chorus", "bridge", "verse2", "chorus2", "outro"]
+    points = [0.0] + boundaries + [total_duration]
+    sections = []
+
+    for i in range(len(points) - 1):
+        label_idx = min(i, len(labels_map) - 1)
+        sections.append({
+            "start": round(points[i], 2),
+            "end": round(points[i + 1], 2),
+            "label": labels_map[label_idx],
+        })
+
+    return sections
+
+
+def _suggest_cuts(
+    sections: list[dict],
+    beats: list[float],
+    total_duration: float,
+) -> list[dict]:
+    """
+    Generate suggested cut points respecting 5-15s segment constraints.
+    Uses section boundaries as primary cuts, then subdivides or merges as needed.
+    """
+    raw_segments = []
+    for sec in sections:
+        start = sec["start"]
+        end = sec["end"]
+        duration = end - start
+        label = sec["label"]
+
+        if duration <= MAX_SEGMENT_S:
+            raw_segments.append({"time": start, "end": end, "duration": round(duration, 2), "section": label})
+        else:
+            # Subdivide long sections at beat points
+            sub_segments = _subdivide_at_beats(start, end, beats, label)
+            raw_segments.extend(sub_segments)
+
+    # Merge segments that are too short
+    merged = _merge_short_segments(raw_segments)
+
+    # Final pass: ensure all within bounds
+    result = []
+    for seg in merged:
+        dur = seg["end"] - seg["time"]
+        if dur >= MIN_SEGMENT_S:
+            result.append({
+                "time": round(seg["time"], 2),
+                "end": round(seg["end"], 2),
+                "duration": round(dur, 2),
+                "section": seg["section"],
+            })
+
+    # Handle edge case: if no valid segments, create evenly spaced ones
+    if not result:
+        n = max(1, int(total_duration / 10))
+        seg_dur = total_duration / n
+        for i in range(n):
+            s = i * seg_dur
+            e = min((i + 1) * seg_dur, total_duration)
+            result.append({
+                "time": round(s, 2),
+                "end": round(e, 2),
+                "duration": round(e - s, 2),
+                "section": f"segment_{i + 1}",
+            })
+
+    return result
+
+
+def _subdivide_at_beats(
+    start: float,
+    end: float,
+    beats: list[float],
+    label: str,
+) -> list[dict]:
+    """Split a long section at beat points into 5-15s segments."""
+    section_beats = [b for b in beats if start <= b <= end]
+    if not section_beats:
+        # No beats found; split evenly
+        n = max(2, int((end - start) / 10))
+        seg_len = (end - start) / n
+        return [
+            {
+                "time": round(start + i * seg_len, 2),
+                "end": round(start + (i + 1) * seg_len, 2),
+                "duration": round(seg_len, 2),
+                "section": label,
+            }
+            for i in range(n)
+        ]
+
+    segments = []
+    current_start = start
+
+    for beat in section_beats:
+        if beat - current_start >= MAX_SEGMENT_S:
+            # Find the best beat to cut at (closest to target ~10s)
+            target = current_start + 10.0
+            candidates = [b for b in section_beats if current_start + MIN_SEGMENT_S <= b <= current_start + MAX_SEGMENT_S]
+            if candidates:
+                cut = min(candidates, key=lambda b: abs(b - target))
+                segments.append({
+                    "time": round(current_start, 2),
+                    "end": round(cut, 2),
+                    "duration": round(cut - current_start, 2),
+                    "section": label,
+                })
+                current_start = cut
+
+    # Final segment
+    if end - current_start >= MIN_SEGMENT_S:
+        segments.append({
+            "time": round(current_start, 2),
+            "end": round(end, 2),
+            "duration": round(end - current_start, 2),
+            "section": label,
+        })
+    elif segments:
+        # Extend the last segment
+        segments[-1]["end"] = round(end, 2)
+        segments[-1]["duration"] = round(end - segments[-1]["time"], 2)
+    else:
+        segments.append({
+            "time": round(start, 2),
+            "end": round(end, 2),
+            "duration": round(end - start, 2),
+            "section": label,
+        })
+
+    return segments
+
+
+def _merge_short_segments(segments: list[dict]) -> list[dict]:
+    """Merge segments shorter than MIN_SEGMENT_S with their neighbors."""
+    if not segments:
+        return []
+
+    merged = [segments[0].copy()]
+
+    for seg in segments[1:]:
+        prev = merged[-1]
+        prev_dur = prev["end"] - prev["time"]
+        seg_dur = seg["end"] - seg["time"]
+
+        if seg_dur < MIN_SEGMENT_S:
+            # Try merging with previous if combined still <= MAX
+            combined = prev_dur + seg_dur
+            if combined <= MAX_SEGMENT_S:
+                prev["end"] = seg["end"]
+                prev["duration"] = round(combined, 2)
+                continue
+
+        if prev_dur < MIN_SEGMENT_S:
+            # Extend previous into current
+            combined = prev_dur + seg_dur
+            if combined <= MAX_SEGMENT_S:
+                prev["end"] = seg["end"]
+                prev["duration"] = round(combined, 2)
+                prev["section"] = seg["section"]
+                continue
+
+        merged.append(seg.copy())
+
+    return merged
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python3 analyze-beats.py <audio_file>", file=sys.stderr)
+        print("Supported formats: mp3, aac, wav, m4a, ogg, flac", file=sys.stderr)
+        sys.exit(1)
+
+    audio_path = sys.argv[1]
+    if not Path(audio_path).exists():
+        print(json.dumps({"error": f"File not found: {audio_path}"}), file=sys.stderr)
+        sys.exit(1)
+
+    result = analyze_beats(audio_path)
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

package/skills/short-film-editor/scripts/batch-generate.sh

@@ -0,0 +1,150 @@
+#!/usr/bin/env bash
+#
+# Batch video generation for short film projects.
+# Reads a prompts JSON file and sequentially creates/waits/retrieves each shot.
+#
+# Usage:
+#   bash batch-generate.sh --project <project-id> --ratio <ratio> --prompts-file <prompts.json>
+#
+# Prompts JSON format:
+#   [
+#     { "shot_id": "S1", "prompt": "...", "duration": 8 },
+#     { "shot_id": "S2", "prompt": "...", "duration": 13 },
+#     ...
+#   ]
+
+set -euo pipefail
+
+# ---- Parse args ----
+PROJECT=""
+RATIO="16:9"
+PROMPTS_FILE=""
+TIMEOUT=600
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --project)  PROJECT="$2";      shift 2 ;;
+    --ratio)    RATIO="$2";        shift 2 ;;
+    --prompts-file) PROMPTS_FILE="$2"; shift 2 ;;
+    --timeout)  TIMEOUT="$2";      shift 2 ;;
+    *)          echo "Unknown arg: $1"; exit 1 ;;
+  esac
+done
+
+if [[ -z "$PROMPTS_FILE" ]]; then
+  echo "Error: --prompts-file is required."
+  echo "Usage: bash batch-generate.sh --project <id> --ratio <ratio> --prompts-file <prompts.json>"
+  exit 1
+fi
+
+if [[ ! -f "$PROMPTS_FILE" ]]; then
+  echo "Error: File not found: $PROMPTS_FILE"
+  exit 1
+fi
+
+# ---- Locate renoise-cli ----
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CLI="${SCRIPT_DIR}/../../renoise-gen/renoise-cli.mjs"
+
+if [[ ! -f "$CLI" ]]; then
+  echo "Error: renoise-cli.mjs not found at $CLI"
+  exit 1
+fi
+
+# ---- Check balance ----
+echo "=== Checking balance ==="
+node "$CLI" me
+echo ""
+
+# ---- Read prompts ----
+SHOT_COUNT=$(jq 'length' "$PROMPTS_FILE")
+echo "=== Batch generation: $SHOT_COUNT shots ==="
+echo "Project: ${PROJECT:-'(none)'}"
+echo "Ratio: $RATIO"
+echo "Timeout per shot: ${TIMEOUT}s"
+echo ""
+
+# ---- Results tracking ----
+RESULTS=()
+FAILED=0
+
+for i in $(seq 0 $((SHOT_COUNT - 1))); do
+  SHOT_ID=$(jq -r ".[$i].shot_id" "$PROMPTS_FILE")
+  PROMPT=$(jq -r ".[$i].prompt" "$PROMPTS_FILE")
+  DURATION=$(jq -r ".[$i].duration" "$PROMPTS_FILE")
+
+  echo "--- [$((i + 1))/$SHOT_COUNT] $SHOT_ID (${DURATION}s) ---"
+
+  # Build tags
+  TAGS="$SHOT_ID"
+  if [[ -n "$PROJECT" ]]; then
+    TAGS="$PROJECT,$SHOT_ID"
+  fi
+
+  # Create task
+  CREATE_OUTPUT=$(node "$CLI" create \
+    --prompt "$PROMPT" \
+    --duration "$DURATION" \
+    --ratio "$RATIO" \
+    --tags "$TAGS" 2>&1) || {
+    echo "[FAILED] $SHOT_ID — create error:"
+    echo "$CREATE_OUTPUT"
+    FAILED=$((FAILED + 1))
+    RESULTS+=("$SHOT_ID|FAILED|—|create error")
+    echo ""
+    echo "Stopping batch — fix the issue and re-run."
+    break
+  }
+
+  # Extract task ID from create output
+  TASK_ID=$(echo "$CREATE_OUTPUT" | grep -oE 'id=[0-9]+' | head -1 | cut -d= -f2)
+
+  if [[ -z "$TASK_ID" ]]; then
+    echo "[FAILED] $SHOT_ID — could not parse task ID from output:"
+    echo "$CREATE_OUTPUT"
+    FAILED=$((FAILED + 1))
+    RESULTS+=("$SHOT_ID|FAILED|—|no task ID")
+    break
+  fi
+
+  echo "Task created: #$TASK_ID"
+
+  # Wait for completion
+  WAIT_OUTPUT=$(node "$CLI" wait "$TASK_ID" --timeout "$TIMEOUT" 2>&1) || {
+    echo "[FAILED] $SHOT_ID (task #$TASK_ID) — wait error:"
+    echo "$WAIT_OUTPUT"
+    FAILED=$((FAILED + 1))
+    RESULTS+=("$SHOT_ID|FAILED|#$TASK_ID|wait timeout/error")
+    echo ""
+    echo "Stopping batch — the task may still be running. Check with: node renoise-cli.mjs get $TASK_ID"
+    break
+  }
+
+  # Get result
+  RESULT_OUTPUT=$(node "$CLI" result "$TASK_ID" 2>&1)
+  VIDEO_URL=$(echo "$RESULT_OUTPUT" | jq -r '.result.videoUrl // .videoUrl // "unknown"' 2>/dev/null || echo "unknown")
+
+  echo "[SUCCESS] $SHOT_ID → $VIDEO_URL"
+  RESULTS+=("$SHOT_ID|SUCCESS|#$TASK_ID|$VIDEO_URL")
+  echo ""
+done
+
+# ---- Summary ----
+echo ""
+echo "========================================="
+echo "  BATCH GENERATION SUMMARY"
+echo "========================================="
+printf "%-8s %-10s %-10s %s\n" "Shot" "Status" "Task" "URL"
+printf "%-8s %-10s %-10s %s\n" "----" "------" "----" "---"
+
+for entry in "${RESULTS[@]}"; do
+  IFS='|' read -r shot status task url <<< "$entry"
+  printf "%-8s %-10s %-10s %s\n" "$shot" "$status" "$task" "$url"
+done
+
+echo ""
+echo "Total: ${#RESULTS[@]}/$SHOT_COUNT completed, $FAILED failed"
+
+if [[ $FAILED -gt 0 ]]; then
+  exit 1
+fi