Skip to content

Open-source AI podcast clipper. Generate vertical clips with face tracking and burned-in captions. CLI, MCP server, web app.

Fix premature outro transition and soften fallback audio join

Nika Siradze6070a4a37f25
diff --git a/backend/services/video_processor.py b/backend/services/video_processor.py
index 15706c6..55290ec 100644
--- a/backend/services/video_processor.py
+++ b/backend/services/video_processor.py
@@ -8,6 +8,7 @@ audio normalization, and final encoding.
import os
import subprocess
import json
+import math
from typing import Optional
from services.encoder import get_video_encode_flags
@@ -79,6 +80,41 @@ def get_video_info(video_path: str) -> dict:
return json.loads(result.stdout)
+def _parse_duration_seconds(value: object) -> Optional[float]:
+ """Parse a duration value and reject invalid/non-finite numbers."""
+ try:
+ parsed = float(str(value).strip())
+ except Exception:
+ return None
+ if not math.isfinite(parsed) or parsed <= 0:
+ return None
+ return parsed
+
+
+def _get_media_duration_seconds(video_path: str, default: float = 0.0) -> float:
+ """
+ Best-effort media duration in seconds.
+ Prefers max valid duration from format/streams, else returns default.
+ """
+ try:
+ info = get_video_info(video_path)
+ except Exception:
+ return default
+
+ candidates: list[float] = []
+ fmt = info.get("format", {})
+ fmt_duration = _parse_duration_seconds(fmt.get("duration"))
+ if fmt_duration is not None:
+ candidates.append(fmt_duration)
+
+ for stream in info.get("streams", []):
+ stream_duration = _parse_duration_seconds(stream.get("duration"))
+ if stream_duration is not None:
+ candidates.append(stream_duration)
+
+ return max(candidates) if candidates else default
+
+
def get_dimensions(video_path: str) -> tuple[int, int]:
"""Get video width and height."""
info = get_video_info(video_path)
@@ -2980,18 +3016,8 @@ def concat_outro(
"""
width, height = get_dimensions(input_path)
- # Get main clip duration for crossfade offset
- probe_cmd = [
- "ffprobe", "-v", "quiet", "-print_format", "json",
- "-show_format", input_path,
- ]
- probe = subprocess.run(probe_cmd, capture_output=True, text=True, timeout=_FFMPEG_TIMEOUT)
- try:
- main_duration = float(json.loads(probe.stdout)["format"]["duration"])
- except Exception:
- main_duration = 30.0
-
- fade_offset = max(0, main_duration - crossfade_duration)
+ main_duration = _get_media_duration_seconds(input_path, default=30.0)
+ safe_crossfade = _parse_duration_seconds(crossfade_duration) or 0.5
# Re-encode outro to match dimensions
outro_scaled = output_path + ".outro_scaled.mp4"
@@ -3010,46 +3036,83 @@ def concat_outro(
label="outro_scale",
)
+ outro_duration = _get_media_duration_seconds(outro_scaled, default=0.0)
+ safe_crossfade = min(safe_crossfade, max(0.05, main_duration - 0.05))
+ if outro_duration > 0:
+ safe_crossfade = min(safe_crossfade, max(0.05, outro_duration - 0.05))
+ fade_offset = max(0.0, main_duration - safe_crossfade)
+ can_crossfade = fade_offset >= 0.05 and safe_crossfade >= 0.05
+
# Try crossfade (requires FFmpeg 4.3+).
- # acrossfade often fails on mismatched streams, so use afade on
- # each input and amerge instead — more robust.
- for audio_filter in [
- # Option 1: fade out main audio, fade in outro audio, then amerge
- (
- f"[0:v][1:v]xfade=transition=fade:duration={crossfade_duration}:offset={fade_offset}[v];"
- f"[0:a]afade=t=out:st={fade_offset}:d={crossfade_duration}[a0];"
- f"[1:a]afade=t=in:st=0:d={crossfade_duration}[a1];"
- f"[a0][a1]concat=n=2:v=0:a=1[a]"
- ),
- # Option 2: just video xfade, concat audio without crossfade
- (
- f"[0:v][1:v]xfade=transition=fade:duration={crossfade_duration}:offset={fade_offset}[v];"
- f"[0:a][1:a]concat=n=2:v=0:a=1[a]"
- ),
- ]:
+ # If durations are too short or malformed, skip xfade entirely to avoid
+ # transition-at-t=0 behavior that can make outro appear instantly.
+ if can_crossfade:
+ for audio_filter in [
+ # Option 1: proper audio crossfade.
+ (
+ f"[0:v][1:v]xfade=transition=fade:duration={safe_crossfade}:offset={fade_offset}[v];"
+ f"[0:a][1:a]acrossfade=d={safe_crossfade}[a]"
+ ),
+ # Option 2: video xfade + hard audio concat fallback.
+ (
+ f"[0:v][1:v]xfade=transition=fade:duration={safe_crossfade}:offset={fade_offset}[v];"
+ f"[0:a][1:a]concat=n=2:v=0:a=1[a]"
+ ),
+ ]:
+ try:
+ xfade_cmd = [
+ "ffmpeg", "-y",
+ "-i", input_path,
+ "-i", outro_scaled,
+ "-filter_complex", audio_filter,
+ "-map", "[v]", "-map", "[a]",
+ ]
+ xfade_cmd += get_video_encode_flags()
+ xfade_cmd += [
+ "-c:a", "aac", "-b:a", "192k",
+ "-movflags", "+faststart",
+ output_path,
+ ]
+ result = subprocess.run(xfade_cmd, capture_output=True, text=True, timeout=_FFMPEG_TIMEOUT)
+ if result.returncode == 0:
+ if os.path.exists(outro_scaled):
+ os.remove(outro_scaled)
+ return output_path
+ except Exception:
+ continue
+
+ # Fallback 1: hard video cut + softened audio boundary
+ # (keeps playback natural even when xfade is unavailable/fails).
+ if _has_audio_stream(input_path) and _has_audio_stream(outro_scaled):
+ audio_fade = min(safe_crossfade, max(0.05, main_duration - 0.05))
+ audio_fade_start = max(0.0, main_duration - audio_fade)
try:
- xfade_cmd = [
- "ffmpeg", "-y",
- "-i", input_path,
- "-i", outro_scaled,
- "-filter_complex", audio_filter,
- "-map", "[v]", "-map", "[a]",
- ]
- xfade_cmd += get_video_encode_flags()
- xfade_cmd += [
- "-c:a", "aac", "-b:a", "192k",
- "-movflags", "+faststart",
- output_path,
- ]
- result = subprocess.run(xfade_cmd, capture_output=True, text=True, timeout=_FFMPEG_TIMEOUT)
- if result.returncode == 0:
- if os.path.exists(outro_scaled):
- os.remove(outro_scaled)
- return output_path
+ return _run_ffmpeg_with_fallback(
+ cmd_parts_before_enc=[
+ "ffmpeg", "-y",
+ "-i", input_path,
+ "-i", outro_scaled,
+ "-filter_complex",
+ (
+ "[0:v][1:v]concat=n=2:v=1:a=0[v];"
+ f"[0:a]afade=t=out:st={audio_fade_start}:d={audio_fade}[a0];"
+ f"[1:a]afade=t=in:st=0:d={audio_fade}[a1];"
+ "[a0][a1]concat=n=2:v=0:a=1[a]"
+ ),
+ "-map", "[v]",
+ "-map", "[a]",
+ ],
+ cmd_parts_after_enc=[
+ "-c:a", "aac", "-b:a", "192k", "-ar", "44100",
+ "-movflags", "+faststart",
+ ],
+ output_path=output_path,
+ label="outro_hardcut_soft_audio",
+ )
except Exception:
- continue
+ pass
- # Fallback: hard cut concat
+ # Fallback 2: pure hard cut concat
main_reenc = output_path + ".main_reenc.mp4"
concat_list = os.path.join(os.path.dirname(output_path), "concat_list.txt")
diff --git a/tests/test_video_processor.py b/tests/test_video_processor.py
index e1142f8..2cf8c2c 100644
--- a/tests/test_video_processor.py
+++ b/tests/test_video_processor.py
@@ -13,6 +13,40 @@ from services import video_processor as vp
class VideoProcessorTests(unittest.TestCase):
+ def test_parse_duration_seconds_rejects_nan(self):
+ self.assertIsNone(vp._parse_duration_seconds("nan"))
+ self.assertIsNone(vp._parse_duration_seconds(float("inf")))
+ self.assertIsNone(vp._parse_duration_seconds(0))
+ self.assertEqual(vp._parse_duration_seconds("12.5"), 12.5)
+
+ def test_get_media_duration_seconds_falls_back_to_default_on_invalid_values(self):
+ fake_info = {
+ "format": {"duration": "nan"},
+ "streams": [{"codec_type": "video", "duration": "N/A"}],
+ }
+ with mock.patch.object(vp, "get_video_info", return_value=fake_info):
+ duration = vp._get_media_duration_seconds("/tmp/fake.mp4", default=30.0)
+ self.assertEqual(duration, 30.0)
+
+ def test_concat_outro_uses_soft_audio_fallback_before_hard_concat(self):
+ run_fail = mock.Mock(returncode=1, stdout="", stderr="xfade unavailable")
+ with mock.patch.object(vp, "get_dimensions", return_value=(1080, 1920)), \
+ mock.patch.object(vp, "_get_media_duration_seconds", side_effect=[20.0, 5.0]), \
+ mock.patch.object(vp, "_has_audio_stream", return_value=True), \
+ mock.patch.object(vp, "get_video_encode_flags", return_value=vp.CPU_FLAGS), \
+ mock.patch.object(vp.os.path, "exists", return_value=False), \
+ mock.patch.object(vp, "_run_ffmpeg_with_fallback") as run_ffmpeg, \
+ mock.patch.object(vp.subprocess, "run", return_value=run_fail):
+ run_ffmpeg.side_effect = [
+ "/tmp/outro_scaled.mp4", # outro scaling
+ "/tmp/out.mp4", # soft-audio fallback
+ ]
+ out = vp.concat_outro("/tmp/in.mp4", "/tmp/outro.mp4", "/tmp/out.mp4")
+
+ self.assertEqual(out, "/tmp/out.mp4")
+ self.assertGreaterEqual(run_ffmpeg.call_count, 2)
+ self.assertEqual(run_ffmpeg.call_args_list[1].kwargs.get("label"), "outro_hardcut_soft_audio")
+
def test_resolve_speaker_sides_does_not_guess_from_transcript_order(self):
speaker_side = vp._resolve_speaker_sides(
segments=[(0.0, 2.0, "SPEAKER_00"), (2.0, 4.0, "SPEAKER_01")],