adding checkbox for diffusion

app.py

@@ -1,3 +1,5 @@
+
+
 import gradio as gr
 import torch
 import torchaudio
@@ -9,7 +11,7 @@ import os
 from PIL import Image
 
 def estimate_chunk_durations(text, words_per_second=2.5, min_sec=5, max_sec=10):
-    print("Estimating chunk durations...")  # Printing part of the text
+    print("Estimating chunk durations...")
     words = text.split()
     chunks = []
     current_chunk = []
@@ -37,33 +39,35 @@ def generate_speech(text):
     print("Speech generated")
     return wav_path
 
-def generate_images(chunks, image_size=(640, 480)):
+def generate_images(chunks, image_size=(640, 480), use_diffusion=True, num_steps=5):
     print("Generating images...")
-    pipe = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4")
-    pipe.to("cuda" if torch.cuda.is_available() else "cpu")
     image_paths = []
     
-    # Set number of inference steps to 10 for faster image generation
-    num_inference_steps = 5
-
+    if use_diffusion:
+        pipe = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4")
+        pipe.to("cuda" if torch.cuda.is_available() else "cpu")
+    
     for i, chunk in enumerate(chunks):
-        print(f"Generating image for chunk {i + 1} of {len(chunks)}: {chunk[:50]}...")  # Printing part of the chunk
-        image = pipe(chunk, num_inference_steps=num_inference_steps).images[0]
-        image = image.resize(image_size)
+        print(f"Generating image for chunk {i + 1} of {len(chunks)}: {chunk[:50]}...")
+        if use_diffusion:
+            image = pipe(chunk, num_inference_steps=num_steps).images[0]
+            image = image.resize(image_size)
+        else:
+            image = Image.new("RGB", image_size, (0, 0, 0))
+        
         img_path = f"image_{i}.png"
         image.save(img_path)
         image_paths.append(img_path)
-
+    
     return image_paths
 
-
 def create_video(images, durations, speech_path, image_size=(640, 480)):
     clips = []
     for img, dur in zip(images, durations):
-        pil_image = Image.open(img)  # Open the image with PIL
-        pil_image = pil_image.resize(image_size, Image.Resampling.LANCZOS)  # Resize with the new resampling filter
-        img_resized_path = f"resized_{os.path.basename(img)}"  # Temporary file to store resized image
-        pil_image.save(img_resized_path)  # Save resized image to file
+        pil_image = Image.open(img)
+        pil_image = pil_image.resize(image_size, Image.Resampling.LANCZOS)
+        img_resized_path = f"resized_{os.path.basename(img)}"
+        pil_image.save(img_resized_path)
         
         clip = mp.ImageClip(img_resized_path).set_duration(dur)
         clips.append(clip)
@@ -76,28 +80,30 @@ def create_video(images, durations, speech_path, image_size=(640, 480)):
     final_video.write_videofile("output.mp4", fps=24)
     return "output.mp4"
 
-def process_text(text, image_size):
+def process_text(text, image_size, use_diffusion, num_steps):
     chunks = estimate_chunk_durations(text)
     speech_path = generate_speech(text)
-    image_paths = generate_images(chunks, image_size)
+    image_paths = generate_images(chunks, image_size, use_diffusion, num_steps)
     durations = [min(10, max(5, len(chunk.split()) / 2.5)) for chunk in chunks]
     video_path = create_video(image_paths, durations, speech_path, image_size)
     return video_path
 
 with gr.Blocks() as demo:
     gr.Markdown("# Text-to-Video Generator using AI 🎥")
-    text_input = gr.Textbox(label="Enter your text")
+    text_input = gr.Textbox(label="Enter your text", placeholder="Ancient Egypt, one of the most fascinating and enduring civilizations in history, flourished along the Nile River for over 3,000 years. Its civilization developed around 3100 BCE and lasted until Alexander the Great conquered Egypt in 332 BCE. Egypt is famous for its monumental achievements in architecture, art, and culture, many of which have had a lasting influence on the world.")
     file_input = gr.File(label="Or upload a .txt file")
     image_size_input = gr.Radio(choices=["640x480", "800x600", "1024x768"], label="Select Image Size", value="640x480")
+    use_diffusion_input = gr.Checkbox(label="Use Diffusion Images", value=True)
+    num_steps_input = gr.Slider(minimum=1, maximum=50, step=1, value=5, label="Diffusion Model Steps")
     process_btn = gr.Button("Generate Video")
     output_video = gr.Video()
     
-    def handle_request(text, file, image_size):
+    def handle_request(text, file, image_size, use_diffusion, num_steps):
         if file is not None:
             text = open(file.name, "r").read()
         image_size_dict = {"640x480": (640, 480), "800x600": (800, 600), "1024x768": (1024, 768)}
-        return process_text(text, image_size_dict[image_size])
+        return process_text(text, image_size_dict[image_size], use_diffusion, num_steps)
     
-    process_btn.click(handle_request, inputs=[text_input, file_input, image_size_input], outputs=output_video)
+    process_btn.click(handle_request, inputs=[text_input, file_input, image_size_input, use_diffusion_input, num_steps_input], outputs=output_video)
 
 demo.launch()