Update app.py

app.py

@@ -9,7 +9,7 @@ import gradio as gr
 os.system("chmod +x fdkaac")  # Ensure fdkaac is executable
 
 accel = 'auto'
-video_base_opts = ['-crf', '63', '-c:v', 'libx264', '-tune', 'zerolatency', '-movflags', '+faststart']
+video_base_opts = ['-crf', '63', '-c:v', 'libx264', '-tune', 'zerolatency']
 
 UPLOAD_FOLDER = 'uploads'
 CONVERTED_FOLDER = 'converted'
@@ -20,7 +20,6 @@ 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(
         *cmd,
         stdout=asyncio.subprocess.PIPE,
@@ -29,170 +28,140 @@ async def run_subprocess(cmd, use_fdkaac=False):
     )
     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, progress):
     if use_mp3:
+        progress.update(1, desc="Converting audio to MP3...")
         output_audio = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.mp3")
-        await progress(0.1, desc="Converting audio to MP3...")
-        ffmpeg_audio_cmd = [
+        cmd = [
             'ffmpeg', '-y', '-i', input_path, '-vn',
             '-c:a', 'libmp3lame', '-b:a', '8k', '-ar', '24000', '-ac', '1',
             output_audio
         ]
+        await run_subprocess(cmd)
         if audio_only:
-            await run_subprocess(ffmpeg_audio_cmd)
             return output_audio, None
+        # embed into video
+        progress.update(1, desc="Making the video quality lower...")
+        output_video = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.mp4")
+        cmd = ['ffmpeg', '-y', '-hwaccel', accel, '-i', input_path]
+        if custom_bitrate:
+            cmd += ['-b:v', f"{int(video_bitrate)}k"]
         else:
-            output_video = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.mp4")
-            await progress(0.3, desc="Making the video quality lower...")
-            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
-            ]
-            await run_subprocess(ffmpeg_video_cmd)
-            return None, output_video
-
-    # AAC (fdkaac) path
-    await progress(0.1, desc="Splitting Audio and Video...")
+            cmd += video_base_opts
+            if faster:
+                cmd += ['-preset', 'ultrafast']
+        cmd += ['-c:a', 'libmp3lame', '-b:a', '8k', '-ar', '24000', '-ac', '1', output_video]
+        await run_subprocess(cmd)
+        return None, output_video
+
+    # split
+    progress.update(1, desc="Splitting Audio and Video...")
     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(['ffmpeg','-y','-i',input_path,'-ac','1','-ar','8000',audio_wav])
 
-    await progress(0.3, desc="Converting audio to AAC which is lower quality...")
-    await run_subprocess([
-        './fdkaac', '-b', '1k', '-C', '-f', '2', '-G', '1', '-w', '8000',
-        '-o', audio_output, audio_wav
-    ], use_fdkaac=True)
+    # AAC encode
+    progress.update(1, desc="Converting audio to AAC which is lower quality...")
+    audio_output = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.m4a")
+    await run_subprocess([ './fdkaac','-b','1k','-C','-f','2','-G','1','-w','8000','-o',audio_output,audio_wav ], use_fdkaac=True)
 
-    await progress(0.6, desc="Making the video quality lower...")
-    video_cmd = [
-        'ffmpeg', '-y', '-hwaccel', accel, '-i', input_path
-    ]
+    # video
+    progress.update(1, desc="Making the video quality lower...")
+    video_output = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.mp4")
+    cmd = ['ffmpeg','-y','-hwaccel',accel,'-i',input_path]
     if downscale:
-        video_cmd += ['-vf', 'scale=-2:144']
+        cmd += ['-vf','scale=-2:144']
     if custom_bitrate:
-        video_cmd += ['-b:v', f"{int(video_bitrate)}k"]
+        cmd += ['-b:v',f"{int(video_bitrate)}k"]
     else:
-        video_cmd += video_base_opts
+        cmd += video_base_opts
         if faster:
-            video_cmd.extend(['-preset', 'ultrafast'])
-    video_cmd += ['-an', video_output]
-    await run_subprocess(video_cmd)
+            cmd += ['-preset','ultrafast']
+    cmd += ['-an',video_output]
+    await run_subprocess(cmd)
 
     if audio_only:
         return audio_output, None
 
-    await progress(0.9, desc="Mixing audio and video together...")
-    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
-    ])
+    # merge
+    progress.update(1, desc="Mixing audio and video together...")
+    merged = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.mp4")
+    await run_subprocess(['ffmpeg','-y','-i',video_output,'-i',audio_output,'-c','copy',merged])
 
-    for f in [audio_wav, audio_output, video_output]:
-        try:
-            os.remove(f)
-        except FileNotFoundError:
-            pass
+    # cleanup
+    for f in (audio_wav, audio_output, video_output):
+        try: os.remove(f)
+        except: pass
 
-    await progress(1.0)
-    return None, merged_output
+    return None, merged
 
