up

README.md

@@ -1,12 +1,14 @@
 ---
-title: New Wip Space
-emoji: 🔥
-colorFrom: yellow
-colorTo: red
+title: ReCamMaster
+emoji: 🎥
+colorFrom: pink
+colorTo: gray
 sdk: gradio
 sdk_version: 5.37.0
 app_file: app.py
-pinned: false
+pinned: true
+header: mini
+short_description: Reshoot existing videos using AI
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -6,6 +6,8 @@ import shutil
 import imageio
 import logging
 from pathlib import Path
+import numpy as np
+import random
 
 # Import from our modules
 from model_loader import ModelLoader, MODELS_ROOT_DIR
@@ -19,6 +21,16 @@ logger = logging.getLogger(__name__)
 model_loader = ModelLoader()
 video_processor = None
 
+# Constants
+MAX_SEED = np.iinfo(np.int32).max
+
+# Check if running in demo mode
+IS_DEMO = os.environ.get("IS_DEMO", "").lower() in ["true", "1", "yes", "on"]
+
+# Set limits based on demo mode
+MAX_INFERENCE_STEPS = 25 if IS_DEMO else 50
+MAX_FRAMES = 49 if IS_DEMO else 81
+
 def init_video_processor():
     """Initialize video processor"""
     global video_processor
@@ -59,18 +71,22 @@ def generate_recammaster_video(
     camera_type,
     num_frames,
     resolution,
+    seed,
+    randomize_seed,
+    num_inference_steps,
+    cfg_scale,
     progress=gr.Progress()
 ):
     """Main function to generate video with ReCamMaster"""
     
     if not model_loader.is_loaded:
-        return None, "Error: Models not loaded! Please load models first."
+        return None, "Error: Models not loaded! Please load models first.", seed
     
     if not init_video_processor():
-        return None, "Error: Failed to initialize video processor."
+        return None, "Error: Failed to initialize video processor.", seed
     
     if video_file is None:
-        return None, "Please upload a video file."
+        return None, "Please upload a video file.", seed
     
     try:
         # Create temporary directory for processing
@@ -84,6 +100,10 @@ def generate_recammaster_video(
             # Parse resolution
             width, height = map(int, resolution.split('x'))
             
+            # Handle seed
+            current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
+            logger.info(f"Using seed: {current_seed}")
+            
             # Extract frames
             progress(0.2, desc="Extracting video frames...")
             extracted_frames, fps = extract_frames_from_video(
@@ -101,7 +121,10 @@ def generate_recammaster_video(
                 camera_type,
                 num_frames=num_frames,
                 height=height,
-                width=width
+                width=width,
+                seed=current_seed,
+                num_inference_steps=num_inference_steps,
+                cfg_scale=cfg_scale
             )
             
             # Save output video
@@ -117,23 +140,27 @@ def generate_recammaster_video(
             progress(1.0, desc="Done!")
             
             transformation_name = CAMERA_TRANSFORMATIONS.get(str(camera_type), "Unknown")
-            status_msg = f"Successfully generated video with '{transformation_name}' camera movement!"
+            status_msg = f"Successfully generated video with '{transformation_name}' camera movement! (Seed: {current_seed})"
             
-            return final_output_path, status_msg
+            return final_output_path, status_msg, current_seed
     
     except Exception as e:
         logger.error(f"Error generating video: {str(e)}")
-        return None, f"Error: {str(e)}"
+        return None, f"Error: {str(e)}", seed
 
 # Create Gradio interface
 with gr.Blocks(title="ReCamMaster") as demo:
 
+    demo_notice = "⚠️ **Demo Mode**: Limited to 49 frames and 25 inference steps for faster processing." if IS_DEMO else ""
+    
     gr.Markdown(f"""
     # ReCamMaster 🎥
 
     This is a demo of [ReCamMaster](https://jianhongbai.github.io/ReCamMaster/), an amazing model that allows you to reshoot any video!
     
     Due to the long generation times (~ 10 min) this space [should be duplicated](https://huggingface.co/spaces/jbilcke-hf/ReCamMaster?duplicate=true) to your own account for the best experience (please select at least a Nvidia L40S).
+    
+    {demo_notice}
     """)
     
     with gr.Row():
@@ -162,17 +189,55 @@ with gr.Blocks(title="ReCamMaster") as demo:
                 gr.Markdown("### Step 3: Video Settings")
                 num_frames = gr.Slider(
                     minimum=17,
-                    maximum=81,
-                    value=81,
+                    maximum=MAX_FRAMES,
+                    value=MAX_FRAMES,
                     step=16,
                     label="Number of Frames",
-                    info="Must be 16n+1 (17, 33, 49, 65, 81)"
+                    info=f"Must be 16n+1 (17, 33, 49{', 65, 81' if not IS_DEMO else ''})"
                 )
                 resolution = gr.Dropdown(
                     choices=["832x480", "480x480", "480x832", "576x320", "320x576"],
                     value="832x480",
                     label="Resolution",
-                    info="Output video resolution"
+                    info="Output video resolution",
+
+                    # let's disable the resolution picker,
+                    # right now the rest of the code doesn't support changing it, so..
+                    visible=False
+                )
+            
+            # Advanced settings
+            with gr.Group():
+                gr.Markdown("### Step 4: Advanced Settings")
+                with gr.Row():
+                    seed = gr.Slider(
+                        label="Seed",
+                        minimum=0,
+                        maximum=MAX_SEED,
+                        step=1,
+                        value=0,
+                        interactive=True
+                    )
+                    randomize_seed = gr.Checkbox(
+                        label="Randomize seed",
+                        value=True,
+                        interactive=True
+                    )
+                num_inference_steps = gr.Slider(
+                    minimum=10,
+                    maximum=MAX_INFERENCE_STEPS,
+                    value=min(30, MAX_INFERENCE_STEPS),
+                    step=1,
+                    label="Inference Steps",
+                    info=f"More steps = higher quality but slower{' (Demo mode: limited to 25)' if IS_DEMO else ''}"
+                )
+                cfg_scale = gr.Slider(
+                    minimum=0.0,
+                    maximum=8.0,
+                    value=5.0,
+                    step=0.5,
+                    label="CFG Scale",
+                    info="Controls adherence to prompt"
                 )
             
             # Generate button
@@ -186,8 +251,8 @@ with gr.Blocks(title="ReCamMaster") as demo:
     # Event handlers
     generate_btn.click(
         fn=generate_recammaster_video,
-        inputs=[video_input, text_prompt, camera_type, num_frames, resolution],
-        outputs=[output_video, status_output]
+        inputs=[video_input, text_prompt, camera_type, num_frames, resolution, seed, randomize_seed, num_inference_steps, cfg_scale],
+        outputs=[output_video, status_output, seed]
     )
 
 if __name__ == "__main__":

video_processor.py

@@ -94,7 +94,7 @@ class VideoProcessor:
         
         return camera_tensor
     
-    def process_video(self, video_path, text_prompt, cam_type, num_frames=81, height=480, width=832):
+    def process_video(self, video_path, text_prompt, cam_type, num_frames=81, height=480, width=832, seed=0, num_inference_steps=50, cfg_scale=5.0):
         """Process video through ReCamMaster model"""
         
         # Load video frames
@@ -112,9 +112,9 @@ class VideoProcessor:
             height=height,
             width=width,
             num_frames=num_frames,
-            cfg_scale=5.0,
-            num_inference_steps=50,
-            seed=0,
+            cfg_scale=cfg_scale,
+            num_inference_steps=num_inference_steps,
+            seed=seed,
             tiled=True
         )