updated files

Demo/02_Tech_Deck.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b45c266eb01b16301621ee2e31ea8282cd1d72fff4bf959522b0b302f5b7d0e
+size 10621

Demo/04_Team_Profile.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e71ceecc9d5d85324fd31ed8b268e222977f8dfc1455cb44e260b2aa74ad5de0
+size 73529

Demo/05-Roadmap.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea63aed5200371c1b3bc42cf06f9e4f1d3cded3afe53f27f5789de4cbccc352d
+size 83787

Demo/06-End Slide.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eaab3d85667480068276f4c7c45db0ce1a31c7b26227ac904eb5b8ad4e6cf0ca
+size 3922333

Demo/old-02_Tech_Deck.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8887e7d3825f880a83d1d4c94d1d9dbc3dbe3db290b6d4ee03c14a918b07bd45
+size 1730

app/api/v1/audio.py

@@ -1,11 +1,9 @@
-from fastapi import APIRouter, HTTPException, Depends, Body
+from fastapi import APIRouter, HTTPException, Body
+from fastapi.responses import Response  # ✅ add this
 from pydantic import BaseModel
-from app.services.audio_service import generate_audio_file
-from app.auth.auth import verify_token
-import uuid  # ✅ Add this
-import os    # ✅ Also needed
-from gtts import gTTS  # ✅ Needed if you're calling it directly here
-
+from gtts import gTTS
+import uuid
+import os
 router = APIRouter()
 
 class AudioRequest(BaseModel):
@@ -16,14 +14,21 @@ class AudioRequest(BaseModel):
 @router.post("/generate")
 def generate_audio_endpoint(payload: AudioRequest):
     try:
+        # ✅ Save inside generated/audio for consistency
         filename = f"audio_{uuid.uuid4().hex}.mp3"
-        file_path = f"generated_audio/{filename}"
+        folder = "generated/audio"
         os.makedirs("generated_audio", exist_ok=True)
+        file_path = f"generated_audio/{filename}" # ✅ match your video & image folders        
+        
+        # ✅ Generate TTS audio
         tts = gTTS(text=payload.text, lang=payload.language)
         tts.save(file_path)
-        return {
-            "file_path": file_path,
-            "download_url": f"/api/v1/download?file_path={file_path}"
-        }
+        
+        # ✅ Return audio bytes for inline Streamlit playback
+        with open(file_path, "rb") as f:
+            audio_bytes = f.read()
+
+        return Response(content=audio_bytes, media_type="audio/mpeg")
+        
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))

app/api/v1/image.py

@@ -1,54 +1,41 @@
 from fastapi import APIRouter, HTTPException, Depends, Body
+from fastapi.responses import Response
 from pydantic import BaseModel
 from app.auth.auth import verify_token
-from PIL import Image, ImageDraw, ImageFont
-from datetime import datetime
+import requests
 import os
+from pydantic import BaseModel
+from dotenv import load_dotenv
+load_dotenv()
+
 
+# ✅ Define router
 router = APIRouter()
 
+# ✅ Define Request schema
 class ImageRequest(BaseModel):
     prompt: str
     style: str = "default"
 
-class ImageResponse(BaseModel):
-    message: str
-    filename: str
-    download_url: str
+UNSPLASH_ACCESS_KEY = os.getenv("UNSPLASH_ACCESS_KEY")  # store this in .env
+print(f"unsplash key is: {UNSPLASH_ACCESS_KEY}")
 
-@router.post("/generate", response_model=ImageResponse)
+# ✅ Endpoint
+@router.post("/generate")
 def generate_image_file_endpoint(
     data: ImageRequest = Body(...),
     token: str = Depends(verify_token)
 ):
-    prompt = data.prompt
-    style = data.style
-    filename = f"image_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
-    folder = "generated/image"
-    os.makedirs(folder, exist_ok=True)
-    output_path = os.path.join(folder, filename)
+    query = f"{data.prompt} {data.style}"
+    url = f"https://api.unsplash.com/photos/random?query={query}&client_id={UNSPLASH_ACCESS_KEY}&orientation=landscape"
 
     try:
-        img = Image.new("RGB", (768, 512), color="white")
-        draw = ImageDraw.Draw(img)
-
-        try:
-            font = ImageFont.truetype("arial.ttf", 20)
-        except:
-            font = ImageFont.load_default()
-
-        draw.text((20, 20), f"Prompt: {prompt}", fill="black", font=font)
-        draw.text((20, 60), f"Style: {style}", fill="gray", font=font)
-
-        img.save(output_path, format="PNG")
-
-        print(f"✅ Image created: {output_path}, size = {os.path.getsize(output_path)} bytes")
-        return {
-            "message": "Image generated successfully",
-            "filename": filename,
-            "download_url": f"/api/v1/download?file_path=generated/image/{filename}"
-        }
+        r = requests.get(url)
+        r.raise_for_status()
+        image_url = r.json()["urls"]["regular"]
+        img_data = requests.get(image_url).content
+        return Response(content=img_data, media_type="image/jpeg")
 
     except Exception as e:
-        print(f"❌ Image generation failed: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
+        print(f"❌ Image fetch failed: {str(e)}")
+        raise HTTPException(status_code=500, detail="Image generation failed.")

app/api/v1/video.py

@@ -1,13 +1,13 @@
 # app/api/v1/video.py
 from fastapi import APIRouter, HTTPException, Depends, Body
+from fastapi.responses import FileResponse
 from pydantic import BaseModel
 from app.services.video_service import generate_video_file
 from app.auth.auth import verify_token
-import uuid  # ✅ Add this
-import os    # ✅ Also needed
-from gtts import gTTS  # ✅ Needed if you're calling it directly here
+import os
 from typing import Optional
 
+# ✅ Define router FIRST
 router = APIRouter()
 
 class VideoInput(BaseModel):
@@ -15,23 +15,31 @@ class VideoInput(BaseModel):
     tone: str
     domain: str
     environment: str
-    transcript: Optional[str] = None  # ✅ make optional
+    transcript: Optional[str] = None
 
 @router.post("/generate")
 def generate_video_endpoint(
     payload: VideoInput = Body(...), 
-    token: str = Depends(verify_token)):
+    token: str = Depends(verify_token)
+):
     try:
-        # Use `payload.prompt` as the script
+        # Generate video file
         filename = generate_video_file(
-            script=payload.prompt,  # 👈 mapping prompt to script
-            duration=10  # Or dynamically set based on text length
+            script=payload.prompt,
+            duration=10  # Optional: could be dynamic
         )
-        return {
-            "message": "Video generated successfully",
-            "filename": filename,
-            "download_url": f"/api/v1/download?file_path=generated/video/{filename}"
-        }
+        video_path = os.path.join("generated/video", filename)
+
+        if not os.path.exists(video_path):
+            raise HTTPException(status_code=500, detail="Video not found")
+
+        # ✅ Return the actual file for Streamlit to play
+        return FileResponse(
+            video_path,
+            media_type="video/mp4",
+            filename=filename
+        )
+
     except Exception as e:
         print("❌ Video generation error:", str(e))
         raise HTTPException(status_code=500, detail=str(e))

app/services/video_service.py

@@ -1,67 +1,94 @@
 # app/services/video_service.py
 
-import cv2
-import numpy as np
 import os
 import uuid
-import math
+import requests
 from gtts import gTTS
 from mutagen.mp3 import MP3
-import subprocess
+from moviepy.editor import ImageClip, concatenate_videoclips, AudioFileClip
+from dotenv import load_dotenv
+
+load_dotenv()
+
+UNSPLASH_KEY = os.getenv("UNSPLASH_ACCESS_KEY")
+UNSPLASH_API = "https://api.unsplash.com/photos/random"
+
+def fetch_unsplash_images(query, count=3):
+    headers = {"Accept-Version": "v1", "Authorization": f"Client-ID {UNSPLASH_KEY}"}
+    urls = []
+
+    for _ in range(count):
+        r = requests.get(UNSPLASH_API, params={"query": query}, headers=headers)
+        if r.status_code == 200:
+            data = r.json()
+            if isinstance(data, dict):
+                urls.append(data["urls"]["regular"])
+            elif isinstance(data, list) and len(data) > 0:
+                urls.append(data[0]["urls"]["regular"])
+    return urls
 
 def generate_video_file(script: str, duration: int = None) -> str:
-    # Paths
-    audio_filename = f"generated/audio/audio_{uuid.uuid4().hex}.mp3"
-    raw_video_path = f"generated/video/video_{uuid.uuid4().hex}.mp4"
-    final_video_path = raw_video_path.replace(".mp4", "_final.mp4")
+    os.makedirs("generated/video", exist_ok=True)
+    os.makedirs("generated/audio", exist_ok=True)
+    os.makedirs("generated/tmp", exist_ok=True)
 
-    # Ensure directories exist
-    os.makedirs(os.path.dirname(audio_filename), exist_ok=True)
-    os.makedirs(os.path.dirname(raw_video_path), exist_ok=True)
+    video_filename = f"video_{uuid.uuid4().hex}.mp4"
+    video_path = os.path.join("generated/video", video_filename)
+    audio_path = f"generated/audio/audio_{uuid.uuid4().hex}.mp3"
 
-    # Generate audio
+    # Step 1: Generate audio
     tts = gTTS(text=script, lang='en')
-    tts.save(audio_filename)
-
-    # Get accurate audio duration
-    audio = MP3(audio_filename)
-    audio_duration = audio.info.length  # e.g., 5.98 seconds
-
-    # Video specs
-    fps = 25  # Higher FPS = smoother video
-    total_frames = int(audio_duration * fps)
-    width, height = 640, 480
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out = cv2.VideoWriter(raw_video_path, fourcc, fps, (width, height))
-
-    # Create each frame
-    for _ in range(total_frames):
-        frame = np.ones((height, width, 3), dtype=np.uint8) * 255
-        cv2.putText(frame, script, (30, height // 2), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 0), 2)
-        out.write(frame)
-
-    out.release()
-
-    # Merge audio and video
-    ffmpeg_cmd = [
-        "ffmpeg",
-        "-y",
-        "-i", raw_video_path,
-        "-i", audio_filename,
-        "-c:v", "libx264",
-        "-c:a", "aac",
-        "-crf", "23",
-        "-c:a", "aac",
-        "-b:a", "128k",
-        "-shortest",        
-        "-movflags", "+faststart",  # 👈 crucial for browser playback
-        final_video_path
-    ]
-
-    try:
-        subprocess.run(ffmpeg_cmd, check=True)
-    except subprocess.CalledProcessError as e:
-        print(f"FFmpeg failed: {e}")
-        return None
-
-    return os.path.basename(final_video_path)
+    tts.save(audio_path)
+
+    # Get audio duration (fallback if 0)
+    audio = MP3(audio_path)
+    audio_duration = max(audio.info.length, 3.0)  # ensure at least 3s
+
+    # Step 2: Fetch Unsplash images
+    images = fetch_unsplash_images(script, count=3)
+    if not images:
+        raise Exception("No images found from Unsplash for the prompt")
+
+    # Step 3: Create slideshow clips
+    clips = []
+    per_image_duration = audio_duration / len(images)
+    tmp_files = []
+
+    for url in images:
+        img_data = requests.get(url).content
+        tmp_file = f"generated/tmp/tmp_{uuid.uuid4().hex}.jpg"
+        tmp_files.append(tmp_file)
+
+        with open(tmp_file, "wb") as f:
+            f.write(img_data)
+
+        clip = ImageClip(tmp_file).resize(height=720).set_duration(per_image_duration)
+        clips.append(clip)
+
+    # Step 4: Concatenate without negative padding
+    final_clip = concatenate_videoclips(clips, method="compose")
+
+    # Step 5: Force duration to match audio
+    final_clip = final_clip.set_duration(audio_duration)
+
+    # Step 6: Add audio
+    final_clip = final_clip.set_audio(AudioFileClip(audio_path))
+
+    # Step 7: Export video
+    final_clip.write_videofile(
+        video_path,
+        fps=24,
+        codec="libx264",
+        audio_codec="aac",
+        threads=4,
+        preset="ultrafast"
+    )
+
+    # Cleanup
+    for file in tmp_files:
+        try:
+            os.remove(file)
+        except:
+            pass
+
+    return video_filename

generated_audio/audio_46204c7f1cdd4d21b632318c1533798f.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a752e374c3cd105ec751eb30df12b3a0939e0500e7e2487b41e4269050e44906
+size 57216

generated_audio/audio_4e8cfaddd1e143a4a7a11a8baeafa178.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f2d93711bae321f7bfe7f698a0a5be8b0b6462c862cf196a95a621931089ba6
+size 20160

generated_audio/audio_5d3d0ac54e0e4b7ab91a88a5e6cb5a7a.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6924a2184a3a139ef4d6d9bc5e1e08d3b1b69d7e6904f8acb458d40cbc90fc73
+size 9024

generated_audio/audio_6b4a3eaef6c745d4932063aba95541e5.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:343053419eba6ee94bd9d7fd54631336e97b693dea9775f2d57c6f342953cefb
+size 9024

generated_audio/audio_772adc2bcf6a49e28757294a6157a71c.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7168fbdac599d9f1f20f13a88b11188cfca4bf03c6c5e83b10f0446f501a698
+size 35328

generated_audio/audio_8d99b8f248d549f3806c1fe705c8a24c.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bbd01d120150bc2de7f4f6882d9194d8cf67a267ae3505dda8ddcc9b109701c
+size 20160

generated_audio/audio_8e0e1a375aa8415eb3be3689fdfc015e.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c348b34bef828c56c5157933592943b8e23c02b00eb1f81cedde7e2b3a4dac7
+size 72384

generated_audio/audio_d9f41d5ef87c4d088bd7cd230a75cd62.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0ba21c2e66aa0ee7d2fb7f5f7e7cc18948526f35cdcc458dc043e2ab16afef8
+size 20160

generated_audio/audio_db2b96e4b94e4bcf8ab796d4fe483e41.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7168fbdac599d9f1f20f13a88b11188cfca4bf03c6c5e83b10f0446f501a698
+size 35328

streamlit_ui - Copy.py

@@ -0,0 +1,213 @@
+# streamlit_ui.py
+
+import streamlit as st
+import requests
+import base64
+from PIL import Image
+import io
+import os
+import tempfile
+
+st.set_page_config(
+    page_title="Prompta - Text to Media Generator",
+    page_icon="🎙️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+st.title("🎙️🖼️🎞️ Prompta - Text to Media Generator")
+
+# 🛠️ Get Token FIRST
+TOKEN = st.sidebar.text_input("🔑 API Token", type="password")
+HEADERS = {"Authorization": f"Bearer {TOKEN}"} if TOKEN else {}
+
+# ✅ Display AFTER token is typed
+if TOKEN:
+    st.sidebar.write("Using token:", TOKEN)
+    st.sidebar.write("Sending headers:", HEADERS)
+else:
+    st.sidebar.warning("⚠️ Please enter a valid API token to use the app.")
+
+API_BASE = "http://localhost:8000"
+
+#API_BASE = "https://2255d6a4793d.ngrok-free.app"
+
+def render_media(file_bytes, media_type, caption):
+    b64 = base64.b64encode(file_bytes).decode()
+    if media_type == "audio":
+        st.audio(f"data:audio/wav;base64,{b64}", format="audio/wav")
+    elif media_type == "video":
+        st.video(f"data:video/mp4;base64,{b64}")
+    elif media_type == "image":
+        try:
+            # Validate if it's a valid image
+            img = Image.open(io.BytesIO(file_bytes))
+            st.image(img, caption=caption)
+        except Exception as e:
+            st.warning("⚠️ Cannot render image. It may be corrupt or empty.")
+            st.code(str(e))
+
+# Sidebar inputs
+st.sidebar.header("🛠️ Settings")
+#TOKEN = st.sidebar.text_input("🔑 API Token", type="password")
+#HEADERS = {"Authorization": f"Bearer {TOKEN}"} if TOKEN else {}
+
+voice = st.selectbox("Choose voice", ["en", "hi", "te", "ta"])
+voice_map = {
+    "en": "en-US",
+    "hi": "hi-IN",
+    "te": "te-IN",
+    "ta": "ta-IN"
+}
+
+tab = st.sidebar.radio("Select Task", ["Text to Audio", "Text to Image", "Text to Video"])
+
+if tab == "Text to Audio":
+    st.subheader("🎤 Text to Audio")
+    text = st.text_area("Enter text")
+    voice = st.selectbox("Choose language", ["English", "Hindi", "Telugu", "Tamil"])
+    voice_map = {
+        "English": ("en-US", "en"),
+        "Hindi": ("hi-IN", "hi"),
+        "Telugu": ("te-IN", "te"),
+        "Tamil": ("ta-IN", "ta")
+    }
+    voice_code, lang_code = voice_map[voice]
+
+    if st.button("🔊 Generate Audio"):
+        with st.spinner("Generating audio..."):
+            r = requests.post(
+                f"{API_BASE}/api/v1/audio/generate", 
+                json={
+                    "text": text,
+                    "voice": voice_code,
+                    "language": lang_code
+                },
+                headers=HEADERS
+            )
+            if r.status_code == 200:
+                try:
+                    data = r.json()
+                    st.code(data, language="json")  # Debug: show full JSON response in UI
+
+                    if "download_url" in data:
+                        download_url = f"{API_BASE}{data['download_url']}"
+                        audio_resp = requests.get(download_url, headers=HEADERS)
+                        if audio_resp.status_code == 200:
+                            render_media(audio_resp.content, "audio", "Generated Audio")
+                        else:
+                            st.error("❌ Failed to download audio file.")
+                    else:
+                        st.error("❌ `download_url` not found in API response.")
+                        st.code(data)
+                except Exception as e:
+                    st.error("❌ Failed to parse API response.")
+                    st.code(r.text)
+                    st.exception(e)
+            else:
+                st.error(f"❌ Failed: {r.json().get('detail')}")
+
+
+elif tab == "Text to Image":
+    st.subheader("🖼️ Text to Image")
+    prompt = st.text_area("Enter image prompt")
+    style = st.selectbox("Choose Style", ["sdxl", "deepfloyd", "kandinsky"])
+
+    if st.button("🧠 Generate Image"):
+        with st.spinner("Generating image..."):
+            r = requests.post(
+                f"{API_BASE}/api/v1/image/generate", 
+                json={"prompt": prompt, "style": style},  # ✅ correct key
+                headers=HEADERS
+            )
+            if r.status_code == 200:
+                try:
+                    res_json = r.json()
+                    download_url = res_json.get("download_url")
+                    if not download_url:
+                        st.error("No download URL returned.")
+                    else:
+                        download_full_url = f"{API_BASE}{download_url}"
+                        image_response = requests.get(download_full_url, headers={"accept": "image/png"}, allow_redirects=True)
+                        if image_response.status_code != 200:
+                            st.error("❌ Failed to download image.")
+                            st.code(image_response.text)
+                            st.write("Status:", image_response.status_code)
+                            st.write("Headers:", image_response.headers)
+                        st.write(image_response.status_code, image_response.headers)
+                        render_media(image_response.content, "image", "Generated Image")
+                except Exception as e:
+                    st.error(f"⚠️ Failed to fetch/display image: {str(e)}")
+                    st.code(r.text)
+            else:
+                try:
+                    detail = r.json().get("detail")
+                except Exception:
+                    detail = r.text  # fallback to raw response text (may be empty or HTML)
+
+                st.error(f"❌ Failed: {detail}")                
+
+elif tab == "Text to Video":
+    st.subheader("🎞️ Text to Video")
+    prompt = st.text_area("Enter video prompt")
+    tone = st.selectbox("Tone", ["formal", "casual", "emotional", "documentary"])
+    domain = st.selectbox("Domain", ["health", "education", "governance", "entertainment"])
+    environment = st.selectbox("Environment", ["urban", "rural", "nature", "futuristic"])
+
+    transcript = st.text_area("Transcript (optional - for subtitles)", height=100)
+    enhance = st.checkbox("✨ Add Subtitles and Background Music")
+
+    if st.button("🎬 Generate Video"):
+        with st.spinner("Generating video..."):
+            r = requests.post(
+                f"{API_BASE}/api/v1/video/generate",
+                json={"prompt": prompt, "tone": tone, "domain": domain, "environment": environment},
+                headers=HEADERS
+            )
+            if r.status_code == 200:
+                try:
+                    data = r.json()
+                    st.code(data, language="json")
+
+                    download_url = data.get("download_url")
+                    if not download_url:
+                        st.error("⚠️ No download URL received.")
+                    else:
+                        full_video_url = f"{API_BASE}{download_url}"
+                        video_response = requests.get(full_video_url, headers=HEADERS)
+                        if video_response.status_code == 200:
+                            video_bytes = video_response.content
+                            st.write("📦 Video size (bytes):", len(video_bytes))
+
+                            if enhance and transcript:
+                                with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_vid:
+                                    tmp_vid.write(video_bytes)
+                                    tmp_vid_path = tmp_vid.name
+
+                                srt_path = generate_srt_from_text(transcript, output_path="streamlit_subs.srt")
+                                enhanced_path = "streamlit_final_video.mp4"
+                                enhance_video_with_subtitles_and_bgm(
+                                    video_path=tmp_vid_path,
+                                    srt_path=srt_path,
+                                    bgm_path="default_bgm.mp3",
+                                    output_path=enhanced_path
+                                )
+
+                                with open(enhanced_path, "rb") as f:
+                                    render_media(f.read(), "video", "Enhanced Video")
+                            else:
+                                st.video(video_bytes)
+                        else:
+                            st.error("❌ Failed to download video.")
+                except Exception as e:
+                    st.error("❌ Error parsing response or rendering video.")
+                    st.code(r.text)
+                    st.exception(e)
+            else:
+                try:
+                    st.error(f"❌ Failed: {r.json().get('detail')}")
+                except:
+                    st.error(f"❌ Failed: {r.text}")
+
+
+st.sidebar.markdown("---")
+st.sidebar.info("Built with ❤️ for AI GovTech Challenge 2025")

streamlit_ui.py

@@ -1,12 +1,8 @@
 # streamlit_ui.py
-
 import streamlit as st
 import requests
 import base64
-from PIL import Image
 import io
-import os
-import tempfile
 
 st.set_page_config(
     page_title="Prompta - Text to Media Generator",
@@ -23,131 +19,95 @@ HEADERS = {"Authorization": f"Bearer {TOKEN}"} if TOKEN else {}
 # ✅ Display AFTER token is typed
 if TOKEN:
     st.sidebar.write("Using token:", TOKEN)
-    st.sidebar.write("Sending headers:", HEADERS)
 else:
     st.sidebar.warning("⚠️ Please enter a valid API token to use the app.")
 
 API_BASE = "http://localhost:8000"
 
-
-
-API_BASE = "http://localhost:8000"
-#API_BASE = "https://2255d6a4793d.ngrok-free.app"
-
-def render_media(file_bytes, media_type, caption):
-    b64 = base64.b64encode(file_bytes).decode()
-    if media_type == "audio":
-        st.audio(f"data:audio/wav;base64,{b64}", format="audio/wav")
-    elif media_type == "video":
-        st.video(f"data:video/mp4;base64,{b64}")
-    elif media_type == "image":
+# ==================================================
+# Unified media rendering
+# ==================================================
+def render_media(response, label):
+    content_type = response.headers.get("Content-Type", "")
+    file_bytes = response.content
+
+    if "audio" in content_type:
+        st.audio(file_bytes, format=content_type)
+    elif "video" in content_type:
+        st.video(file_bytes)
+    elif "image" in content_type:
+        st.image(file_bytes, caption=label, use_container_width=True)
+    else:
         try:
-            # Validate if it's a valid image
-            img = Image.open(io.BytesIO(file_bytes))
-            st.image(img, caption=caption)
-        except Exception as e:
-            st.warning("⚠️ Cannot render image. It may be corrupt or empty.")
-            st.code(str(e))
+            # JSON fallback (video download_url case)
+            data = response.json()
+            if "download_url" in data:
+                video_url = f"{API_BASE}{data['download_url']}"
+                st.info("📥 Downloading video from URL...")
+                video_resp = requests.get(video_url, headers=HEADERS)
+                if video_resp.status_code == 200:
+                    st.video(video_resp.content)
+                else:
+                    st.error(f"❌ Failed to download video from {video_url}")
+            else:
+                st.warning("⚠️ Unsupported media format or empty response.")
+        except Exception:
+            st.warning("⚠️ Unsupported media format or empty response.")
 
+# ==================================================
+# Sidebar Inputs
+# ==================================================
 st.sidebar.header("🛠️ Settings")
-#TOKEN = st.sidebar.text_input("🔑 API Token", type="password")
-#HEADERS = {"Authorization": f"Bearer {TOKEN}"} if TOKEN else {}
-
-voice = st.selectbox("Choose voice", ["en", "hi", "te", "ta"])
-voice_map = {
-    "en": "en-US",
-    "hi": "hi-IN",
-    "te": "te-IN",
-    "ta": "ta-IN"
-}
 
 tab = st.sidebar.radio("Select Task", ["Text to Audio", "Text to Image", "Text to Video"])
 
+# ==================================================
+# Text to Audio
+# ==================================================
 if tab == "Text to Audio":
     st.subheader("🎤 Text to Audio")
     text = st.text_area("Enter text")
-    voice = st.selectbox("Choose language", ["English", "Hindi", "Telugu", "Tamil"])
-    voice_map = {
-        "English": ("en-US", "en"),
-        "Hindi": ("hi-IN", "hi"),
-        "Telugu": ("te-IN", "te"),
-        "Tamil": ("ta-IN", "ta")
-    }
-    voice_code, lang_code = voice_map[voice]
+    voice = st.selectbox("Choose voice/language", ["en-US", "hi-IN", "te-IN", "ta-IN"])
 
     if st.button("🔊 Generate Audio"):
         with st.spinner("Generating audio..."):
             r = requests.post(
-                f"{API_BASE}/api/v1/audio/generate", 
-                json={
-                    "text": text,
-                    "voice": voice_code,
-                    "language": lang_code
-                },
+                f"{API_BASE}/api/v1/audio/generate",
+                json={"text": text, "voice": voice},
                 headers=HEADERS
             )
             if r.status_code == 200:
-                try:
-                    data = r.json()
-                    st.code(data, language="json")  # Debug: show full JSON response in UI
-
-                    if "download_url" in data:
-                        download_url = f"{API_BASE}{data['download_url']}"
-                        audio_resp = requests.get(download_url, headers=HEADERS)
-                        if audio_resp.status_code == 200:
-                            render_media(audio_resp.content, "audio", "Generated Audio")
-                        else:
-                            st.error("❌ Failed to download audio file.")
-                    else:
-                        st.error("❌ `download_url` not found in API response.")
-                        st.code(data)
-                except Exception as e:
-                    st.error("❌ Failed to parse API response.")
-                    st.code(r.text)
-                    st.exception(e)
+                render_media(r, "Generated Audio")
             else:
-                st.error(f"❌ Failed: {r.json().get('detail')}")
-
+                st.error(f"❌ Failed: {r.json().get('detail', r.text)}")
 
+# ==================================================
+# Text to Image
+# ==================================================
 elif tab == "Text to Image":
     st.subheader("🖼️ Text to Image")
     prompt = st.text_area("Enter image prompt")
-    style = st.selectbox("Choose Style", ["sdxl", "deepfloyd", "kandinsky"])
+    style = st.selectbox("Choose style", ["nature", "technology", "urban", "abstract"])
 
     if st.button("🧠 Generate Image"):
-        with st.spinner("Generating image..."):
+        with st.spinner("Generating image from Unsplash..."):
             r = requests.post(
-                f"{API_BASE}/api/v1/image/generate", 
-                json={"prompt": prompt, "style": style},  # ✅ correct key
+                f"{API_BASE}/api/v1/image/generate",
+                json={"prompt": prompt, "style": style},
                 headers=HEADERS
             )
             if r.status_code == 200:
-                try:
-                    res_json = r.json()
-                    download_url = res_json.get("download_url")
-                    if not download_url:
-                        st.error("No download URL returned.")
-                    else:
-                        download_full_url = f"{API_BASE}{download_url}"
-                        image_response = requests.get(download_full_url, headers={"accept": "image/png"}, allow_redirects=True)
-                        if image_response.status_code != 200:
-                            st.error("❌ Failed to download image.")
-                            st.code(image_response.text)
-                            st.write("Status:", image_response.status_code)
-                            st.write("Headers:", image_response.headers)
-                        st.write(image_response.status_code, image_response.headers)
-                        render_media(image_response.content, "image", "Generated Image")
-                except Exception as e:
-                    st.error(f"⚠️ Failed to fetch/display image: {str(e)}")
-                    st.code(r.text)
+                render_media(r, "Generated Image")
             else:
                 try:
-                    detail = r.json().get("detail")
+                    err = r.json().get('detail', 'Unknown error')
                 except Exception:
-                    detail = r.text  # fallback to raw response text (may be empty or HTML)
-
-                st.error(f"❌ Failed: {detail}")                
+                    err = r.text
+                st.error(f"❌ Failed to fetch/display image: {err}")
 
+# ==================================================
+# Text to Video
+# ==================================================
 elif tab == "Text to Video":
     st.subheader("🎞️ Text to Video")
     prompt = st.text_area("Enter video prompt")
@@ -155,9 +115,6 @@ elif tab == "Text to Video":
     domain = st.selectbox("Domain", ["health", "education", "governance", "entertainment"])
     environment = st.selectbox("Environment", ["urban", "rural", "nature", "futuristic"])
 
-    transcript = st.text_area("Transcript (optional - for subtitles)", height=100)
-    enhance = st.checkbox("✨ Add Subtitles and Background Music")
-
     if st.button("🎬 Generate Video"):
         with st.spinner("Generating video..."):
             r = requests.post(
@@ -166,49 +123,9 @@ elif tab == "Text to Video":
                 headers=HEADERS
             )
             if r.status_code == 200:
-                try:
-                    data = r.json()
-                    st.code(data, language="json")
-
-                    download_url = data.get("download_url")
-                    if not download_url:
-                        st.error("⚠️ No download URL received.")
-                    else:
-                        full_video_url = f"{API_BASE}{download_url}"
-                        video_response = requests.get(full_video_url, headers=HEADERS)
-                        if video_response.status_code == 200:
-                            video_bytes = video_response.content
-                            st.write("📦 Video size (bytes):", len(video_bytes))
-
-                            if enhance and transcript:
-                                with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_vid:
-                                    tmp_vid.write(video_bytes)
-                                    tmp_vid_path = tmp_vid.name
-
-                                srt_path = generate_srt_from_text(transcript, output_path="streamlit_subs.srt")
-                                enhanced_path = "streamlit_final_video.mp4"
-                                enhance_video_with_subtitles_and_bgm(
-                                    video_path=tmp_vid_path,
-                                    srt_path=srt_path,
-                                    bgm_path="default_bgm.mp3",
-                                    output_path=enhanced_path
-                                )
-
-                                with open(enhanced_path, "rb") as f:
-                                    render_media(f.read(), "video", "Enhanced Video")
-                            else:
-                                st.video(video_bytes)
-                        else:
-                            st.error("❌ Failed to download video.")
-                except Exception as e:
-                    st.error("❌ Error parsing response or rendering video.")
-                    st.code(r.text)
-                    st.exception(e)
+                render_media(r, "Generated Video")
             else:
-                try:
-                    st.error(f"❌ Failed: {r.json().get('detail')}")
-                except:
-                    st.error(f"❌ Failed: {r.text}")
+                st.error(f"❌ Failed: {r.json().get('detail', r.text)}")
 
 
 st.sidebar.markdown("---")