Update app.py

app.py

@@ -18,27 +18,27 @@ def get_media_duration(file_path):
         return 5.0
 
 def create_static_background(image_path, output_path):
-    """Creates a darkened, blurred background (720p optimized)."""
+    """Creates a darkened, blurred background (720p)."""
     target_size = (720, 1280)
     with Image.open(image_path) as img:
         img = img.convert("RGB")
         bg = ImageOps.fit(img, target_size, method=Image.Resampling.LANCZOS)
-        bg = bg.filter(ImageFilter.GaussianBlur(radius=25)) 
+        bg = bg.filter(ImageFilter.GaussianBlur(radius=30)) 
         enhancer = ImageEnhance.Brightness(bg)
-        bg = enhancer.enhance(0.6)
+        bg = enhancer.enhance(0.5) 
         bg.save(output_path, "JPEG", quality=95)
     return output_path
 
 def prepare_foreground(image_path, output_path):
     """
-    Prepares foreground image.
-    CHANGE: Resizes to 1080px width (High Res) instead of 720px.
-    This provides extra pixels so the zoom doesn't look pixelated/stucky.
+    CRITICAL FOR SMOOTHNESS:
+    Upscales image to 2560px (2K) even for 30 FPS output.
+    This creates a high-res grid so movement doesn't snap to pixels.
     """
-    target_width = 1080 
+    target_width = 2560 
     with Image.open(image_path) as img:
         img = img.convert("RGB")
-        # Calculate height to keep aspect ratio
+        
         w_percent = (target_width / float(img.size[0]))
         h_size = int((float(img.size[1]) * float(w_percent)))
         
@@ -48,38 +48,33 @@ def prepare_foreground(image_path, output_path):
 
 def get_smooth_movement_filter(total_frames, fg_w, fg_h):
     """
-    Generates a 60FPS zoompan filter.
-    We add a buffer to 'd' (duration) to prevent end-of-clip freezing.
+    Generates 30 FPS zoompan filter.
     """
     move_type = random.choice(["zoom_in", "zoom_out", "pan_up", "pan_down"])
     
-    # We output the result at 720x1280, even if input is larger
-    # d={total_frames + 60} provides a 1-second safety buffer so it never runs out of frames
-    common = f"d={total_frames + 60}:s=720x1280:fps=60"
+    # 30 FPS buffer (add 30 frames extra to prevent end freeze)
+    # s=1280x720: Downscales the high-res movement to 720p smoothly
+    common = f"d={total_frames + 30}:s=1280x720:fps=30"
     
-    # We use the EXACT duration for the math, so the movement finishes exactly when audio ends
     math_duration = total_frames
     
+    # 0.15 zoom factor is the sweet spot for 30fps smoothness
     if move_type == "zoom_in":
-        # Linear Zoom In (Slow & Smooth)
         z = f"1+(0.15*on/{math_duration})" 
         x = "iw/2-(iw/zoom/2)"
         y = "ih/2-(ih/zoom/2)"
         
     elif move_type == "zoom_out":
-        # Linear Zoom Out
         z = f"1.15-(0.15*on/{math_duration})"
         x = "iw/2-(iw/zoom/2)"
         y = "ih/2-(ih/zoom/2)"
         
     elif move_type == "pan_up":
-        # Linear Pan Up
         z = "1.15"
         x = "iw/2-(iw/zoom/2)"
         y = f"(ih-ih/zoom)*(1-on/{math_duration})"
 
     else: # pan_down
-        # Linear Pan Down
         z = "1.15"
         x = "iw/2-(iw/zoom/2)"
         y = f"(ih-ih/zoom)*(on/{math_duration})"
@@ -90,11 +85,9 @@ def process_batch(image_files, audio_files, progress=gr.Progress()):
     if not image_files or not audio_files:
         raise gr.Error("Please upload both images and audio.")
     
-    # Sort files
     image_files.sort(key=lambda x: x.name)
     audio_files.sort(key=lambda x: x.name)
 
-    # Cleanup
     output_dir = "temp_clips"
     processed_img_dir = "temp_images"
     for d in [output_dir, processed_img_dir]:
@@ -105,29 +98,24 @@ def process_batch(image_files, audio_files, progress=gr.Progress()):
     clip_paths = []
     
     for i, (img_path, aud_path) in enumerate(zip(image_files, audio_files)):
