Update app.py

app.py

@@ -146,7 +146,11 @@ def add_speed_message(msg, speed_factor):
 
 
 def make_video(s, video_in, audio_in, trim_frames=0, speed_factor=1.0):
-    """Compile frames before the source video, then apply speed to the complete result."""
+    """Compile the extracted-frame intro with the currently selected, independently trimmed source video.
+
+    Extracted frames keep their existing extraction timing. Trimming affects only the source-video
+    section, then the whole compiled output is sped up/slowed down as the final operation.
+    """
     v_path = p(video_in)
     audio_path = p(audio_in)
     if not v_path:
@@ -163,42 +167,49 @@ def make_video(s, video_in, audio_in, trim_frames=0, speed_factor=1.0):
         if trim_frames > 0 and not has_frames:
             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.
+        # Always use the currently selected input as the original-video segment. The extracted
+        # frame state is used only to build the intro, so those two parts stay independent.
+        _, _, source_fps, source_duration = meta(v_path)
+        trim_seconds = trim_frames / source_fps
+        if trim_frames and trim_seconds >= source_duration:
+            return None, (
+                f"Cannot remove {trim_frames} source frame(s): the selected video is only "
+                f"{source_duration:.3f}s long at {source_fps:.3f} FPS."
+            )
+
         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:
-                out = os.path.join(tempfile.mkdtemp(), f"final_audio_{int(time.time() * 1000)}.mp4")
+            # With no intro frames, trim the source video if requested (the UI normally expects
+            # a frame intro for trimming, but this branch remains safe if called directly).
+            if trim_frames:
+                return None, "Extract frames first to use initial-frame trimming."
+            base_out = v_path
+            msg = "✅ Final video created from the original video. No extracted-frame intro was added."
+            if audio_path:
+                base_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 []
+                loop_args = ["-stream_loop", "-1"] if replacement_duration > 0 and (source_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),
+                    "-t", str(source_duration),
                     "-c:v", "copy", "-c:a", "aac", "-b:a", "192k",
-                    "-movflags", "+faststart", out,
+                    "-movflags", "+faststart", base_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."
+            final_out = apply_speed_to_video(base_out, speed_factor)
+            return final_out, add_speed_message(msg, speed_factor)
 
+        # Build the intro from the extracted frames with the same frame rate as extraction,
+        # preserving the existing behavior. Trimming below is calculated from the current source.
+        frame_dir, frames = s["d"], s["fs"]
+        intro_fps = float(s["fps"])
         intro = os.path.join(frame_dir, "intro.mp4")
         r = subprocess.run(
             [
-                "ffmpeg", "-y", "-framerate", str(fps),
+                "ffmpeg", "-y", "-framerate", str(intro_fps),
                 "-i", os.path.join(frame_dir, "f_%06d.png"),
                 "-c:v", "libx264", "-crf", "18", "-preset", "medium",
                 "-pix_fmt", "yuv420p", intro,
@@ -208,36 +219,57 @@ def make_video(s, video_in, audio_in, trim_frames=0, speed_factor=1.0):
         if r.returncode:
             return None, r.stderr or "Could not compile extracted frames."
 
-        intro_duration = len(frames) / fps
-        total_duration = intro_duration + (source_duration - trim_seconds)
+        intro_duration = len(frames) / intro_fps
+        body_duration = source_duration - trim_seconds
+        total_duration = intro_duration + body_duration
         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]"
+
+        # Normalize the source segment after trimming, then concatenate it after the intro.
+        # Scaling/padding the intro to source dimensions avoids concat failures if the selected
+        # source video differs from the video used to extract the frames.
+        width, height, _, _ = meta(v_path)
+        video_filter = (
+            f"[0:v:0]scale={width}:{height}:force_original_aspect_ratio=decrease,"
+            f"pad={width}:{height}:(ow-iw)/2:(oh-ih)/2,setsar=1,fps={source_fps:.8f}[intro];"
+            f"[1:v:0]trim=start_frame={trim_frames},setpts=PTS-STARTPTS,"
+            f"fps={source_fps:.8f},setsar=1[body];"
+            "[intro][body]concat=n=2:v=1:a=0[vout]"
         )
 
+        cmd = ["ffmpeg", "-y", "-i", intro, "-i", v_path]
         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,
+            cmd += loop_args + ["-i", audio_path,
+                "-filter_complex", video_filter,
                 "-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,
-            ]
+                "-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,
-            ]
+            if stream_has_audio(v_path):
+                # Keep source audio aligned with the trimmed video section. The intro is silent.
+                audio_filter = (
+                    f"{video_filter};[1:a:0]atrim=start={trim_seconds:.8f},"
+                    f"asetpts=PTS-STARTPTS,adelay={int(round(intro_duration * 1000))}:all=1[aout]"
+                )
+                cmd += [
+                    "-filter_complex", audio_filter,
+                    "-map", "[vout]", "-map", "[aout]",
+                    "-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 += [
+                    "-filter_complex", video_filter,
+                    "-map", "[vout]", "-an",
+                    "-t", str(total_duration),
+                    "-c:v", "libx264", "-crf", "18", "-preset", "medium",
+                    "-pix_fmt", "yuv420p", "-movflags", "+faststart", out,
+                ]
 
         result = subprocess.run(cmd, capture_output=True, text=True)
         if result.returncode:
@@ -245,16 +277,22 @@ def make_video(s, video_in, audio_in, trim_frames=0, speed_factor=1.0):
 
         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)."
+            msg += f" Original video starts after skipping {trim_frames} frame(s) ({trim_seconds:.3f}s at {source_fps:.3f} FPS)."
+        else:
+            msg += " Original video starts from its beginning."
         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."
+        elif stream_has_audio(v_path):
+            msg += " Original audio is trimmed to match the original-video section; the intro is silent."
         else:
-            msg += " Original video audio retained when available."
-        out = apply_speed_to_video(out, speed_factor)
-        return out, add_speed_message(msg, speed_factor)
+            msg += " The source video has no audio track."
+
+        # Speed is deliberately the final step, so it affects the intro and original video together.
+        final_out = apply_speed_to_video(out, speed_factor)
+        return final_out, add_speed_message(msg, speed_factor)
 
     except Exception as e:
         return None, str(e)
@@ -275,7 +313,7 @@ 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. Applies when extracted frames are added first.",
+            info="Affects only the original-video section, not the extracted-frame intro. Frame count is based on the currently selected original video FPS.",
         )
 
     with gr.Row():