Update app.py

app.py

@@ -1,129 +1,116 @@
 import os
+import asyncio
 import subprocess
 import uuid
 import glob
 import shutil
 import gradio as gr
 
-os.system("chmod +x ffmpeg")
-# Set default acceleration and extra encoding options.
 accel = 'auto'
-extra = '-crf 63 -c:v libx264'  # default extra settings
+video_extra = ['-crf', '63', '-c:v', 'libx264', '-preset', 'ultrafast', '-tune', 'zerolatency']
 
-# Fixed upload and conversion folders.
 UPLOAD_FOLDER = 'uploads'
 CONVERTED_FOLDER = 'converted'
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 os.makedirs(CONVERTED_FOLDER, exist_ok=True)
 
-# Helper function to configure audio options.
-def configure_audio(cmd_list, use_mp3):
-    if use_mp3:
-        cmd_list.extend(['-c:a', 'libmp3lame', '-b:a', '8k', '-ar', '24k', '-ac', '1'])
-    else:
-        cmd_list.extend(['-c:a', 'aac', '-b:a', '1k', '-ar', '8k', '-ac', '1'])
-
-def convert_video(use_youtube, youtube_url, video_file, downscale, faster, use_mp3, audio_only):
-    """
-    Converts a video either from a YouTube URL or an uploaded file.
-    Returns a tuple (preview_file, download_file) with the output path.
-    """
-    # Determine output filename based on whether only audio is desired.
-    if audio_only:
-        output_filename = f"{uuid.uuid4()}.mp3" if use_mp3 else f"{uuid.uuid4()}.aac"
-    else:
-        output_filename = f"{uuid.uuid4()}.mp4"
-    output_path = os.path.join(CONVERTED_FOLDER, output_filename)
-
-    if use_youtube:
-        if not youtube_url:
-            return "Error: YouTube URL is required.", None
-
-        quality = 'worstaudio' if audio_only and downscale else (
-                  'worstvideo+worstaudio' if downscale else 'b')
-
-        yt_uuid = str(uuid.uuid4())
-        yt_input_filename = yt_uuid + ".%(ext)s"
-        yt_input_path = os.path.join(UPLOAD_FOLDER, yt_input_filename)
-        yt_dlp_cmd = ['yt-dlp', '-o', yt_input_path, '-f', quality, youtube_url]
-        try:
-            subprocess.run(yt_dlp_cmd, check=True)
-        except subprocess.CalledProcessError as e:
-            return f"An error occurred during YouTube download: {e}", None
-
-        pattern = os.path.join(UPLOAD_FOLDER, yt_uuid + ".*")
-        downloaded_files = glob.glob(pattern)
-        if not downloaded_files:
-            return "Failed to download YouTube video.", None
-        input_path = downloaded_files[0]
-    else:
-        if not video_file:
-            return "Error: No video file provided.", None
-        if os.path.exists(video_file):
-            ext = os.path.splitext(video_file)[1]
-            input_filename = f"{uuid.uuid4()}{ext}"
-            input_path = os.path.join(UPLOAD_FOLDER, input_filename)
-            shutil.copy2(video_file, input_path)
-        else:
-            input_path = video_file
-
-    # Handle optional downscale first
-    if downscale and not audio_only:
-        downscaled_path = os.path.join(UPLOAD_FOLDER, f"downscaled_{uuid.uuid4()}.mp4")
-        downscale_cmd = ['ffmpeg', '-hwaccel', accel, '-y', '-i', input_path,
-                         '-vf', 'scale=144:-2', '-c:v', 'libx264', '-preset', 'ultrafast', '-crf', '40',
-                         '-c:a', 'copy', downscaled_path]
-        try:
-            subprocess.run(downscale_cmd, check=True)
-        except subprocess.CalledProcessError as e:
-            return f"An error occurred during downscaling: {e}", None
-        input_path = downscaled_path  # Use this for next pass
-
-    # Now do the final encode
-    ffmpeg_cmd = ['./ffmpeg', '-hwaccel', accel, '-y', '-i', input_path] + extra.split()
+async def run_subprocess(cmd):
+    process = await asyncio.create_subprocess_exec(
+        *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+    )
+    stdout, stderr = await process.communicate()
+    if process.returncode != 0:
+        raise subprocess.CalledProcessError(process.returncode, cmd, stderr.decode())
+    return stdout.decode(), stderr.decode()
 
