Update app.py

app.py

@@ -1,19 +1,21 @@
-# low_quality_video_inator.py
+# app.py
 import asyncio
 import os
 import re
 import shutil
 import uuid
-import glob
-import subprocess
+import html
 from pathlib import Path
+from typing import Optional, Tuple
+
 import gradio as gr
 
 # -------------------------
-# Config / constants
+# Config
 # -------------------------
-UPLOAD_FOLDER = Path("uploads")
-CONVERTED_FOLDER = Path("converted")
+BASE_DIR = Path(".")
+UPLOAD_FOLDER = BASE_DIR / "uploads"
+CONVERTED_FOLDER = BASE_DIR / "converted"
 UPLOAD_FOLDER.mkdir(exist_ok=True)
 CONVERTED_FOLDER.mkdir(exist_ok=True)
 
@@ -26,33 +28,60 @@ ALLOWED_EXTENSIONS = {
     ".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:
+# Ensure fdkaac executable bit if it exists in cwd
+FDKAAC_PATH = Path("./fdkaac")
+try:
+    if FDKAAC_PATH.exists():
+        FDKAAC_PATH.chmod(FDKAAC_PATH.stat().st_mode | 0o111)
+except Exception:
+    pass
+
+# -------------------------
+# Helpers
+# -------------------------
+def is_audio_file(path: str) -> bool:
+    ext = Path(path).suffix.lower()
+    return ext in {".mp3", ".m4a", ".wav", ".aac", ".oga", ".ogg"}
+
+def preview_html(percent: float, step: str, media_src: Optional[str] = None) -> str:
+    """Return HTML containing media preview (video or audio) with overlayed progress/step."""
     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>
+    esc_step = html.escape(str(step))
+    media_tag = ""
+    if media_src:
+        esc_src = html.escape(str(media_src))
+        if is_audio_file(media_src):
+            media_tag = f'<audio src="{esc_src}" controls style="width:100%;display:block;"></audio>'
+        else:
+            media_tag = f'<video src="{esc_src}" controls style="width:100%;height:auto;display:block;"></video>'
+    else:
+        media_tag = (
+            '<div style="width:100%;height:320px;display:flex;align-items:center;justify-content:center;'
+            'background:#0b0b0b;color:#fff;font-size:16px;">Preview will appear here once available</div>'
+        )
+
+    return f'''
+    <div style="position:relative;border-radius:8px;overflow:hidden;border:1px solid #ddd;">
+      {media_tag}
+      <div style="position:absolute;left:8px;right:8px;bottom:12px;pointer-events:none;">
+        <div style="background:rgba(0,0,0,0.52);padding:10px;border-radius:8px;color:#fff;font-family:system-ui,Segoe UI,Roboto,Arial;">
+          <div style="font-size:13px;margin-bottom:8px;"><strong>{esc_step}</strong></div>
+          <div style="height:12px;background:#222;border-radius:6px;overflow:hidden;">
+            <div style="width:{pct:.2f}%;height:100%;background:linear-gradient(90deg,#21d4fd,#b721ff);"></div>
+          </div>
+          <div style="font-size:12px;margin-top:6px;color:#ddd;">{pct:.1f}%</div>
         </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)."""
+async def run_command_capture(cmd, cwd=None, env=None) -> Tuple[str, str, int]:
+    """Run command to completion, capture stdout/stderr."""
     proc = await asyncio.create_subprocess_exec(
         *cmd,
         cwd=cwd,
@@ -63,73 +92,33 @@ async def run_command_capture(cmd, cwd=None, env=None):
     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."""
+async def get_duration_seconds(path: Path) -> Optional[float]:
+    """Get duration using ffprobe (seconds) or None if unknown."""
     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),
-        ]
-        stdout, stderr, rc = await run_command_capture(cmd2)
-        if rc != 0:
-            return None
+    if rc != 0 or not stdout:
+        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()
-    )
-
-    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
+def which_cmd(name: str) -> Optional[str]:
+    return shutil.which(name)
 
 # -------------------------
-# Conversion logic (async generator feeding Gradio)
+# Converter generator
+# streams tuples: (preview_html_str, download_path_or_None)
 # -------------------------
 async def convert_stream(
     use_youtube: bool,
     youtube_url: str,
-    video_file,  # gr.File-like arg when uploaded
+    video_file,  # gr.File
     downscale: bool,
     faster: bool,
     use_mp3: bool,
@@ -137,111 +126,72 @@ async def convert_stream(
     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
-
-    # 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
+    # initial
+    yield preview_html(0.0, "Starting..."), None
 
-    # Choose input source
-    input_path: Path | None = None
     temp_files = []
+    input_path: Optional[Path] = None
 
     try:
+        # SOURCE
         if use_youtube:
             if not youtube_url:
-                step = "Error: YouTube URL required."
-                yield progress_html(0.0, step), step, None, None
+                yield preview_html(0.0, "Error: YouTube URL required."), None
+                return
+            if not which_cmd("yt-dlp"):
+                yield preview_html(0.0, "yt-dlp not found on server. Please upload the file manually."), None
                 return
 
-            step = "Attempting to download from YouTube (yt-dlp)..."
-            yield progress_html(1.0, step), step, None, None
-
-            # Build output template
+            yield preview_html(1.0, "Attempting YouTube download..."), None
             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)
+            combined = (stdout or "") + "\n" + (stderr or "")
             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
+                    yield preview_html(0.0, "Video unavailable (removed/private/age-restricted)."), None
                     return
-            # find the downloaded file
+                yield preview_html(0.0, "Could not download from YouTube from this server (cloud host blocked). Please upload manually."), None
+                return
             files = list(UPLOAD_FOLDER.glob(f"{out_uuid}.*"))
             if not files:
-                step = "Download completed but file not found."
-                yield progress_html(0.0, step), step, None, None
+                yield preview_html(0.0, "Download completed but file not found."), None
                 return
             input_path = files[0]
             temp_files.append(input_path)
-
         else:
             if not video_file:
-                step = "No video provided. Upload a file or use a YouTube URL."
-                yield progress_html(0.0, step), step, None, None
+                yield preview_html(0.0, "No video provided. Upload or use YouTube URL."), 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
+                yield preview_html(0.0, f"Unsupported file type: {ext}"), None
                 return
             input_path = UPLOAD_FOLDER / f"{uuid.uuid4().hex}{ext}"
             shutil.copy2(video_file.name, input_path)
             temp_files.append(input_path)
 
-        # 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
+        yield preview_html(1.0, "Probing duration..."), None
+        total_seconds = await get_duration_seconds(input_path)
+        if not total_seconds:
+            yield preview_html(0.0, "Warning: duration unknown; progress will be step-based."), None
+
+        # AUDIO-ONLY PATH
         if audio_only:
+            # MP3 branch
             if use_mp3:
-                step = "Converting audio to MP3..."
-                yield progress_html(1.0, step), step, None, None
+                step = "Converting to MP3..."
                 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)
+                    "-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:
+                yield preview_html(2.0, step), None
+                if total_seconds:
                     proc = await asyncio.create_subprocess_exec(*ffmpeg_cmd, stderr=asyncio.subprocess.PIPE)
                     last = 0.0
                     while True:
@@ -250,191 +200,205 @@ async def convert_stream(
                             break
                         txt = line.decode(errors="ignore")
                         m = FFMPEG_TIME_RE.search(txt)
-                        if m and total:
+                        if m:
                             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
+                            pct = (current / total_seconds) * 100.0
+                            if pct - last >= 0.5:
+                                last = pct
+                                yield preview_html(pct, step), None
                     await proc.wait()
                     if proc.returncode != 0:
-                        raise RuntimeError("ffmpeg audio conversion failed")
+                        yield preview_html(0.0, "ffmpeg failed while encoding MP3."), None
+                        return
                 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)
+                        yield preview_html(0.0, "ffmpeg failed while encoding MP3."), None
+                        return
+                yield preview_html(100.0, "MP3 conversion finished.", media_src=str(out_audio)), str(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)
+            # AAC via fdkaac branch (audio-only)
+            # Ensure fdkaac exists
+            if not FDKAAC_PATH.exists():
+                yield preview_html(0.0, "fdkaac not found at ./fdkaac — please add it to the app folder and make executable."), None
                 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
+            step = "Preparing WAV for fdkaac..."
+            yield preview_html(2.0, step), None
+            wav_tmp = CONVERTED_FOLDER / f"{uuid.uuid4().hex}.wav"
+            aac_out = CONVERTED_FOLDER / f"{uuid.uuid4().hex}.m4a"
+
+            # Generate WAV (low sample rate)
+            ffmpeg_wav_cmd = ["ffmpeg", "-y", "-i", str(input_path), "-ac", "1", "-ar", "8000", str(wav_tmp)]
+            stdout, stderr, rc = await run_command_capture(ffmpeg_wav_cmd)
+            if rc != 0:
+                yield preview_html(0.0, "ffmpeg failed to produce WAV for fdkaac."), None
+                try:
+                    wav_tmp.unlink()
+                except Exception:
+                    pass
+                return
+
+            # Run fdkaac to produce m4a
+            fdkaac_cmd = [
+                "./fdkaac", "-b", "1k", "-C", "-f", "2", "-G", "1", "-w", "8000",
+                "-o", str(aac_out), str(wav_tmp)
+            ]
+            yield preview_html(5.0, "Encoding AAC with fdkaac..."), None
+            stdout, stderr, rc = await run_command_capture(fdkaac_cmd)
+            try:
+                wav_tmp.unlink()
+            except Exception:
+                pass
+            if rc != 0:
+                yield preview_html(0.0, f"fdkaac failed: {stderr[:300] if stderr else 'no output'}"), None
+                return
+
+            yield preview_html(100.0, "AAC (fdkaac) audio ready.", media_src=str(aac_out)), str(aac_out)
+            return
+
+        # ----------------------
+        # FULL VIDEO FLOW
+        # ----------------------
+        # 1) Audio encode (via fdkaac or mp3)
         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)]
+            ffmpeg_audio_cmd = ["ffmpeg", "-y", "-i", str(input_path), "-ac", "1", "-ar", "8000", "-c:a", "libmp3lame", "-b:a", "8k", str(out_audio)]
+            yield preview_html(2.0, "Encoding audio (MP3)..."), None
+            if total_seconds:
+                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:
+                        hh, mm, ss = m.groups()
+                        current = int(hh) * 3600 + int(mm) * 60 + float(ss)
+                        pct = (current / total_seconds) * 100.0 * 0.20
+                        if pct - last >= 0.5:
+                            last = pct
+                            yield preview_html(pct, "Encoding audio (MP3)..."), None
+                await proc.wait()
+                if proc.returncode != 0:
+                    yield preview_html(0.0, "ffmpeg audio encoding failed."), None
+                    return
+            else:
+                stdout, stderr, rc = await run_command_capture(ffmpeg_audio_cmd)
+                if rc != 0:
+                    yield preview_html(0.0, "ffmpeg audio encoding failed."), None
+                    return
         else:
-            ffmpeg_audio_cmd += ["aac", "-b:a", "12k", str(out_audio)]
+            # Use fdkaac path for AAC
+            if not FDKAAC_PATH.exists():
+                yield preview_html(0.0, "fdkaac not found at ./fdkaac — please add it to the app folder and make executable."), None
+                return
 
-        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)
+            # 1a: Create WAV
+            yield preview_html(2.0, "Generating WAV for fdkaac..."), None
+            wav_tmp = CONVERTED_FOLDER / f"{uuid.uuid4().hex}.wav"
+            ffmpeg_wav_cmd = ["ffmpeg", "-y", "-i", str(input_path), "-ac", "1", "-ar", "8000", str(wav_tmp)]
+            stdout, stderr, rc = await run_command_capture(ffmpeg_wav_cmd)
+            if rc != 0:
+                yield preview_html(0.0, "ffmpeg failed generating WAV for fdkaac."), None
+                try:
+                    wav_tmp.unlink()
+                except Exception:
+                    pass
+                return
+
+            # 1b: Run fdkaac
+            aac_tmp = CONVERTED_FOLDER / f"{uuid.uuid4().hex}.m4a"
+            fdkaac_cmd = [
+                "./fdkaac", "-b", "1k", "-C", "-f", "2", "-G", "1", "-w", "8000",
+                "-o", str(aac_tmp), str(wav_tmp)
+            ]
+            yield preview_html(6.0, "Encoding AAC with fdkaac..."), None
+            stdout, stderr, rc = await run_command_capture(fdkaac_cmd)
+            try:
+                wav_tmp.unlink()
+            except Exception:
+                pass
             if rc != 0:
-                raise RuntimeError("ffmpeg audio encoding failed (no duration)")
+                yield preview_html(0.0, f"fdkaac failed: {stderr[:300] if stderr else 'no output'}"), None
+                return
+            out_audio = aac_tmp
 
-        # 2) encode video-only
-        step = "Encoding video track..."
-        yield progress_html(5.0, step), step, None, None
+        # 2) Video encode
+        step_video = "Encoding video track..."
+        yield preview_html(20.0, step_video), 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
+        if total_seconds:
             proc = await asyncio.create_subprocess_exec(*ffmpeg_video_cmd, stderr=asyncio.subprocess.PIPE)
-            last = 0.0
+            last = 20.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:
+                if m:
                     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
+                    pct_video = (current / total_seconds) * 100.0
+                    combined = 20.0 + (pct_video * 0.70)
+                    if combined - last >= 0.5:
+                        last = combined
+                        yield preview_html(combined, step_video), None
             await proc.wait()
             if proc.returncode != 0:
-                raise RuntimeError("ffmpeg video encoding failed")
+                yield preview_html(0.0, "ffmpeg video encoding failed."), None
+                return
         else:
             stdout, stderr, rc = await run_command_capture(ffmpeg_video_cmd)
             if rc != 0:
-                raise RuntimeError("ffmpeg video encoding failed (no duration)")
+                yield preview_html(0.0, "ffmpeg video encoding failed."), None
+                return
 
-        # 3) merge audio+video (fast copy)
-        step = "Merging audio and video..."
-        yield progress_html(95.0, step), step, None, None
+        # 3) Merge audio + video
+        yield preview_html(90.0, "Merging audio & video..."), 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)
-        ]
+        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)
-            ]
+            # fallback re-encode audio into AAC during merge
+            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")
+                yield preview_html(0.0, "Merging audio and video failed."), None
+                return
 
-        # cleanup temp pieces
+        # cleanup intermediate audio/video
         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)
+        # final
+        yield preview_html(100.0, "Conversion complete!", media_src=str(merged_out)), str(merged_out)
         return
 
     except Exception as e:
-        err = f"Error: {e}"
-        yield progress_html(0.0, err), err, None, None
+        yield preview_html(0.0, f"Error: {e}"), None
         return
     finally:
-        # remove temporary download files if any
+        # remove any temp files downloaded
         for p in temp_files:
             try:
                 p.unlink()
@@ -444,14 +408,11 @@ async def convert_stream(
 # -------------------------
 # 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.Blocks(title="Low Quality Video Inator (fdkaac)") as demo:
+    gr.Markdown("# Low Quality Video Inator\nUpload a file or paste a YouTube URL. The app streams a step-aware overlayed progress bar while encoding.\n\n**Note:** put `fdkaac` binary in the same folder as this app and make it executable (`chmod +x fdkaac`).")
 
     with gr.Row():
-        use_youtube = gr.Checkbox(label="Use YouTube URL (try server download first)", value=False)
+        use_youtube = gr.Checkbox(label="Use YouTube URL (server will try to 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")
@@ -464,28 +425,22 @@ with gr.Blocks(title="Low Quality Video Inator", css="""
         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)
+        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])
+    def toggle_bitrate(v):
+        return gr.update(visible=v)
+    custom_bitrate.change(toggle_bitrate, 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")
+    preview_html_el = gr.HTML("<div>Ready. Preview will appear here.</div>", label="Preview")
+    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]
+        outputs=[preview_html_el, download_file]
     )
 
-# Safety / hosting configuration: no flagging UI
-demo.launch()
+demo.launch(share=False)