-        progress((i / len(image_files)), desc=f"Rendering Scene {i+1} (60 FPS)...")
+        progress((i / len(image_files)), desc=f"Rendering Scene {i+1} (30 FPS High-Res)...")
         
         try:
-            # Prepare Images
+            # 1. Background
             bg_path = os.path.join(processed_img_dir, f"bg_{i}.jpg")
             create_static_background(img_path, bg_path)
             
+            # 2. Foreground (High Res 2K)
             fg_path = os.path.join(processed_img_dir, f"fg_{i}.jpg")
-            # fg_w/h will be High Res (1080p width)
             fg_w, fg_h = prepare_foreground(img_path, fg_path)
             
             duration = get_media_duration(aud_path)
             
-            # CHANGE: Calculate for 60 FPS
-            dur_frames = int(duration * 60)
+            # CHANGE: Calculate frames for 30 FPS
+            dur_frames = int(duration * 30)
             
-            # Get the Fixed Filter
             movement_filter = get_smooth_movement_filter(dur_frames, fg_w, fg_h)
             
-            # Filter Complex:
-            # 1. Background is input 0
-            # 2. Foreground is input 1 -> goes into zoompan -> becomes [fg_move]
-            # 3. [fg_move] is overlayed on [0:v]
             filter_complex = (
                 f"[1:v]{movement_filter}[fg_move];"
                 f"[0:v][fg_move]overlay=(W-w)/2:(H-h)/2,"
@@ -139,20 +127,24 @@ def process_batch(image_files, audio_files, progress=gr.Progress()):
             cmd = [
                 "ffmpeg", "-y", "-hide_banner", "-loglevel", "error",
                 "-loop", "1", "-i", bg_path,
+                
+                # Input framerate 30 to match output
+                "-framerate", "30", 
                 "-loop", "1", "-i", fg_path,
+                
                 "-i", aud_path,
                 "-filter_complex", filter_complex,
                 "-map", "[v]", "-map", "2:a",
-                "-r", "60",                     # CHANGE: 60 FPS output
+                
+                "-r", "30",                     # 30 FPS Output
                 "-c:v", "libx264", 
-                "-crf", "23",                   # CHANGE: Slightly higher quality (lower CRF)
-                "-preset", "veryfast",          # CHANGE: veryfast is smoother than ultrafast
-                "-c:a", "aac", "-b:a", "192k",
+                "-crf", "18",                   # HIGH BITRATE (Visual Lossless)
+                "-preset", "slow",              # BETTER COMPRESSION/QUALITY
+                "-c:a", "aac", "-b:a", "320k",  # High Quality Audio
                 "-shortest", 
                 clip_name
             ]
             
-            # Run
             result = subprocess.run(cmd, capture_output=True, text=True)
             if result.returncode != 0:
                 print(f"FFmpeg Error: {result.stderr}")
@@ -169,7 +161,7 @@ def process_batch(image_files, audio_files, progress=gr.Progress()):
         for clip in clip_paths:
             f.write(f"file '{clip}'\n")
 
-    final_output = "final_smooth_60fps.mp4"
+    final_output = "final_high_bitrate_30fps.mp4"
     subprocess.run([
         "ffmpeg", "-y", "-f", "concat", "-safe", "0", 
         "-i", list_file, "-c", "copy", final_output
@@ -182,15 +174,15 @@ css = """
 .gradio-container {background-color: #222; color: #eee}
 """
 
-with gr.Blocks(title="Smooth Video Maker 60FPS", css=css) as app:
-    gr.Markdown("## 🎬 Super Smooth Video Generator (60 FPS)")
-    gr.Markdown("Generates High-Res 60FPS video to eliminate stutter.")
+with gr.Blocks(title="High Bitrate 30FPS Maker", css=css) as app:
+    gr.Markdown("## 🎬 High Quality Video Generator (30 FPS)")
+    gr.Markdown("Optimized for **High Bitrate** and Smooth Motion at 30fps.")
     
     with gr.Row():
         img_in = gr.File(label="Images", file_count="multiple", file_types=["image"])
         aud_in = gr.File(label="Audio", file_count="multiple", file_types=["audio"])
     
-    btn = gr.Button("Generate Smooth Video", variant="primary")
+    btn = gr.Button("Generate HQ Video", variant="primary")
     out = gr.Video()
     
     btn.click(process_batch, [img_in, aud_in], out)