+async def convert_video_task(input_path, downscale, faster, use_mp3):
+    if use_mp3:
+        # Directly compress audio to MP3 with video untouched or skipped
+        output_path = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.mp3")
+        ffmpeg_cmd = ['ffmpeg', '-y', '-i', input_path, '-vn',
+                      '-c:a', 'libmp3lame', '-b:a', '8k', '-ar', '24000', '-ac', '1', output_path]
+        await run_subprocess(ffmpeg_cmd)
+        return output_path, None  # No video output in this case
+
+    # Non-MP3 path: split streams
+    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")
+
+    # Extract mono WAV
+    await run_subprocess([
+        'ffmpeg', '-y', '-i', input_path, '-ac', '1', '-ar', '8000', audio_wav
+    ])
+
+    # Compress with fdkaac
+    await run_subprocess([
+        'fdkaac', '-b', '1k', '-C', '-f', '2', '-G', '1', '-w', '8000',
+        '-o', audio_output, audio_wav
+    ])
+
+    # Video compression
+    video_cmd = ['ffmpeg', '-y', '-hwaccel', accel, '-i', input_path, *video_extra, '-an', video_output]
     if faster:
-        ffmpeg_cmd.extend(['-preset', 'ultrafast'])
+        video_cmd.extend(['-preset', 'ultrafast'])
+    await run_subprocess(video_cmd)
 
-    if audio_only:
-        ffmpeg_cmd.extend(['-vn'])
-    configure_audio(ffmpeg_cmd, use_mp3)
-
-    ffmpeg_cmd.append(output_path)
+    return audio_output, video_output
 
+async def process_conversion(use_youtube, youtube_url, video_file, downscale, faster, use_mp3, audio_only):
     try:
-        subprocess.run(ffmpeg_cmd, check=True)
-    except subprocess.CalledProcessError as e:
-        return f"An error occurred during conversion: {e}", None
+        if use_youtube:
+            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)
+            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)[1]
+            input_path = os.path.join(UPLOAD_FOLDER, f"{uuid.uuid4()}{ext}")
+            shutil.copy2(video_file, input_path)
+
+        audio_out, video_out = await convert_video_task(input_path, downscale, faster, use_mp3)
+
+        if audio_only:
+            return audio_out, audio_out
+        return video_out or audio_out, video_out or audio_out
+    except Exception as e:
+        return str(e), None
 
-    return output_path, output_path
+def convert_video(*args):
+    return asyncio.run(process_conversion(*args))
 
-# Create the Gradio interface.
+# Gradio Interface
 with gr.Blocks() as demo:
     gr.Markdown("## Low Quality Video Inator")
     gr.Markdown("Upload a video or use a YouTube URL and adjust the options below.")
-    
+
     with gr.Row():
-        use_youtube = gr.Checkbox(label="Use YouTube URL (almost never works)", value=False)
-        youtube_url = gr.Textbox(label="YouTube URL", placeholder="Enter YouTube URL here")
+        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(label="Downscale Video (144p)", value=False)
-        faster = gr.Checkbox(label="Faster Conversion (more pixelated)", value=False)
+        faster = gr.Checkbox(label="Faster Conversion", value=False)
     with gr.Row():
-        use_mp3 = gr.Checkbox(label="Use MP3 (video audio compression)", value=False)
-        audio_only = gr.Checkbox(label="Only Audio (no video)", value=False)
-    
-    convert_button = gr.Button("Convert Video")
-    
-    gr.Markdown("### Preview Converted Video")
-    video_preview = gr.Video(label="Converted Video")
-    gr.Markdown("### Download Converted Video")
-    file_download = gr.File(label="Download Video")
-    
+        use_mp3 = gr.Checkbox(label="Use MP3 (skips video compression)", value=False)
+        audio_only = gr.Checkbox(label="Only Audio", value=False)
+
+    convert_button = gr.Button("Convert")
+    gr.Markdown("### Preview")
+    video_preview = gr.Video()
+    gr.Markdown("### Download")
+    file_download = gr.File()
+
     convert_button.click(
-        convert_video, 
+        convert_video,
         inputs=[use_youtube, youtube_url, video_file, downscale, faster, use_mp3, audio_only],
         outputs=[video_preview, file_download]
     )