-async def process_conversion(use_youtube, youtube_url, video_file, downscale, faster, use_mp3, audio_only, custom_bitrate, video_bitrate, progress=gr.Progress()):
-    try:
+async def process_conversion(use_youtube, youtube_url, video_file, downscale, faster,
+                             use_mp3, audio_only, custom_bitrate, video_bitrate,
+                             progress=gr.Progress()):
+    with progress.tqdm(total=5) as pbar:
+        # Step 1: fetch
         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")
-            await progress(0, desc="Downloading from YouTube...")
-            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)
-            if not files:
-                return "Download failed.", None
+            pbar.update(1, desc="Downloading video...")
+            yt_uuid = uuid.uuid4().hex
+            out = os.path.join(UPLOAD_FOLDER, yt_uuid + ".%(ext)s")
+            await run_subprocess(['yt-dlp','-o',out,'-f','b',youtube_url])
+            files = glob.glob(os.path.join(UPLOAD_FOLDER, yt_uuid + ".*"))
+            if not files: return "Download failed.", None
             input_path = files[0]
         else:
-            if not video_file:
-                return "No video provided.", None
-            ext = os.path.splitext(video_file.name)[1]
-            input_path = os.path.join(UPLOAD_FOLDER, f"{uuid.uuid4()}{ext}")
-            shutil.copy2(video_file.name, input_path)
-
+            pbar.update(1, desc="Preparing input video...")
+            fname = video_file.name
+            ext = os.path.splitext(fname)[1]
+            input_path = os.path.join(UPLOAD_FOLDER, uuid.uuid4().hex + ext)
+            shutil.copy2(fname, input_path)
+
+        # Step 2–5: convert
+        if use_mp3:
+            pbar.update(1, desc="Converting audio to MP3...")
+        else:
+            pbar.update(1, desc="Converting audio to AAC which is lower quality...")
         audio_out, video_out = await convert_video_task(
-            input_path, downscale, faster, use_mp3, audio_only, custom_bitrate, video_bitrate, progress
+            input_path, downscale, faster, use_mp3, audio_only,
+            custom_bitrate, video_bitrate, pbar
         )
 
+        # final update
+        pbar.update(1, desc="Finalizing...")
+
         if audio_only:
             return audio_out, audio_out
         return video_out, video_out
-    except Exception as e:
-        return f"Error: {str(e)}", None
 
-# Gradio Interface
+# Build UI
 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 to your liking.
-    """)
-
-    with gr.Group():
-        with gr.Row():
-            use_youtube = gr.Checkbox(label="🔗 Use YouTube URL (If ran locally, then it works.)", value=False)
-            youtube_url = gr.Textbox(label="YouTube URL", placeholder="Paste YouTube URL here")
-        video_file = gr.File(label="📁 Upload Video File")
-
-    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 (will result in pixelated artifacts)", value=False)
-        with gr.Row():
-            use_mp3 = gr.Checkbox(label="Use MP3 Audio (however AAC sounds lower quality)", value=False)
-            audio_only = gr.Checkbox(label="Audio Only", value=False)
-        with gr.Row():
-            custom_bitrate = gr.Checkbox(label="Custom Video Bitrate", value=False)
-            video_bitrate = gr.Number(label="Bitrate (kbps)", visible=False)
-
-        custom_bitrate.change(
-            lambda checked: gr.update(visible=checked),
-            inputs=[custom_bitrate],
-            outputs=[video_bitrate]
-        )
+    gr.Markdown("# Low Quality Video Inator")
+    with gr.Row():
+        use_youtube = gr.Checkbox(label="Use YouTube URL", value=False)
+        youtube_url = gr.Textbox(label="YouTube URL")
+    video_file = gr.File(label="Upload Video")
+
+    with gr.Row():
+        downscale = gr.Checkbox("Downscale Video to 144p", value=False)
+        faster = gr.Checkbox("Faster Compression", value=False)
+    with gr.Row():
+        use_mp3 = gr.Checkbox("Use MP3 Audio", value=False)
+        audio_only = gr.Checkbox("Audio Only", value=False)
+    with gr.Row():
+        custom_bitrate = gr.Checkbox("Custom Video Bitrate", value=False)
+        video_bitrate = gr.Number(label="Bitrate (kbps)", visible=False)
+        custom_bitrate.change(lambda x: gr.update(visible=x), custom_bitrate, 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")
+    video_preview = gr.Video()
+    file_download = gr.File()
 
     convert_button.click(
         process_conversion,
-        inputs=[
-            use_youtube, youtube_url, video_file,
-            downscale, faster, use_mp3, audio_only,
-            custom_bitrate, video_bitrate
-        ],
+        inputs=[use_youtube, youtube_url, video_file,
+                downscale, faster, use_mp3, audio_only,
+                custom_bitrate, video_bitrate],
         outputs=[video_preview, file_download]
     )