Update app.py

app.py

@@ -75,62 +75,60 @@ def save_frames(v, t, n):
         return [], None, str(e)
 
 
-def extract_last(v, n):
-    v = p(v)
-    if not v:
-        return [], None, "Upload a video."
-    try:
-        n = int(n)
-        _, _, fps, dur = meta(v)
-        if n < 1:
-            return [], None, "Number of frames must be at least 1."
-        t = max(0, dur - (n / fps))
-        return save_frames(v, t, n)
-    except Exception as e:
-        return [], None, str(e)
+def clear_extracted_frames():
+    """Clear the selected frame sequence and reset trimming tied to that sequence."""
+    return (
+        [],
+        None,
+        "✅ Extracted frames cleared. The final video will not have a frame intro.",
+        0,
+    )
 
 
+def stream_has_audio(path):
+    """Return True when a media file contains an audio stream."""
+    if not path:
+        return False
+    probe = subprocess.run(
+        [
+            "ffprobe", "-v", "error", "-select_streams", "a:0",
+            "-show_entries", "stream=index", "-of", "csv=p=0", path,
+        ],
+        capture_output=True, text=True,
+    )
+    return probe.returncode == 0 and bool(probe.stdout.strip())
+
 
 def apply_speed_to_video(input_path, speed_factor):
-    """Change the playback speed of the complete compiled video and its audio."""
+    """Change playback speed of the complete video and its audio together."""
     speed_factor = float(speed_factor)
     if not 0.5 <= speed_factor <= 1.5:
         raise ValueError("Playback speed must be between 0.5x and 1.5x.")
     if abs(speed_factor - 1.0) < 1e-9:
         return input_path
 
-    # Detect whether the compiled video has an audio stream.
-    probe = subprocess.run(
-        [
-            "ffprobe", "-v", "error", "-select_streams", "a:0",
-            "-show_entries", "stream=index", "-of", "csv=p=0", input_path,
-        ],
-        capture_output=True, text=True,
-    )
-    has_audio = probe.returncode == 0 and bool(probe.stdout.strip())
+    has_audio = stream_has_audio(input_path)
     sped_path = os.path.join(
         tempfile.mkdtemp(), f"speed_{int(time.time() * 1000)}.mp4"
     )
-
-    common = [
-        "ffmpeg", "-y", "-i", input_path,
-    ]
+    cmd = ["ffmpeg", "-y", "-i", input_path]
     if has_audio:
