Update app.py

app.py

@@ -14,11 +14,20 @@ import requests
 from datetime import datetime
 import tempfile
 import time
-from moviepy.editor import VideoFileClip, TextClip, CompositeVideoClip
-import numpy as np
+
+# Try to import video processing libraries
+try:
+    import cv2
+    import numpy as np
+    VIDEO_PROCESSING_AVAILABLE = True
+except ImportError:
+    VIDEO_PROCESSING_AVAILABLE = False
+    print("Warning: cv2 not available. Watermark feature will be disabled.")
 
 # API token setup
 api_token = os.getenv("RAPI_TOKEN")
+if api_token:
+    os.environ["REPLICATE_API_TOKEN"] = api_token
 
 # Aspect ratio options
 ASPECT_RATIOS = {
@@ -35,63 +44,89 @@ ASPECT_RATIOS = {
 DEFAULT_TEXT_PROMPT = ""
 DEFAULT_IMAGE_PROMPT = "Generate a video with smooth and natural movement. Objects should have visible motion while maintaining fluid transitions."
 
-def add_watermark(input_video_path, output_video_path):
-    """Add watermark to video using moviepy"""
+def add_watermark_cv2(input_video_path, output_video_path):
+    """Add watermark to video using OpenCV"""
+    if not VIDEO_PROCESSING_AVAILABLE:
+        return False
+    
     try:
-        # Load the video
-        video = VideoFileClip(input_video_path)
+        # Open the video
+        cap = cv2.VideoCapture(input_video_path)
         
-        # Get video dimensions
-        width, height = video.size
+        # Get video properties
+        fps = int(cap.get(cv2.CAP_PROP_FPS))
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         
-        # Calculate watermark size and position
-        watermark_text = "ginigen.com"
-        font_size = max(12, int(height * 0.025))  # 2.5% of video height, minimum 12px
-        
-        # Create text clip for watermark
-        watermark = TextClip(
-            watermark_text,
-            fontsize=font_size,
-            color='white',
-            font='Arial',
-            stroke_color='black',
-            stroke_width=1,
-            method='caption',
-            size=(None, None)
-        )
+        # Define codec and create VideoWriter
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_video_path, fourcc, fps, (width, height))
         
-        # Position watermark at bottom right with padding
-        padding = int(width * 0.02)  # 2% padding
-        watermark = watermark.set_position((width - watermark.w - padding, height - watermark.h - padding))
-        watermark = watermark.set_duration(video.duration)
-        
-        # Set opacity (semi-transparent)
-        watermark = watermark.set_opacity(0.7)
-        
-        # Composite the watermark onto the video
-        final_video = CompositeVideoClip([video, watermark])
-        
-        # Write the output video
-        final_video.write_videofile(
-            output_video_path,
-            codec='libx264',
-            audio_codec='aac',
-            temp_audiofile=tempfile.mktemp('.m4a'),
-            remove_temp=True,
-            logger=None  # Suppress moviepy output
-        )
+        # Watermark settings
+        watermark_text = "ginigen.com"
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = max(0.4, height * 0.001)  # Scale based on video height
+        font_thickness = max(1, int(height * 0.002))
+        
+        # Get text size
+        (text_width, text_height), baseline = cv2.getTextSize(watermark_text, font, font_scale, font_thickness)
+        
+        # Position (bottom right with padding)
+        padding = int(width * 0.02)
+        x = width - text_width - padding
+        y = height - padding
+        
+        # Process each frame
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            # Add semi-transparent background for text
+            overlay = frame.copy()
+            cv2.rectangle(overlay, 
+                         (x - 5, y - text_height - 5), 
+                         (x + text_width + 5, y + 5), 
+                         (0, 0, 0), 
+                         -1)
+            frame = cv2.addWeighted(frame, 0.7, overlay, 0.3, 0)
+            
+            # Add text
+            cv2.putText(frame, watermark_text, (x, y), font, font_scale, (255, 255, 255), font_thickness, cv2.LINE_AA)
+            
+            # Write frame
+            out.write(frame)
         
-        # Clean up
-        video.close()
-        final_video.close()
+        # Release everything
+        cap.release()
+        out.release()
+        cv2.destroyAllWindows()
         
         return True
+        
     except Exception as e:
         print(f"Watermark error: {str(e)}")
-        # If watermarking fails, just copy the original
+        return False
+
+def add_watermark_simple(input_video_path, output_video_path):
+    """Simple fallback - just copy the video without watermark"""
+    try:
         import shutil
         shutil.copy2(input_video_path, output_video_path)
         return False
+    except Exception as e:
+        print(f"Copy error: {str(e)}")
+        return False
+
+def add_watermark(input_video_path, output_video_path):
+    """Add watermark to video - tries cv2 first, then fallback"""
+    if VIDEO_PROCESSING_AVAILABLE:
+        success = add_watermark_cv2(input_video_path, output_video_path)
+        if success:
+            return True
+    
+    # Fallback - just copy without watermark
+    return add_watermark_simple(input_video_path, output_video_path)
 
 def update_prompt_placeholder(mode):
     """Update prompt placeholder based on mode"""
@@ -263,33 +298,35 @@ def generate_video(mode, prompt, image, aspect_ratio, seed, api_key_input, progr
             tmp_file.write(video_data)
             temp_video_path = tmp_file.name
         
-        progress(0.8, desc="Adding watermark...")
+        # Try to add watermark
+        watermark_added = False
+        final_video_path = temp_video_path
         
-        # Create final output path
-        final_video_path = tempfile.mktemp(suffix='.mp4')
-        
-        # Add watermark
-        watermark_added = add_watermark(temp_video_path, final_video_path)
+        if VIDEO_PROCESSING_AVAILABLE:
+            progress(0.8, desc="Adding watermark...")
+            final_video_path = tempfile.mktemp(suffix='.mp4')
+            watermark_added = add_watermark(temp_video_path, final_video_path)
+            
+            if not watermark_added or not os.path.exists(final_video_path):
+                final_video_path = temp_video_path
         
-        # Also save as output.mp4
-        if os.path.exists(final_video_path):
-            with open(final_video_path, "rb") as f:
-                watermarked_data = f.read()
-            with open("output.mp4", "wb") as file:
-                file.write(watermarked_data)
-        else:
-            # Fallback if watermarking failed
-            with open("output.mp4", "wb") as file:
-                file.write(video_data)
-            final_video_path = temp_video_path
+        # Save final video
+        with open(final_video_path, "rb") as f:
+            final_video_data = f.read()
+        with open("output.mp4", "wb") as file:
+            file.write(final_video_data)
         
-        # Clean up temp file if different
+        # Clean up temp files
         if temp_video_path != final_video_path and os.path.exists(temp_video_path):
-            os.unlink(temp_video_path)
+            try:
+                os.unlink(temp_video_path)
+            except:
+                pass
         
         progress(1.0, desc="Complete!")
         
         # Generation info
+        watermark_status = "Added" if watermark_added else "Not available (cv2 not installed)" if not VIDEO_PROCESSING_AVAILABLE else "Failed"
         info = f"""✅ Video generated successfully!
 
 📊 Generation Info:
@@ -298,7 +335,7 @@ def generate_video(mode, prompt, image, aspect_ratio, seed, api_key_input, progr
 - Seed: {seed}
 - Duration: 5 seconds
 - Resolution: 480p
-- Watermark: {"Added" if watermark_added else "Failed (original saved)"}
+- Watermark: {watermark_status}
 - File: output.mp4"""
         
         return final_video_path, info
@@ -376,11 +413,12 @@ with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as
             )
             
             # Fixed settings display
-            gr.Markdown("""
+            watermark_info = "ginigen.com" if VIDEO_PROCESSING_AVAILABLE else "ginigen.com (requires cv2)"
+            gr.Markdown(f"""
             ### 📋 Fixed Settings
             - **Duration**: 5 seconds
             - **Resolution**: 480p
-            - **Watermark**: ginigen.com
+            - **Watermark**: {watermark_info}
             """)
         
         with gr.Column(scale=2):
@@ -414,15 +452,20 @@ with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as
         
         1. **Install required packages**:
         ```bash
-        pip install gradio replicate pillow requests moviepy
+        pip install gradio replicate pillow requests
+        ```
+        
+        2. **For watermark support (optional)**:
+        ```bash
+        pip install opencv-python
         ```
         
-        2. **Set environment variable** (optional):
+        3. **Set environment variable** (optional):
         ```bash
         export RAPI_TOKEN="your-replicate-api-token"
         ```
         
-        3. **Run**:
+        4. **Run**:
         ```bash
         python app.py
         ```
@@ -433,7 +476,7 @@ with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as
         - **Image to Video**: Transform uploaded image into animated video
         - **Aspect Ratios**: Choose ratios optimized for various social media platforms
         - **Seed Value**: Use same seed to reproduce identical results
-        - **Watermark**: Automatically adds "ginigen.com" watermark to generated videos
+        - **Watermark**: Automatically adds "ginigen.com" watermark (requires opencv-python)
         
         ### Prompt Writing Tips
         
@@ -447,7 +490,7 @@ with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as
         - **Timeout errors**: The model might be cold starting. Wait 1-2 minutes and try again.
         - **Model booting**: First requests after inactivity may take longer as the model boots up.
         - **Extended wait times**: Complex prompts or server load may cause longer generation times.
-        - **Watermark issues**: If watermark fails, the original video will be saved without watermark.
+        - **Watermark not showing**: Install opencv-python for watermark support.
         """)
     
     # Examples