Update app.py

app.py

@@ -1,225 +1,491 @@
-import os
+# low_quality_video_inator.py
 import asyncio
-import subprocess
+import os
+import re
+import shutil
 import uuid
 import glob
-import shutil
+import subprocess
+from pathlib import Path
 import gradio as gr
 
-allowed_extensions = [
-    ".3g2", ".3gp", ".3gpp", ".avi", ".cavs", ".dv", ".dvr", ".flv", ".m2ts",
-    ".m4v", ".mkv", ".mod", ".mov", ".mp4", ".mpeg", ".mpg", ".mts", ".mxf",
-    ".ogg", ".rm", ".rmvb", ".swf", ".ts", ".vob", ".webm", ".wmv", ".wtv",
-    ".ogv", ".opus", ".aac", ".ac3", ".aif", ".aifc", ".aiff", ".amr", ".au",
-    ".caf", ".dss", ".flac", ".m4a", ".m4b", ".mp3", ".oga", ".voc", ".wav",
-    ".weba", ".wma"
-]
-
-os.system("chmod +x fdkaac")  # Make sure fdkaac is executable
-
-accel = 'auto'
-video_base_opts = ['-crf', '63', '-c:v', 'libx264', '-tune', 'zerolatency']
-
-UPLOAD_FOLDER = 'uploads'
-CONVERTED_FOLDER = 'converted'
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-os.makedirs(CONVERTED_FOLDER, exist_ok=True)
-
-async def run_subprocess(cmd, use_fdkaac=False):
-    env = os.environ.copy()
-    if use_fdkaac:
-        env["LD_LIBRARY_PATH"] = os.path.abspath("./") + ":" + env.get("LD_LIBRARY_PATH", "")
-    print(f"[DEBUG] Running command:\n{' '.join(cmd)}\n")
-    process = await asyncio.create_subprocess_exec(
+# -------------------------
+# Config / constants
+# -------------------------
+UPLOAD_FOLDER = Path("uploads")
+CONVERTED_FOLDER = Path("converted")
+UPLOAD_FOLDER.mkdir(exist_ok=True)
+CONVERTED_FOLDER.mkdir(exist_ok=True)
+
+ALLOWED_EXTENSIONS = {
+    ".3g2", ".3gp", ".3gpp", ".avi", ".cavs", ".dv", ".dvr", ".flv",
+    ".m2ts", ".m4v", ".mkv", ".mod", ".mov", ".mp4", ".mpeg", ".mpg",
+    ".mts", ".mxf", ".ogg", ".rm", ".rmvb", ".swf", ".ts", ".vob",
+    ".webm", ".wmv", ".wtv", ".ogv", ".opus", ".aac", ".ac3", ".aif",
+    ".aifc", ".aiff", ".amr", ".au", ".caf", ".dss", ".flac", ".m4a",
+    ".m4b", ".mp3", ".oga", ".voc", ".wav", ".weba", ".wma"
+}
+
+# FFmpeg defaults
+VIDEO_BASE_OPTS = ["-crf", "63", "-c:v", "libx264", "-tune", "zerolatency"]
+ACCEL = "auto"
+
+# Regex to find ffmpeg "time=HH:MM:SS.mmm" in stderr
+FFMPEG_TIME_RE = re.compile(r"time=(\d+):(\d+):(\d+\.\d+)")
+
+# Helper HTML progress bar generator (friendly and portable)
+def progress_html(percent: float, step: str) -> str:
+    pct = max(0.0, min(100.0, percent))
+    bar = f"""
+    <div style="font-family:system-ui,Segoe UI,Roboto,Arial;margin-bottom:6px;">
+      <div style="font-size:14px;margin-bottom:4px;"><strong>Step:</strong> {gr.utils.html.escape(step)}</div>
+      <div style="background:#eee;border-radius:6px;overflow:hidden;border:1px solid #ddd;">
+        <div style="width:{pct:.2f}%;padding:8px 0;text-align:center;white-space:nowrap;">
+          <span style="color:#111;font-weight:600;">{pct:.1f}%</span>
+        </div>
+      </div>
+    </div>
+    """
+    return bar
+
+# -------------------------
+# Async process helpers
+# -------------------------
+async def run_command_capture(cmd, cwd=None, env=None):
+    """Run command to completion, return (stdout, stderr, returncode)."""
+    proc = await asyncio.create_subprocess_exec(
         *cmd,
+        cwd=cwd,
+        env=env or os.environ.copy(),
         stdout=asyncio.subprocess.PIPE,
         stderr=asyncio.subprocess.PIPE,
-        env=env
     )
-    stdout, stderr = await process.communicate()
-    if process.returncode != 0:
-        print(f"[ERROR] Command failed:\n{stderr.decode()}\n")
-        raise subprocess.CalledProcessError(process.returncode, cmd, stderr.decode())
-    print(f"[DEBUG] Command succeeded:\n{stdout.decode()}\n")
-    return stdout.decode(), stderr.decode()
-
-async def convert_video_task(input_path, downscale, faster, use_mp3, audio_only, custom_bitrate, video_bitrate):
-    if audio_only:
-        if use_mp3:
-            # Directly convert to MP3 via ffmpeg
-            output_audio = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.mp3")
-            ffmpeg_audio_cmd = [
-                'ffmpeg', '-y', '-i', input_path,
-                '-c:a', 'libmp3lame', '-b:a', '8k', '-ar', '24000', '-ac', '1',
-                output_audio
-            ]
-            await run_subprocess(ffmpeg_audio_cmd)
-            return output_audio, None
-        else:
-            # Convert to WAV, then AAC via fdkaac
-            audio_wav = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.wav")
-            audio_output = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.m4a")
-            await run_subprocess([
-                'ffmpeg', '-y', '-i', input_path, '-ac', '1', '-ar', '8000', audio_wav
-            ])
-            await run_subprocess([
-                './fdkaac', '-b', '1k', '-C', '-f', '2', '-G', '1', '-w', '8000',
-                '-o', audio_output, audio_wav
-            ], use_fdkaac=True)
-            os.remove(audio_wav)
-            return audio_output, None
-
-    # Video conversion paths
-    if use_mp3:
-        output_video = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.mp4")
-        ffmpeg_video_cmd = [
-            'ffmpeg', '-y', '-hwaccel', accel, '-i', input_path
-        ]
-    
-    if custom_bitrate:
-        ffmpeg_video_cmd += ['-b:v', f"{int(video_bitrate)}k"]
-    else:
-        ffmpeg_video_cmd += video_base_opts
-        
-    if faster:
-             ffmpeg_video_cmd.extend(['-preset', 'ultrafast'])
-    
-    ffmpeg_video_cmd += [
-            '-c:a', 'libmp3lame', '-b:a', '8k', '-ar', '24000', '-ac', '1',
-            output_video
+    stdout, stderr = await proc.communicate()
+    return stdout.decode(errors="ignore"), stderr.decode(errors="ignore"), proc.returncode
+
+async def get_duration_seconds(path: Path) -> float | None:
+    """Get media duration using ffprobe. Returns seconds or None."""
+    cmd = [
+        "ffprobe", "-v", "error",
+        "-select_streams", "v:0",
+        "-show_entries", "format=duration",
+        "-of", "default=noprint_wrappers=1:nokey=1",
+        str(path)
+    ]
+    stdout, stderr, rc = await run_command_capture(cmd)
+    if rc != 0:
+        # try generic format probing
+        cmd2 = [
+            "ffprobe", "-v", "error",
+            "-show_entries", "format=duration",
+            "-of", "default=noprint_wrappers=1:nokey=1",
+            str(path),
         ]
-        await run_subprocess(ffmpeg_video_cmd)
-        return None, output_video
-
-    # AAC video + fdkaac audio merge
-    audio_wav = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.wav")
-    audio_output = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.m4a")
-    video_output = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.mp4")
-
-    await run_subprocess([
-        'ffmpeg', '-y', '-i', input_path, '-ac', '1', '-ar', '8000', audio_wav
-    ])
-
-    await run_subprocess([
-        './fdkaac', '-b', '1k', '-C', '-f', '2', '-G', '1', '-w', '8000',
-        '-o', audio_output, audio_wav
-    ], use_fdkaac=True)
-
-    video_cmd = ['ffmpeg', '-y', '-hwaccel', accel, '-i', input_path]
-    if downscale:
-        video_cmd += ['-vf', 'scale=-2:144']
-    if custom_bitrate:
-        video_cmd += ['-b:v', f"{int(video_bitrate)}k"]
-    else:
-        video_cmd += video_base_opts
-        if faster:
-            video_cmd.extend(['-preset', 'ultrafast'])
-    video_cmd += ['-an', video_output]
-    await run_subprocess(video_cmd)
+        stdout, stderr, rc = await run_command_capture(cmd2)
+        if rc != 0:
+            return None
+    try:
+        return float(stdout.strip())
+    except Exception:
+        return None
+
+async def stream_ffmpeg_with_progress(cmd, total_seconds, step_name, yield_fn):
+    """
+    Run ffmpeg command and stream progress updates via yield_fn(percent, step_name).
+    yield_fn is a coroutine function that accepts (percent: float, step_text: str)
+    """
+    # Start process, read stderr line-by-line
+    proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        env=os.environ.copy()
+    )
 
-    merged_output = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.mp4")
-    await run_subprocess([
-        'ffmpeg', '-y', '-i', video_output, '-i', audio_output, '-c', 'copy', merged_output
-    ])
+    last_percent = 0.0
+    # Read stderr bytes as they arrive
+    while True:
+        line = await proc.stderr.readline()
+        if not line:
+            break
+        text = line.decode(errors="ignore").strip()
+        # parse time=HH:MM:SS.ms
+        m = FFMPEG_TIME_RE.search(text)
+        if m and total_seconds and total_seconds > 0.0:
+            hh, mm, ss = m.groups()
+            current = int(hh) * 3600 + int(mm) * 60 + float(ss)
+            percent = (current / total_seconds) * 100.0
+            # Only yield when percent changed enough to avoid UI spam
+            if percent - last_percent >= 0.5:
+                last_percent = percent
+                await yield_fn(percent, step_name)
+        # Optionally we can yield textual debug lines (not required)
+    await proc.wait()
+    return proc.returncode
 
-    for f in [audio_wav, audio_output, video_output]:
-        try:
-            os.remove(f)
-        except FileNotFoundError:
-            pass
+# -------------------------
+# Conversion logic (async generator feeding Gradio)
+# -------------------------
+async def convert_stream(
+    use_youtube: bool,
+    youtube_url: str,
+    video_file,  # gr.File-like arg when uploaded
+    downscale: bool,
+    faster: bool,
+    use_mp3: bool,
+    audio_only: bool,
+    custom_bitrate: bool,
+    video_bitrate: float
+):
+    # Convenience small helper to push progress to UI (Gradio generator will yield)
+    async def push(percent: float, step_text: str):
+        yield progress_html(percent, step_text), step_text, None, None
 
-    return None, merged_output
+    # Another helper to yield final outputs
+    def final_yield(percent, step_text, preview_path, download_path):
+        # Gradio generator expects plain values, not coroutine - so we return these
+        return progress_html(percent, step_text), step_text, str(preview_path) if preview_path else None, str(download_path) if download_path else None
+
+    # Start
+    step = "Starting..."
+    yield progress_html(0.0, step), step, None, None
+
+    # Choose input source
+    input_path: Path | None = None
+    temp_files = []
 
-async def process_conversion(use_youtube, youtube_url, video_file, downscale, faster, use_mp3, audio_only, custom_bitrate, video_bitrate):
     try:
         if use_youtube:
             if not youtube_url:
-                return "Error: YouTube URL required.", None
-            yt_uuid = str(uuid.uuid4())
-            yt_out = os.path.join(UPLOAD_FOLDER, yt_uuid + ".%(ext)s")
-            yt_cmd = ['yt-dlp', '-o', yt_out, '-f', 'b', youtube_url]
-            await run_subprocess(yt_cmd)
-            pattern = os.path.join(UPLOAD_FOLDER, yt_uuid + ".*")
-            files = glob.glob(pattern)
+                step = "Error: YouTube URL required."
+                yield progress_html(0.0, step), step, None, None
+                return
+
+            step = "Attempting to download from YouTube (yt-dlp)..."
+            yield progress_html(1.0, step), step, None, None
+
+            # Build output template
+            out_uuid = uuid.uuid4().hex
+            out_template = str(UPLOAD_FOLDER / f"{out_uuid}.%(ext)s")
+            ytdlp_cmd = ["yt-dlp", "-f", "b", "-o", out_template, youtube_url]
+
+            # Run and capture stderr to inspect errors
+            stdout, stderr, rc = await run_command_capture(ytdlp_cmd)
+            if rc != 0:
+                # Inspect stderr for "Video unavailable"
+                combined = (stdout or "") + "\n" + (stderr or "")
+                if "Video unavailable" in combined or "This video is unavailable" in combined:
+                    step = "Error: Video unavailable on YouTube (removed / private / blocked by uploader)."
+                    yield progress_html(0.0, step), step, None, None
+                    return
+                else:
+                    # Assume server/cloud IP is blocked by YouTube; instruct user to upload
+                    step = (
+                        "Could not download from YouTube from this server. "
+                        "This is commonly caused by YouTube blocking cloud host IPs. "
+                        "Please upload the file manually using the 'Upload Video File' control, or try again from another network."
+                    )
+                    yield progress_html(0.0, step), step, None, None
+                    return
+            # find the downloaded file
+            files = list(UPLOAD_FOLDER.glob(f"{out_uuid}.*"))
             if not files:
-                return "Download failed.", None
+                step = "Download completed but file not found."
+                yield progress_html(0.0, step), step, None, None
+                return
             input_path = files[0]
+            temp_files.append(input_path)
+
         else:
             if not video_file:
-                return "No video provided.", None
-            ext = os.path.splitext(video_file.name)[1].lower()
-            if ext not in allowed_extensions:
-                return f"Unsupported file type: {ext}", None
-            input_path = os.path.join(UPLOAD_FOLDER, f"{uuid.uuid4()}{ext}")
+                step = "No video provided. Upload a file or use a YouTube URL."
+                yield progress_html(0.0, step), step, None, None
+                return
+            # gr.File's .name gives a local temp path in many deployments
+            try:
+                ext = Path(video_file.name).suffix.lower()
+            except Exception:
+                ext = None
+            if ext not in ALLOWED_EXTENSIONS:
+                step = f"Unsupported file type: {ext}"
+                yield progress_html(0.0, step), step, None, None
+                return
+            input_path = UPLOAD_FOLDER / f"{uuid.uuid4().hex}{ext}"
             shutil.copy2(video_file.name, input_path)
+            temp_files.append(input_path)
 
-        audio_out, video_out = await convert_video_task(
-            input_path, downscale, faster, use_mp3, audio_only, custom_bitrate, video_bitrate
-        )
+        # We now have input_path
+        step = "Probing file duration..."
+        yield progress_html(2.0, step), step, None, None
+        total = await get_duration_seconds(input_path)
+        if not total:
+            # Might still proceed but progress can't show percent; we will show step-based progress
+            step = "Warning: could not read duration; progress will be step-based."
+            yield progress_html(0.0, step), step, None, None
+            total = None
 
+        # Handle audio-only or full conversion
         if audio_only:
-            return audio_out, audio_out
-        return video_out, video_out
+            if use_mp3:
+                step = "Converting audio to MP3..."
+                yield progress_html(1.0, step), step, None, None
+                out_audio = CONVERTED_FOLDER / f"{uuid.uuid4().hex}.mp3"
+                # ffmpeg low bitrate mp3 example:
+                ffmpeg_cmd = [
+                    "ffmpeg", "-y", "-i", str(input_path),
+                    "-ac", "1", "-ar", "24000", "-b:a", "8k",
+                    str(out_audio)
+                ]
+                # If we have duration, stream progress parsing
+                if total:
+                    async def _yield_fn(p, s):
+                        yield progress_html(p, s), s, None, None
+                    # Because run_ffmpeg_with_progress expects a coroutine yield_fn, but Gradio expects
+                    # yields from this generator directly, implement manual streaming:
+                    proc = await asyncio.create_subprocess_exec(*ffmpeg_cmd, stderr=asyncio.subprocess.PIPE)
+                    last = 0.0
+                    while True:
+                        line = await proc.stderr.readline()
+                        if not line:
+                            break
+                        txt = line.decode(errors="ignore")
+                        m = FFMPEG_TIME_RE.search(txt)
+                        if m and total:
+                            hh, mm, ss = m.groups()
+                            current = int(hh) * 3600 + int(mm) * 60 + float(ss)
+                            percent = (current / total) * 100.0
+                            if percent - last >= 0.5:
+                                last = percent
+                                yield progress_html(percent, step), step, None, None
+                    await proc.wait()
+                    if proc.returncode != 0:
+                        raise RuntimeError("ffmpeg audio conversion failed")
+                else:
+                    # fallback synchronous run
+                    stdout, stderr, rc = await run_command_capture(ffmpeg_cmd)
+                    if rc != 0:
+                        raise RuntimeError(f"ffmpeg failed: {stderr[:200]}")
+                # Done
+                yield final_yield(100.0, "Audio conversion finished.", out_audio, out_audio)
+                return
+            else:
+                # AAC path (use ffmpeg's aac if fdkaac missing)
+                step = "Extracting audio and encoding AAC..."
+                yield progress_html(1.0, step), step, None, None
+                out_audio = CONVERTED_FOLDER / f"{uuid.uuid4().hex}.m4a"
+                ffmpeg_cmd = [
+                    "ffmpeg", "-y", "-i", str(input_path),
+                    "-ac", "1", "-ar", "8000", "-c:a", "aac", "-b:a", "12k",
+                    str(out_audio)
+                ]
+                # stream progress if possible
+                if total:
+                    proc = await asyncio.create_subprocess_exec(*ffmpeg_cmd, stderr=asyncio.subprocess.PIPE)
+                    last = 0.0
+                    while True:
+                        line = await proc.stderr.readline()
+                        if not line:
+                            break
+                        txt = line.decode(errors="ignore")
+                        m = FFMPEG_TIME_RE.search(txt)
+                        if m and total:
+                            hh, mm, ss = m.groups()
+                            current = int(hh) * 3600 + int(mm) * 60 + float(ss)
+                            percent = (current / total) * 100.0
+                            if percent - last >= 0.5:
+                                last = percent
+                                yield progress_html(percent, step), step, None, None
+                    await proc.wait()
+                    if proc.returncode != 0:
+                        raise RuntimeError("ffmpeg aac audio encoding failed")
+                else:
+                    stdout, stderr, rc = await run_command_capture(ffmpeg_cmd)
+                    if rc != 0:
+                        raise RuntimeError(f"ffmpeg failed: {stderr[:200]}")
+
+                yield final_yield(100.0, "Audio conversion finished.", out_audio, out_audio)
+                return
+
+        # ---------- Video (with audio) flow ----------
+        # 1) encode audio (unless we're merging in single pass). We'll encode audio then encode video then merge.
+        step = "Encoding audio track..."
+        yield progress_html(1.0, step), step, None, None
+        out_audio = CONVERTED_FOLDER / f"{uuid.uuid4().hex}.m4a"
+        ffmpeg_audio_cmd = [
+            "ffmpeg", "-y", "-i", str(input_path),
+            "-ac", "1", "-ar", "8000", "-c:a"
+        ]
+        if use_mp3:
+            ffmpeg_audio_cmd += ["libmp3lame", "-b:a", "8k", str(out_audio)]
+        else:
+            ffmpeg_audio_cmd += ["aac", "-b:a", "12k", str(out_audio)]
+
+        if total:
+            proc = await asyncio.create_subprocess_exec(*ffmpeg_audio_cmd, stderr=asyncio.subprocess.PIPE)
+            last = 0.0
+            while True:
+                line = await proc.stderr.readline()
+                if not line:
+                    break
+                txt = line.decode(errors="ignore")
+                m = FFMPEG_TIME_RE.search(txt)
+                if m and total:
+                    hh, mm, ss = m.groups()
+                    current = int(hh) * 3600 + int(mm) * 60 + float(ss)
+                    percent = (current / total) * 100.0 * 0.20  # audio is 20% of total pipeline (visual weighting)
+                    if percent - last >= 0.5:
+                        last = percent
+                        yield progress_html(percent, step), step, None, None
+            await proc.wait()
+            if proc.returncode != 0:
+                raise RuntimeError("ffmpeg audio encoding failed")
+        else:
+            stdout, stderr, rc = await run_command_capture(ffmpeg_audio_cmd)
+            if rc != 0:
+                raise RuntimeError("ffmpeg audio encoding failed (no duration)")
+
+        # 2) encode video-only
+        step = "Encoding video track..."
+        yield progress_html(5.0, step), step, None, None
+        out_video = CONVERTED_FOLDER / f"{uuid.uuid4().hex}.mp4"
+        ffmpeg_video_cmd = ["ffmpeg", "-y", "-hwaccel", ACCEL, "-i", str(input_path)]
+
+        # Downscale if requested
+        if downscale:
+            ffmpeg_video_cmd += ["-vf", "scale=-2:144"]
+
+        # Bitrate handling
+        if custom_bitrate and video_bitrate:
+            ffmpeg_video_cmd += ["-b:v", f"{int(video_bitrate)}k"]
+        else:
+            ffmpeg_video_cmd += VIDEO_BASE_OPTS
+
+        if faster:
+            ffmpeg_video_cmd += ["-preset", "ultrafast"]
+
+        ffmpeg_video_cmd += ["-an", str(out_video)]
+
+        if total:
+            # We'll treat video encoding as 70% of pipeline
+            proc = await asyncio.create_subprocess_exec(*ffmpeg_video_cmd, stderr=asyncio.subprocess.PIPE)
+            last = 0.0
+            while True:
+                line = await proc.stderr.readline()
+                if not line:
+                    break
+                txt = line.decode(errors="ignore")
+                m = FFMPEG_TIME_RE.search(txt)
+                if m and total:
+                    hh, mm, ss = m.groups()
+                    current = int(hh) * 3600 + int(mm) * 60 + float(ss)
+                    percent_video = (current / total) * 100.0
+                    # Map video portion to a weighted chunk (20% done already for audio, video 70% here)
+                    combined_percent = 20.0 + (percent_video * 0.70)
+                    if combined_percent - last >= 0.5:
+                        last = combined_percent
+                        yield progress_html(combined_percent, step), step, None, None
+            await proc.wait()
+            if proc.returncode != 0:
+                raise RuntimeError("ffmpeg video encoding failed")
+        else:
+            stdout, stderr, rc = await run_command_capture(ffmpeg_video_cmd)
+            if rc != 0:
+                raise RuntimeError("ffmpeg video encoding failed (no duration)")
+
+        # 3) merge audio+video (fast copy)
+        step = "Merging audio and video..."
+        yield progress_html(95.0, step), step, None, None
+        merged_out = CONVERTED_FOLDER / f"{uuid.uuid4().hex}.mp4"
+        merge_cmd = [
+            "ffmpeg", "-y",
+            "-i", str(out_video),
+            "-i", str(out_audio),
+            "-c", "copy",
+            str(merged_out)
+        ]
+        stdout, stderr, rc = await run_command_capture(merge_cmd)
+        if rc != 0:
+            # sometimes copy fails due to container specifics; fallback to re-encoding mux
+            merge_cmd = [
+                "ffmpeg", "-y",
+                "-i", str(out_video),
+                "-i", str(out_audio),
+                "-c:v", "copy", "-c:a", "aac",
+                str(merged_out)
+            ]
+            stdout, stderr, rc = await run_command_capture(merge_cmd)
+            if rc != 0:
+                raise RuntimeError("Merging audio and video failed")
+
+        # cleanup temp pieces
+        for p in (out_audio, out_video):
+            try:
+                p.unlink()
+            except Exception:
+                pass
+
+        # Done
+        step = "Finished"
+        yield final_yield(100.0, "Conversion complete!", merged_out, merged_out)
+        return
+
     except Exception as e:
-        return f"Error: {str(e)}", None
-
-def convert_video(*args):
-    return asyncio.run(process_conversion(*args))
-
-with gr.Blocks(theme=gr.themes.Default(primary_hue="rose")) as demo:
-    gr.Markdown("""
-    # **Low Quality Video Inator**
-
-    Upload a video or paste a YouTube URL below, then tweak the settings.
-    **Note:** YouTube downloads almost never work on HuggingFace.
-    """)
-
-    with gr.Group():
-        with gr.Row():
-            use_youtube = gr.Checkbox(label="🔗 Use YouTube URL (usually broken here)", value=False)
-            youtube_url = gr.Textbox(label="YouTube URL", placeholder="Paste YouTube URL here")
-        video_file = gr.File(label="📁 Upload Video File", file_types=[
-            ".3g2", ".3gp", ".3gpp", ".avi", ".cavs", ".dv", ".dvr", ".flv", ".m2ts", ".m4v",
-            ".mkv", ".mod", ".mov", ".mp4", ".mpeg", ".mpg", ".mts", ".mxf", ".ogg", ".rm",
-            ".rmvb", ".swf", ".ts", ".vob", ".webm", ".wmv", ".wtv", ".ogv", ".opus", ".aac",
-            ".ac3", ".aif", ".aifc", ".aiff", ".amr", ".au", ".caf", ".dss", ".flac", ".m4a",
-            ".m4b", ".mp3", ".oga", ".voc", ".wav", ".weba", ".wma"
-        ])
-
-    gr.Markdown("### ⚙️ **Conversion Settings**")
-    with gr.Group():
-        with gr.Row():
-            downscale = gr.Checkbox(label="Downscale Video to 144p", value=False)
-            faster = gr.Checkbox(label="Faster Video Compression (pixelated, faster)", value=False)
-        with gr.Row():
-            use_mp3 = gr.Checkbox(label="Use MP3 Audio (better compatibility, AAC is lower quality)", value=False)
-            audio_only = gr.Checkbox(label="Audio Only (no video output)", value=False)
-        with gr.Row():
-            custom_bitrate = gr.Checkbox(label="Use Custom Video Bitrate", value=False)
-            video_bitrate = gr.Number(label="Video Bitrate (kbps)", visible=False)
-
-        custom_bitrate.change(
-            lambda checked: gr.update(visible=checked),
-            inputs=[custom_bitrate],
-            outputs=[video_bitrate]
-        )
-
-    convert_button = gr.Button("Convert Now", variant="primary")
-
-    gr.Markdown("### **Conversion Preview**")
-    video_preview = gr.Video(label="Preview Output")
-
-    gr.Markdown("### **Download Your Masterpiece**")
-    file_download = gr.File(label="Download Result")
-
-    convert_button.click(
-        convert_video,
-        inputs=[
-            use_youtube, youtube_url, video_file,
-            downscale, faster, use_mp3, audio_only,
-            custom_bitrate, video_bitrate
-        ],
-        outputs=[video_preview, file_download]
+        err = f"Error: {e}"
+        yield progress_html(0.0, err), err, None, None
+        return
+    finally:
+        # remove temporary download files if any
+        for p in temp_files:
+            try:
+                p.unlink()
+            except Exception:
+                pass
+
+# -------------------------
+# Gradio UI
+# -------------------------
+with gr.Blocks(title="Low Quality Video Inator", css="""
+    .gradio-container { font-family: system-ui, 'Segoe UI', Roboto, Arial; }
+""") as demo:
+
+    gr.Markdown("# Low Quality Video Inator\nUpload a video file or paste a YouTube URL. The interface will stream a step-aware progress bar while ffmpeg runs.")
+
+    with gr.Row():
+        use_youtube = gr.Checkbox(label="Use YouTube URL (try server download first)", value=False)
+        youtube_url = gr.Textbox(label="YouTube URL", placeholder="https://youtube.com/...", lines=1)
+
+    video_file = gr.File(label="Upload Video File", file_types=list(ALLOWED_EXTENSIONS), file_count="single")
+
+    gr.Markdown("### Conversion Settings")
+    with gr.Row():
+        downscale = gr.Checkbox(label="Downscale to 144p", value=False)
+        faster = gr.Checkbox(label="Faster encoding (lower quality)", value=False)
+    with gr.Row():
+        use_mp3 = gr.Checkbox(label="Use MP3 audio", value=False)
+        audio_only = gr.Checkbox(label="Audio Only", value=False)
+    with gr.Row():
+        custom_bitrate = gr.Checkbox(label="Use Custom Video Bitrate (kbps)", value=False)
+        video_bitrate = gr.Number(label="Video Bitrate (kbps)", value=64, visible=False)
+
+    # Toggle visibility of bitrate input
+    def toggle_bitrate_checkbox(use: bool):
+        return gr.update(visible=use)
+    custom_bitrate.change(toggle_bitrate_checkbox, inputs=[custom_bitrate], outputs=[video_bitrate])
+
+    convert_btn = gr.Button("Convert Now", variant="primary")
+
+    with gr.Column():
+        progress_area = gr.HTML("<div>Ready.</div>", label="Progress")
+        step_text = gr.Textbox(value="Idle", label="Current Step", interactive=False)
+        preview = gr.Video(label="Preview Output")
+        download_file = gr.File(label="Download Result")
+
+    # Hook up generator -> UI
+    convert_btn.click(
+        fn=convert_stream,
+        inputs=[use_youtube, youtube_url, video_file, downscale, faster, use_mp3, audio_only, custom_bitrate, video_bitrate],
+        outputs=[progress_area, step_text, preview, download_file]
     )
 
-demo.launch()
+# Safety / hosting configuration: no flagging UI
+demo.launch(share=False, prevent_thread_lock=True)