-        # setpts makes the video faster/slower; atempo applies the same factor to audio.
-        cmd = common + [
+        cmd += [
             "-filter_complex",
-            f"[0:v:0]setpts=PTS/{speed_factor}[v];[0:a:0]atempo={speed_factor}[a]",
+            f"[0:v:0]setpts=PTS/{speed_factor:.6f}[v];"
+            f"[0:a:0]atempo={speed_factor:.6f}[a]",
             "-map", "[v]", "-map", "[a]",
             "-c:v", "libx264", "-crf", "18", "-preset", "medium",
+            "-pix_fmt", "yuv420p",
             "-c:a", "aac", "-b:a", "192k",
             "-movflags", "+faststart", sped_path,
         ]
     else:
-        cmd = common + [
-            "-vf", f"setpts=PTS/{speed_factor}",
+        cmd += [
+            "-vf", f"setpts=PTS/{speed_factor:.6f}",
             "-map", "0:v:0", "-an",
             "-c:v", "libx264", "-crf", "18", "-preset", "medium",
-            "-movflags", "+faststart", sped_path,
+            "-pix_fmt", "yuv420p", "-movflags", "+faststart", sped_path,
         ]
 
     result = subprocess.run(cmd, capture_output=True, text=True)
@@ -139,25 +137,18 @@ def apply_speed_to_video(input_path, speed_factor):
     return sped_path
 
 
-def finish_video(out, msg, speed_factor):
-    """Apply the selected speed to the full result and update the status message."""
-    speed_factor = float(speed_factor)
-    if abs(speed_factor - 1.0) < 1e-9:
-        msg += " Playback speed: normal (1.0x)."
-    else:
-        out = apply_speed_to_video(out, speed_factor)
-        if speed_factor < 1.0:
-            msg += f" Playback slowed to {speed_factor:.1f}x."
-        else:
-            msg += f" Playback sped up to {speed_factor:.1f}x."
-    return out, msg
+def add_speed_message(msg, speed_factor):
+    if abs(float(speed_factor) - 1.0) < 1e-9:
+        return msg + " Playback speed: normal (1.0x)."
+    if speed_factor < 1.0:
+        return msg + f" Entire video slowed to {speed_factor:.1f}x."
+    return msg + f" Entire video sped up to {speed_factor:.1f}x."
 
 
 def make_video(s, video_in, audio_in, trim_frames=0, speed_factor=1.0):
-    """Compile extracted frames before the source video, optionally skipping its first N frames."""
+    """Compile frames before the source video, then apply speed to the complete result."""
     v_path = p(video_in)
     audio_path = p(audio_in)
-
     if not v_path:
         return None, "Upload a video first."
 
@@ -170,114 +161,100 @@ def make_video(s, video_in, audio_in, trim_frames=0, speed_factor=1.0):
         if not 0.5 <= speed_factor <= 1.5:
             return None, "Playback speed must be between 0.5x and 1.5x."
         if trim_frames > 0 and not has_frames:
-            return None, "Extract frames first to use the initial-frame trimming feature."
-
-        if not has_frames and not audio_path:
-            return None, "Extract frames first OR upload an audio file to replace."
-
-        out = os.path.join(tempfile.mkdtemp(), f"final_{int(time.time())}.mp4")
-
-        if has_frames:
-            d_s, v, fs, fps, dur = s["d"], s["v"], s["fs"], s["fps"], s["dur"]
-            trim_seconds = trim_frames / fps
-            if trim_seconds >= dur:
-                return None, f"Cannot remove {trim_frames} frame(s): the video is only {dur:.3f}s long."
-
-            intro_duration = len(fs) / fps
-            total_vid_dur = (dur - trim_seconds) + intro_duration
-            intro = os.path.join(d_s, "intro.mp4")
-
-            # Turn the extracted PNG sequence into a short video.
-            r = subprocess.run(
-                [
-                    "ffmpeg", "-y", "-framerate", str(fps),
-                    "-i", os.path.join(d_s, "f_%06d.png"),
-                    "-c:v", "libx264", "-crf", "18", "-preset", "medium",
-                    "-pix_fmt", "yuv420p", intro,
-                ],
-                capture_output=True, text=True,
-            )
-            if r.returncode:
-                return None, r.stderr
-
-            # Drop the specified number of initial source-video frames, reset timestamps,
-            # and place the extracted frame sequence before the remaining source video.
-            concat_filter = (
-                f"[1:v]trim=start_frame={trim_frames},setpts=PTS-STARTPTS[vtrim];"
-                "[0:v][vtrim]concat=n=2:v=1:a=0[v]"
-            )
-        else:
-            # Audio replacement without extracted frames retains the original video.
-            _, _, _, dur = meta(v_path)
-            total_vid_dur = dur
-            v = v_path
-            fs = []
-            trim_seconds = 0.0
-            intro = None
-            concat_filter = None
-
-        if audio_path:
-            a_dur = audio_meta(audio_path)
-            loop_args = ["-stream_loop", "-1"] if (total_vid_dur - a_dur) > 1.0 else []
-
-            if has_frames:
-                cmd = (
-                    ["ffmpeg", "-y", "-i", intro, "-i", v]
-                    + loop_args
-                    + [
-                        "-i", audio_path,
-                        "-filter_complex", concat_filter,
-                        "-map", "[v]", "-map", "2:a",
-                        "-t", str(total_vid_dur),
-                        "-c:v", "libx264", "-crf", "18", "-preset", "medium",
-                        "-c:a", "aac", "-b:a", "192k", "-movflags", "+faststart", out,
-                    ]
-                )
+            return None, "Extract frames first to use initial-frame trimming."
+
+        # With no extracted frames, keep the original video (and its original audio)
+        # unless the user supplies replacement audio.
+        if not has_frames:
+            _, _, _, duration = meta(v_path)
+            if not audio_path:
+                out = v_path
+                msg = "✅ Final video created from the original video. No extracted-frame intro was added."
             else:
-                cmd = (
-                    ["ffmpeg", "-y", "-i", v]
-                    + loop_args
-                    + [
-                        "-i", audio_path,
-                        "-map", "0:v", "-map", "1:a",
-                        "-t", str(total_vid_dur),
-                        "-c:v", "copy", "-c:a", "aac", "-b:a", "192k",
-                        "-movflags", "+faststart", out,
-                    ]
-                )
-
-            r = subprocess.run(cmd, capture_output=True, text=True)
-            if r.returncode:
-                return None, r.stderr
-
-            msg = "✅ Final video created."
-            if has_frames:
-                msg += f" Added {len(fs)} frame(s)."
-            if trim_frames:
-                msg += f" Removed the first {trim_frames} source frame(s) ({trim_seconds:.3f}s)."
-            if loop_args:
-                msg += f" Audio looped (was {total_vid_dur - a_dur:.1f}s short)."
-            else:
-                msg += " Audio matched to video length."
-            return finish_video(out, msg, speed_factor)
-
-        # Keep the source video's audio if no replacement audio was uploaded.
-        cmd = [
-            "ffmpeg", "-y", "-i", intro, "-i", v,
-            "-filter_complex", concat_filter,
-            "-map", "[v]", "-map", "1:a?",
-            "-t", str(total_vid_dur),
-            "-c:v", "libx264", "-crf", "18", "-preset", "medium",
-            "-c:a", "copy", "-movflags", "+faststart", out,
-        ]
-        r = subprocess.run(cmd, capture_output=True, text=True)
+                out = os.path.join(tempfile.mkdtemp(), f"final_audio_{int(time.time() * 1000)}.mp4")
+                replacement_duration = audio_meta(audio_path)
+                loop_args = ["-stream_loop", "-1"] if replacement_duration > 0 and (duration - replacement_duration) > 1.0 else []
+                cmd = ["ffmpeg", "-y", "-i", v_path] + loop_args + [
+                    "-i", audio_path,
+                    "-map", "0:v:0", "-map", "1:a:0",
+                    "-t", str(duration),
+                    "-c:v", "copy", "-c:a", "aac", "-b:a", "192k",
+                    "-movflags", "+faststart", out,
+                ]
+                result = subprocess.run(cmd, capture_output=True, text=True)
+                if result.returncode:
+                    return None, result.stderr or "Could not replace the audio."
+                msg = "✅ Final video created using the original video and replacement audio."
+            out = apply_speed_to_video(out, speed_factor)
+            return out, add_speed_message(msg, speed_factor)
+
+        # Use the video associated with the extracted frames and its original frame rate.
+        frame_state_video = s["v"]
+        frame_dir, frames, fps, source_duration = s["d"], s["fs"], s["fps"], s["dur"]
+        trim_seconds = trim_frames / fps
+        if trim_seconds >= source_duration:
+            return None, f"Cannot remove {trim_frames} frame(s): the video is only {source_duration:.3f}s long."
+
+        intro = os.path.join(frame_dir, "intro.mp4")
+        r = subprocess.run(
+            [
+                "ffmpeg", "-y", "-framerate", str(fps),
+                "-i", os.path.join(frame_dir, "f_%06d.png"),
+                "-c:v", "libx264", "-crf", "18", "-preset", "medium",
+                "-pix_fmt", "yuv420p", intro,
+            ],
+            capture_output=True, text=True,
+        )
         if r.returncode:
-            return None, r.stderr
+            return None, r.stderr or "Could not compile extracted frames."
+
+        intro_duration = len(frames) / fps
+        total_duration = intro_duration + (source_duration - trim_seconds)
+        out = os.path.join(tempfile.mkdtemp(), f"final_{int(time.time() * 1000)}.mp4")
+        video_concat = (
+            f"[1:v:0]trim=start_frame={trim_frames},setpts=PTS-STARTPTS[bodyv];"
+            "[0:v:0][bodyv]concat=n=2:v=1:a=0[vout]"
+        )
 
-        msg = f"✅ Added {len(fs)} frame(s) to the beginning (original audio kept)."
+        if audio_path:
+            replacement_duration = audio_meta(audio_path)
+            loop_args = ["-stream_loop", "-1"] if replacement_duration > 0 and (total_duration - replacement_duration) > 1.0 else []
+            cmd = ["ffmpeg", "-y", "-i", intro, "-i", frame_state_video] + loop_args + [
+                "-i", audio_path,
+                "-filter_complex", video_concat,
+                "-map", "[vout]", "-map", "2:a:0",
+                "-t", str(total_duration),
+                "-c:v", "libx264", "-crf", "18", "-preset", "medium",
+                "-pix_fmt", "yuv420p", "-c:a", "aac", "-b:a", "192k",
+                "-movflags", "+faststart", out,
+            ]
+        else:
+            cmd = [
+                "ffmpeg", "-y", "-i", intro, "-i", frame_state_video,
+                "-filter_complex", video_concat,
+                "-map", "[vout]", "-map", "1:a?",
+                "-t", str(total_duration),
+                "-c:v", "libx264", "-crf", "18", "-preset", "medium",
+                "-pix_fmt", "yuv420p", "-c:a", "aac", "-b:a", "192k",
+                "-movflags", "+faststart", out,
+            ]
+
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode:
+            return None, result.stderr or "Could not compile the final video."
+
+        msg = f"✅ Final video created. Added {len(frames)} extracted frame(s)."
         if trim_frames:
             msg += f" Removed the first {trim_frames} source frame(s) ({trim_seconds:.3f}s)."
-        return finish_video(out, msg, speed_factor)
+        if audio_path:
+            if loop_args:
+                msg += f" Replacement audio looped (it was {total_duration - replacement_duration:.1f}s short)."
+            else:
+                msg += " Replacement audio added."
+        else:
+            msg += " Original video audio retained when available."
+        out = apply_speed_to_video(out, speed_factor)
+        return out, add_speed_message(msg, speed_factor)
 
     except Exception as e:
         return None, str(e)
@@ -298,26 +275,26 @@ with gr.Blocks(title="Video Frame Editor") as demo:
             minimum=0,
             precision=0,
             label="Initial Frames to Remove from Original Video",
-            info="Set to 0 to keep the original beginning. This applies when extracted frames are added first.",
+            info="Set to 0 to keep the original beginning. Applies when extracted frames are added first.",
         )
 
-    speed_factor = gr.Slider(
-        minimum=0.5,
-        maximum=1.5,
-        value=1.0,
-        step=0.1,
-        label="Whole Video Playback Speed",
-        info="0.5x = half speed, 1.0x = normal speed, 1.5x = 50% faster. Audio speed changes too.",
-    )
-
     with gr.Row():
         extract_btn = gr.Button("🎞️ Extract From Time", variant="primary")
-        last_btn = gr.Button("⏮️ Extract From Last")
+        clear_btn = gr.Button("🧹 Clear Extracted Frames")
 
     gallery = gr.Gallery(label="Extracted Frames", columns=5, object_fit="contain")
     state = gr.State()
     status = gr.Textbox(label="Status")
 
+    # Keep the whole-video speed control immediately above the compile button.
+    speed_factor = gr.Slider(
+        minimum=0.5,
+        maximum=1.5,
+        value=1.0,
+        step=0.1,
+        label="Whole Video Playback Speed",
+        info="0.5x = half speed, 1.0x = normal speed, 1.5x = 50% faster. Applies to the entire final video and its audio.",
+    )
     copy_btn = gr.Button("📋 Compile Final Video", variant="primary")
     output = gr.Video(label="Final Video")
     output_status = gr.Textbox(label="Output Status")
@@ -327,13 +304,11 @@ with gr.Blocks(title="Video Frame Editor") as demo:
         inputs=[video, start, count],
         outputs=[gallery, state, status],
     )
-
-    last_btn.click(
-        fn=extract_last,
-        inputs=[video, count],
-        outputs=[gallery, state, status],
+    clear_btn.click(
+        fn=clear_extracted_frames,
+        inputs=[],
+        outputs=[gallery, state, status, trim_count],
     )
-
     copy_btn.click(
         fn=make_video,
         inputs=[state, video, audio_in, trim_count, speed_factor],