Update app.py

app.py

@@ -6,7 +6,7 @@ import glob
 import shutil
 import gradio as gr
 
-os.system("chmod +x fdkaac")  # Ensure fdkaac is executable
+os.system("chmod +x fdkaac")  # Make sure fdkaac is executable
 
 accel = 'auto'
 video_base_opts = ['-crf', '63', '-c:v', 'libx264', '-tune', 'zerolatency']
@@ -20,6 +20,7 @@ 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,
@@ -28,140 +29,164 @@ 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):
+async def convert_video_task(input_path, downscale, faster, use_mp3, audio_only, custom_bitrate, video_bitrate):
     if use_mp3:
-        progress.update(1, desc="Converting audio to MP3...")
         output_audio = os.path.join(CONVERTED_FOLDER, f"{uuid.uuid4()}.mp3")
-        cmd = [
+        ffmpeg_audio_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:
-            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")
-    await run_subprocess(['ffmpeg','-y','-i',input_path,'-ac','1','-ar','8000',audio_wav])
+            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
+            ]
+            await run_subprocess(ffmpeg_video_cmd)
+            return None, output_video
 
-    # AAC encode
-    progress.update(1, desc="Converting audio to AAC which is lower quality...")
+    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([ './fdkaac','-b','1k','-C','-f','2','-G','1','-w','8000','-o',audio_output,audio_wav ], use_fdkaac=True)
-
-    # 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]
+
+    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:
-        cmd += ['-vf','scale=-2:144']
+        video_cmd += ['-vf', 'scale=-2:144']
     if custom_bitrate:
-        cmd += ['-b:v',f"{int(video_bitrate)}k"]
+        video_cmd += ['-b:v', f"{int(video_bitrate)}k"]
     else:
-        cmd += video_base_opts
+        video_cmd += video_base_opts
         if faster:
-            cmd += ['-preset','ultrafast']
-    cmd += ['-an',video_output]
-    await run_subprocess(cmd)
+            video_cmd.extend(['-preset', 'ultrafast'])
+    video_cmd += ['-an', video_output]
+    await run_subprocess(video_cmd)
 
     if audio_only:
         return audio_output, None
 
-    # 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])
+    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
+    ])
 
-    # cleanup
-    for f in (audio_wav, audio_output, video_output):
-        try: os.remove(f)
-        except: pass
+    for f in [audio_wav, audio_output, video_output]:
+        try:
+            os.remove(f)
+        except FileNotFoundError:
+            pass
 
-    return None, merged
+    return None, merged_output
 
-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
+async def process_conversion(use_youtube, youtube_url, video_file, downscale, faster, use_mp3, audio_only, custom_bitrate, video_bitrate):
+    try:
         if use_youtube:
-            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
+            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)
+            if not files:
+                return "Download failed.", None
             input_path = files[0]
         else:
-            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...")
+            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)
+
         audio_out, video_out = await convert_video_task(
-            input_path, downscale, faster, use_mp3, audio_only,
-            custom_bitrate, video_bitrate, pbar
+            input_path, downscale, faster, use_mp3, audio_only, custom_bitrate, video_bitrate
         )
 
-        # 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
+
+def convert_video(*args):
+    return asyncio.run(process_conversion(*args))
 
-# Build UI
 with gr.Blocks(theme=gr.themes.Default(primary_hue="rose")) as demo:
-    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)
+    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")
+
+    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, worse 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")
-    video_preview = gr.Video()
-    file_download = gr.File()
+
+    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(
-        process_conversion,
-        inputs=[use_youtube, youtube_url, video_file,
-                downscale, faster, use_mp3, audio_only,
-                custom_bitrate, video_bitrate],
+        convert_video,
+        inputs=[
+            use_youtube, youtube_url, video_file,
+            downscale, faster, use_mp3, audio_only,
+            custom_bitrate, video_bitrate
+        ],
         outputs=[video_preview, file_download]
     )