Update app.py

app.py

@@ -2,40 +2,267 @@ import gradio as gr
 import os
 import subprocess
 import uuid
+import shutil
+import zipfile
+import time
+from datetime import datetime
+import pandas as pd
 
-# Function to compress video using ffmpeg
-def compress_video(video):
-    input_path = f"input_{uuid.uuid4()}.mp4"
-    output_path = f"compressed_{uuid.uuid4()}.mp4"
-
-    # Save uploaded video
-    with open(input_path, "wb") as f:
-        f.write(video.read())
-
-    # FFmpeg command for compression
-    command = [
-        "ffmpeg", "-i", input_path,
-        "-vcodec", "libx264", "-crf", "28",  # CRF controls quality (lower = better quality)
-        "-preset", "fast",
-        output_path
+# Ensure output directory exists
+OUTPUT_DIR = "outputs"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def map_level_to_crf(level: str) -> int:
+    """
+    Map user-friendly compression levels to FFmpeg CRF values.
+    Lower CRF = higher quality, higher file size.
+    """
+    level = (level or "Medium").strip().lower()
+    if level == "low":        # Low compression (better quality)
+        return 22
+    elif level == "high":     # High compression (smaller size)
+        return 32
+    else:                     # Medium (default)
+        return 28
+
+def ffmpeg_available() -> bool:
+    try:
+        subprocess.run(["ffmpeg", "-version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
+        return True
+    except Exception:
+        return False
+
+def compress_single_video(
+    infile_path: str,
+    crf: int,
+    preset: str = "fast",
+    audio_bitrate_kbps: int = 128,
+    progress: gr.Progress | None = None
+) -> tuple[str, int, int]:
+    """
+    Compress a single MP4 using ffmpeg (H.264, AAC).
+    Returns: (output_path, original_size_bytes, compressed_size_bytes)
+    """
+    # Build output filename
+    base = os.path.basename(infile_path)
+    name, ext = os.path.splitext(base)
+    out_name = f"{name}_compressed_{uuid.uuid4().hex[:8]}.mp4"
+    out_path = os.path.join(OUTPUT_DIR, out_name)
+
+    original_size = os.path.getsize(infile_path)
+
+    # FFmpeg command
+    # -crf controls quality (18-28 typical; 32 more aggressive)
+    # -preset trades encode speed vs compression efficiency
+    # Audio is encoded to AAC with specified bitrate
+    cmd = [
+        "ffmpeg", "-y",
+        "-i", infile_path,
+        "-vcodec", "libx264",
+        "-crf", str(crf),
+        "-preset", preset,
+        "-acodec", "aac", "-b:a", f"{audio_bitrate_kbps}k",
+        out_path
     ]
-    subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 
-    os.remove(input_path)  # Clean up original file
-    return output_path
+    # Progress: start
+    if progress is not None:
+        progress(0.2, desc=f"Compressing {base} (CRF {crf}, preset {preset})")
+
+    # Run ffmpeg
+    proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if proc.returncode != 0:
+        # Surface ffmpeg error
+        raise RuntimeError(
+            f"FFmpeg failed on {base}.\n\nSTDERR:\n{proc.stderr.decode(errors='ignore')}\n\nSTDOUT:\n{proc.stdout.decode(errors='ignore')}"
+        )
+
+    compressed_size = os.path.getsize(out_path)
+
+    if progress is not None:
+        progress(0.95, desc=f"Finalizing {base}")
+
+    return out_path, original_size, compressed_size
+
+def validate_inputs(files: list) -> list[str]:
+    """
+    Validate and normalize input files into local paths.
+    """
+    if not files or len(files) == 0:
+        raise gr.Error("Please upload at least one MP4 file.")
+
+    # Gradio returns objects with .name when using gr.Files
+    paths = []
+    for f in files:
+        # f can be a tempfile-like object or a dict depending on Gradio version
+        path = getattr(f, "name", None) or (isinstance(f, dict) and f.get("name")) or None
+        if not path:
+            raise gr.Error("Could not read uploaded file path.")
+        if not path.lower().endswith(".mp4"):
+            raise gr.Error(f"Unsupported file type: {os.path.basename(path)}. Please upload .mp4 only.")
+        paths.append(path)
+    return paths
+
+def compress_videos(
+    files,
+    level: str,
+    use_advanced: bool,
+    crf_value: int,
+    preset: str,
+    audio_bitrate_kbps: int,
+    progress: gr.Progress = gr.Progress()
+):
+    """
+    Main handler for multi-file compression with progress and reporting.
+    Returns:
+      - zip_path: ZIP containing all compressed videos + CSV report
+      - summary_df: DataFrame with per-file stats
+      - out_files: list of compressed file paths (for direct downloads)
+    """
+    # Quick check for ffmpeg
+    if not ffmpeg_available():
+        raise gr.Error(
+            "FFmpeg is not available in this environment. "
+            "Please ensure 'ffmpeg' is installed via packages.txt."
+        )
+
+    input_paths = validate_inputs(files)
+
+    total_files = len(input_paths)
+    progress(0, desc=f"Starting compression for {total_files} file(s)…")
+
+    # Resolve CRF
+    crf = crf_value if use_advanced else map_level_to_crf(level or "Medium")
+    # Resolve preset
+    preset = preset or "fast"
+    audio_bitrate_kbps = max(64, int(audio_bitrate_kbps or 128))
+
+    # Prepare report
+    records = []
+    compressed_paths = []
+
+    # Process files sequentially with coarse progress
+    for idx, in_path in enumerate(input_paths, start=1):
+        base = os.path.basename(in_path)
+        try:
+            progress(
+                (idx - 1) / total_files,
+                desc=f"[{idx}/{total_files}] Preparing {base}"
+            )
+            out_path, orig_size, comp_size = compress_single_video(
+                infile_path=in_path,
+                crf=crf,
+                preset=preset,
+                audio_bitrate_kbps=audio_bitrate_kbps,
+                progress=progress
+            )
+            reduction_bytes = orig_size - comp_size
+            reduction_pct = (reduction_bytes / orig_size * 100.0) if orig_size > 0 else 0.0
+            records.append({
+                "File": base,
+                "Original Size (MB)": round(orig_size / (1024 * 1024), 3),
+                "Compressed Size (MB)": round(comp_size / (1024 * 1024), 3),
+                "Size Reduced (MB)": round(reduction_bytes / (1024 * 1024), 3),
+                "Reduction (%)": round(reduction_pct, 2),
+                "Output": os.path.basename(out_path)
+            })
+            compressed_paths.append(out_path)
+            progress(
+                idx / total_files,
+                desc=f"[{idx}/{total_files}] Completed {base} (↓ {round(reduction_pct,2)}%)"
+            )
+        except Exception as e:
+            # Log failure in report
+            records.append({
+                "File": base,
+                "Original Size (MB)": None,
+                "Compressed Size (MB)": None,
+                "Size Reduced (MB)": None,
+                "Reduction (%)": None,
+                "Output": f"ERROR: {str(e).splitlines()[0][:180]}"
+            })
+
+    # Build summary dataframe
+    df = pd.DataFrame.from_records(records)
+
+    # Save CSV report
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    report_name = f"compression_report_{timestamp}.csv"
+    report_path = os.path.join(OUTPUT_DIR, report_name)
+    df.to_csv(report_path, index=False)
+
+    # Create ZIP bundle of outputs + report
+    zip_name = f"compressed_bundle_{timestamp}.zip"
+    zip_path = os.path.join(OUTPUT_DIR, zip_name)
+    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        # Add report
+        zf.write(report_path, arcname=report_name)
+        # Add each compressed video
+        for p in compressed_paths:
+            zf.write(p, arcname=os.path.basename(p))
+
+    # Final progress
+    progress(1.0, desc="All done! Download your results below.")
+
+    # Return ZIP (for one-click download), summary table, and individual files (for selective downloads)
+    return zip_path, df, compressed_paths
 
-# Gradio UI
 with gr.Blocks() as demo:
-    gr.Markdown("# 🎥 MP4 Video Compressor")
-    gr.Markdown("Upload an MP4 video, compress it, and download the result.")
+    gr.Markdown("# 🎥 MP4 Video Compressor (Multi-file)")
+    gr.Markdown(
+        "Upload one or more MP4s, choose compression level, and get the compressed files.\n"
+        "Includes a progress bar and a CSV summary (sizes & reduction)."
+    )
 
     with gr.Row():
         with gr.Column():
-            video_input = gr.File(label="Upload MP4 Video", file_types=[".mp4"])
-            compress_button = gr.Button("Compress Video")
+            files_in = gr.Files(
+                label="Upload MP4 Videos",
+                file_count="multiple",
+                file_types=[".mp4"],
+                height=120
+            )
+
+            # Simple compression level
+            level = gr.Radio(
+                label="Compression Level",
+                choices=["Low", "Medium", "High"],
+                value="Medium",
+                info="Low = best quality, High = smallest files"
+            )
+
+            with gr.Accordion("Advanced Options (optional)", open=False):
+                use_adv = gr.Checkbox(label="Use advanced settings", value=False)
+                crf_val = gr.Slider(
+                    minimum=18, maximum=36, step=1, value=28, label="CRF (Quality/Compression)"
+                )
+                preset = gr.Dropdown(
+                    label="FFmpeg Preset",
+                    choices=["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"],
+                    value="fast",
+                    allow_custom_value=False
+                )
+                audio_bitrate = gr.Slider(
+                    minimum=64, maximum=320, step=16, value=128, label="Audio Bitrate (kbps)"
+                )
+
+            run_btn = gr.Button("🔄 Compress", variant="primary")
+
         with gr.Column():
-            output_video = gr.File(label="Download Compressed Video")
+            zip_out = gr.File(label="Download ZIP (compressed videos + CSV report)")
+            summary = gr.Dataframe(
+                label="Compression Summary",
+                interactive=False,
+                wrap=True,
+                height=260
+            )
+            files_out = gr.Files(label="Download Individual Compressed Files")
 
-    compress_button.click(fn=compress_video, inputs=video_input, outputs=output_video)
+    run_btn.click(
+        fn=compress_videos,
+        inputs=[files_in, level, use_adv, crf_val, preset, audio_bitrate],
+        outputs=[zip_out, summary, files_out]
+    )
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch()