Update app.py

app.py

@@ -0,0 +1,474 @@
+import gradio as gr
+import subprocess
+import os
+import shutil
+import json
+import threading
+import random
+import string
+import time
+import multiprocessing
+
+CPU_THREADS = str(multiprocessing.cpu_count())
+
+BASE_DIR = os.path.join(os.getcwd(), "job_data")
+JOBS_FILE = os.path.join(BASE_DIR, "jobs.json")
+os.makedirs(BASE_DIR, exist_ok=True)
+
+_lock = threading.Lock()
+HISTORY_TTL_SECONDS = 5 * 60 * 60  # 5 ghante
+
+# ---------- BGM file path (server par permanently) ----------
+BGM_FILE = None
+for ext in [".mp4", ".mp3", ".m4a", ".wav"]:
+    potential = os.path.join(os.getcwd(), f"bgm{ext}")
+    if os.path.exists(potential):
+        BGM_FILE = potential
+        break
+
+# ---------- Storage helpers ----------
+def _load_jobs():
+    if not os.path.exists(JOBS_FILE):
+        return {}
+    try:
+        with open(JOBS_FILE, "r") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+def _save_jobs(jobs):
+    with open(JOBS_FILE, "w") as f:
+        json.dump(jobs, f, indent=2)
+
+def _add_task(code, task):
+    with _lock:
+        jobs = _load_jobs()
+        jobs.setdefault(code, []).append(task)
+        _save_jobs(jobs)
+
+def _update_task(code, task_id, **kwargs):
+    with _lock:
+        jobs = _load_jobs()
+        for t in jobs.get(code, []):
+            if t["id"] == task_id:
+                t.update(kwargs)
+        _save_jobs(jobs)
+
+def _get_task(code, task_id):
+    jobs = _load_jobs()
+    for t in jobs.get(code, []):
+        if t["id"] == task_id:
+            return t
+    return None
+
+def _cleanup_old_tasks():
+    """5 ghante se purani tasks hata do (data + entry dono)."""
+    with _lock:
+        jobs = _load_jobs()
+        now = time.time()
+        changed = False
+        for code in list(jobs.keys()):
+            kept = []
+            for t in jobs[code]:
+                if now - t.get("created_ts", now) < HISTORY_TTL_SECONDS:
+                    kept.append(t)
+                else:
+                    changed = True
+                    task_dir = os.path.join(BASE_DIR, code, t["id"])
+                    shutil.rmtree(task_dir, ignore_errors=True)
+            if kept:
+                jobs[code] = kept
+            else:
+                del jobs[code]
+                changed = True
+        if changed:
+            _save_jobs(jobs)
+
+def random_code():
+    return "".join(random.choices(string.ascii_uppercase + string.digits, k=6))
+
+# ---------- Video helpers ----------
+RES_MAP = {
+    "480p (sabse fast)": (854, 480),
+    "720p (balanced)": (1280, 720),
+    "1080p (best quality, slow)": (1920, 1080),
+}
+
+def get_duration(path):
+    try:
+        out = subprocess.run(
+            ["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", path],
+            capture_output=True, text=True
+        )
+        return max(0.1, float(out.stdout.strip()))
+    except Exception:
+        return 0.1
+
+def build_audio_filter():
+    """Halka audio variation — pitch/EQ/echo. Sirf sound texture ke liye, fingerprint-evasion tool nahi hai."""
+    pitch_shift = random.uniform(0.98, 1.02)
+    eq_freq = random.choice([200, 500, 1000, 3000])
+    eq_gain = random.uniform(-1.5, 1.5)
+    filters = [
+        f"asetrate=44100*{pitch_shift},aresample=44100",
+        f"equalizer=f={eq_freq}:t=q:w=1:g={eq_gain:.2f}",
+        f"aecho=0.5:0.3:6:0.1",
+    ]
+    return ",".join(filters)
+
+
+def run_ffmpeg_with_progress(cmd, code, task_id, total_duration, base_pct, weight_pct, fps_hint=""):
+    cmd = [cmd[0], "-y", "-progress", "pipe:1", "-nostats"] + cmd[2:]
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                             text=True, bufsize=1)
+    error_lines = []
+    last_write = 0
+    out_time_sec = 0.0
+    speed_val = 0.0
+    fps_val = 0.0
+
+    for line in proc.stdout:
+        line = line.strip()
+        if "=" in line:
+            key, _, val = line.partition("=")
+            if key == "out_time_ms":
+                try:
+                    out_time_sec = int(val) / 1_000_000
+                except ValueError:
+                    pass
+            elif key == "speed":
+                try:
+                    speed_val = float(val.replace("x", "").strip())
+                except ValueError:
+                    speed_val = 0.0
+            elif key == "fps":
+                try:
+                    fps_val = float(val)
+                except ValueError:
+                    pass
+        else:
+            error_lines.append(line)
+
+        now = time.time()
+        if now - last_write > 0.6:
+            local_pct = min(99, (out_time_sec / total_duration) * 100) if total_duration > 0 else 0
+            overall_pct = round(base_pct + (weight_pct * local_pct / 100), 1)
+            remaining = max(0, total_duration - out_time_sec)
+            eta = round(remaining / speed_val, 1) if speed_val > 0 else None
+            _update_task(code, task_id, progress=overall_pct, speed=round(speed_val, 2),
+                         fps=round(fps_val, 1), eta_seconds=eta,
+                         elapsed=round(out_time_sec, 1), total_dur=round(total_duration, 1),
+                         status="processing")
+            last_write = now
+
+    proc.wait()
+    return proc.returncode == 0, "\n".join(error_lines[-15:])
+
+
+def do_merge(video1, video2, resize_mode, resolution_choice, change_audio_dna, bgm_volume, work_dir, output_path, code, task_id):
+    try:
+        d1 = get_duration(video1)
+        d2 = get_duration(video2)
+        total = d1 + d2
+
+        if resize_mode == "Fast (same resolution/codec required)" and not change_audio_dna and not BGM_FILE:
+            list_file = os.path.join(work_dir, "list.txt")
+            with open(list_file, "w") as f:
+                f.write(f"file '{video1}'\n")
+                f.write(f"file '{video2}'\n")
+
+            cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file, "-c", "copy", output_path]
+            ok, err = run_ffmpeg_with_progress(cmd, code, task_id, total, 0, 100)
+            if ok:
+                return True, "Merge ho gaya (fast copy mode)"
+
+        norm1 = os.path.join(work_dir, "norm1.mp4")
+        norm2 = os.path.join(work_dir, "norm2.mp4")
+        target_w, target_h = RES_MAP.get(resolution_choice, (1280, 720))
+
+        w1 = (d1 / total * 90) if total > 0 else 45
+        w2 = 90 - w1
+
+        for src, dst, base, weight, dur in [
+            (video1, norm1, 0, w1, d1),
+            (video2, norm2, w1, w2, d2),
+        ]:
+            audio_filter_str = "aresample=44100"
+            if change_audio_dna:
+                audio_filter_str = build_audio_filter()
+
+            cmd = [
+                "ffmpeg", "-y", "-threads", CPU_THREADS, "-i", src,
+                "-vf", f"scale={target_w}:{target_h}:force_original_aspect_ratio=decrease:flags=fast_bilinear,"
+                       f"pad={target_w}:{target_h}:(ow-iw)/2:(oh-ih)/2,setsar=1",
+                "-af", audio_filter_str,
+                "-r", "30",
+                "-c:v", "libx264", "-preset", "ultrafast", "-crf", "26",
+                "-c:a", "aac", "-b:a", "128k", "-ar", "44100", "-ac", "2",
+                dst
+            ]
+            ok, err = run_ffmpeg_with_progress(cmd, code, task_id, dur, base, weight)
+            if not ok:
+                return False, f"Normalize error: {err}"
+
+        _update_task(code, task_id, progress=95)
+
+        # Merge normalized videos first
+        list_file = os.path.join(work_dir, "list2.txt")
+        with open(list_file, "w") as f:
+            f.write(f"file '{norm1}'\n")
+            f.write(f"file '{norm2}'\n")
+
+        merged_video = os.path.join(work_dir, "merged_temp.mp4")
+        cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", list_file, "-c", "copy", merged_video]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            return False, f"Merge error: {result.stderr[-400:]}"
+
+        # Add BGM if server par BGM file exist karta hai
+        if BGM_FILE:
+            bgm_loop = os.path.join(work_dir, "bgm_loop.mp3")
+            # Loop BGM to match video duration
+            loop_cmd = [
+                "ffmpeg", "-y", "-i", BGM_FILE,
+                "-filter_complex", f"aloop=loop=-1:size=2e9,atrim=0:{total}",
+                "-c:a", "mp3", "-b:a", "128k", bgm_loop
+            ]
+            subprocess.run(loop_cmd, capture_output=True, text=True)
+
+            # Mix BGM with video audio
+            vol = max(0, min(1, float(bgm_volume or 0.5)))
+            final_cmd = [
+                "ffmpeg", "-y", "-i", merged_video, "-i", bgm_loop,
+                "-filter_complex", f"[0:a]volume=1.0[a0];[1:a]volume={vol}[a1];[a0][a1]amix=inputs=2:duration=longest",
+                "-c:v", "copy", "-c:a", "aac", "-b:a", "192k", output_path
+            ]
+            subprocess.run(final_cmd, capture_output=True, text=True)
+        else:
+            shutil.copy(merged_video, output_path)
+
+        dna_note = " + audio thoda change kiya" if change_audio_dna else ""
+        bgm_note = " + BGM add kiya" if BGM_FILE else ""
+        return True, f"Merge ho gaya!{dna_note}{bgm_note}"
+
+    except Exception as e:
+        return False, f"Error: {str(e)}"
+
+
+def run_job_background(code, task_id, v1_saved, v2_saved, resize_mode, resolution_choice, change_audio_dna, bgm_volume, out_name):
+    task_dir = os.path.join(BASE_DIR, code, task_id)
+    output_path = os.path.join(task_dir, out_name)
+    try:
+        ok, msg = do_merge(v1_saved, v2_saved, resize_mode, resolution_choice, change_audio_dna, bgm_volume, task_dir, output_path, code, task_id)
+        if ok and os.path.exists(output_path):
+            size_mb = round(os.path.getsize(output_path) / (1024 * 1024), 2)
+            _update_task(code, task_id, status="done", message=msg, output=output_path, progress=100,
+                         size_mb=size_mb, finished_ts=time.time())
+        else:
+            _update_task(code, task_id, status="error", message=msg, finished_ts=time.time())
+    except Exception as e:
+        _update_task(code, task_id, status="error", message=f"Error: {str(e)}", finished_ts=time.time())
+
+
+def submit_job(video1, video2, resize_mode, resolution_choice, change_audio_dna, bgm_volume, custom_code):
+    _cleanup_old_tasks()
+
+    if video1 is None or video2 is None:
+        return "❌ Dono videos upload karo pehle!", ""
+
+    code = (custom_code or "").strip().upper()
+    code = "".join(c for c in code if c.isalnum())[:20]
+    if not code:
+        code = random_code()
+
+    task_id = "".join(random.choices(string.ascii_lowercase + string.digits, k=8))
+    task_dir = os.path.join(BASE_DIR, code, task_id)
+    os.makedirs(task_dir, exist_ok=True)
+
+    v1_saved = os.path.join(task_dir, "input1" + os.path.splitext(video1)[1])
+    v2_saved = os.path.join(task_dir, "input2" + os.path.splitext(video2)[1])
+    shutil.copy(video1, v1_saved)
+    shutil.copy(video2, v2_saved)
+
+    out_name = f"output_{task_id}.mp4"
+    display_name = os.path.basename(video1)
+
+    task = {
+        "id": task_id, "status": "queued", "message": "Queue me hai...",
+        "progress": 0, "speed": 0, "fps": 0, "eta_seconds": None,
+        "elapsed": 0, "total_dur": 0, "size_mb": None,
+        "display_name": display_name, "audio_dna": change_audio_dna,
+        "created_ts": time.time(), "created_at": time.strftime("%H:%M:%S"),
+        "output": None,
+    }
+    _add_task(code, task)
+
+    t = threading.Thread(
+        target=run_job_background,
+        args=(code, task_id, v1_saved, v2_saved, resize_mode, resolution_choice, change_audio_dna, bgm_volume, out_name),
+        daemon=True
+    )
+    t.start()
+
+    return (f"✅ Queue mein add hua! Task ID: **{task_id}**\n\n"
+            f"Job Code: **{code}** — isi code se dobara bhi submit kar sakta hai, "
+            f"aur isi code se status/history bhi check hoga."), code
+
+
+def progress_badge_html(pct, status):
+    pct = max(0, min(100, pct or 0))
+    if status == "done":
+        return f'<span style="background:#16a34a;color:white;padding:4px 12px;border-radius:14px;font-weight:bold;">✅ Done</span>'
+    elif status == "error":
+        return f'<span style="background:#dc2626;color:white;padding:4px 12px;border-radius:14px;font-weight:bold;">❌ Error</span>'
+    elif status == "queued":
+        return f'<span style="background:#6b7280;color:white;padding:4px 12px;border-radius:14px;font-weight:bold;">⏳ Queued</span>'
+    else:
+        return f'<span style="background:#2563eb;color:white;padding:4px 12px;border-radius:14px;font-weight:bold;">⚙️ {pct}%</span>'
+
+
+def render_task_card(t):
+    badge = progress_badge_html(t.get("progress", 0), t.get("status"))
+    name = t.get("display_name", "video.mp4")
+    when = t.get("created_at", "")
+    dna_tag = ' <span style="color:#818cf8;">🎵 Audio changed</span>' if t.get("audio_dna") else ""
+
+    detail = ""
+    if t.get("status") == "processing":
+        speed = t.get("speed", 0)
+        fps = t.get("fps", 0)
+        elapsed = t.get("elapsed", 0)
+        total_dur = t.get("total_dur", 0)
+        eta = t.get("eta_seconds")
+        eta_txt = f"{int(eta)}s" if eta is not None else "..."
+        detail = (f'<div style="color:#9ca3af;font-family:monospace;margin-top:4px;">'
+                   f'⚡ {t.get("progress",0)}% | {elapsed}s/{total_dur}s | Speed: {speed}x | FPS: {fps} | ETA: {eta_txt}'
+                   f'</div>')
+    elif t.get("status") == "done":
+        size = t.get("size_mb", "?")
+        detail = f'<div style="color:#9ca3af;">Size: {size} MB</div>'
+    elif t.get("status") == "error":
+        detail = f'<div style="color:#f87171;">{t.get("message","")}</div>'
+
+    return f"""
+    <div style="background:#1a1a2e;border-radius:10px;padding:14px;margin-bottom:10px;">
+      <div style="display:flex;align-items:center;gap:10px;">
+        {badge}
+        <span style="color:white;font-family:monospace;font-size:16px;">{name}</span>
+      </div>
+      <div style="color:#6b7280;font-size:12px;margin-top:4px;">{when}</div>
+      {dna_tag}
+      {detail}
+    </div>
+    """
+
+
+def check_status(code):
+    if not code or not code.strip():
+        return "⚠️ Code daalo pehle", "", None
+    code = "".join(c for c in code.strip().upper() if c.isalnum())
+    jobs = _load_jobs()
+    tasks = jobs.get(code, [])
+    if not tasks:
+        return f"❌ Code '{code}' ke liye koi task nahi mila.", "", None
+
+    tasks_sorted = sorted(tasks, key=lambda t: t.get("created_ts", 0), reverse=True)
+    queued = sum(1 for t in tasks if t.get("status") == "queued")
+    processing = sum(1 for t in tasks if t.get("status") == "processing")
+    done = sum(1 for t in tasks if t.get("status") == "done")
+    error = sum(1 for t in tasks if t.get("status") == "error")
+
+    summary = f"📊 **{code}** — Queue: {queued} waiting | {processing} processing | {done} done | {error} error"
+    cards_html = "".join(render_task_card(t) for t in tasks_sorted)
+
+    latest_done = next((t for t in tasks_sorted if t.get("status") == "done" and t.get("output")), None)
+    video_out = latest_done["output"] if latest_done else None
+
+    return summary, cards_html, video_out
+
+
+def get_history():
+    _cleanup_old_tasks()
+    jobs = _load_jobs()
+    if not jobs:
+        return "Abhi tak koi job nahi hai. (History 5 ghante baad auto-delete ho jati hai)"
+    rows = ["| Code | Waiting | Processing | Done | Error |", "|------|---------|-----------|------|-------|"]
+    for code, tasks in jobs.items():
+        q = sum(1 for t in tasks if t.get("status") == "queued")
+        p = sum(1 for t in tasks if t.get("status") == "processing")
+        d = sum(1 for t in tasks if t.get("status") == "done")
+        e = sum(1 for t in tasks if t.get("status") == "error")
+        rows.append(f"| {code} | {q} | {p} | {d} | {e} |")
+    rows.append("\n_History 5 ghante baad automatically delete ho jati hai._")
+    return "\n".join(rows)
+
+
+# ---------- UI ----------
+with gr.Blocks(title="Video Merger - 2 Videos Jodo") as demo:
+    gr.Markdown("# 🎬 Video Merger\nDo videos upload karo, background me merge hoga — tab band karo chahe!")
+
+    with gr.Tab("🔗 Queue Mein Add Karo"):
+        with gr.Row():
+            video1_input = gr.Video(label="Pehla Video")
+            video2_input = gr.Video(label="Dusra Video")
+
+        bgm_volume = gr.Slider(
+            minimum=0.0, maximum=1.0, value=0.5, step=0.05,
+            label="BGM Volume (0.0 = mute, 1.0 = full) — server par bgm.mp4/bgm.mp3 hona chahiye"
+        )
+        if BGM_FILE:
+            gr.Markdown(f"✅ Server par BGM file mil gaya: `{os.path.basename(BGM_FILE)}` — auto-apply hoga!")
+        else:
+            gr.Markdown("⚠️ Server par koi BGM file nahi mili. `bgm.mp4` ya `bgm.mp3` upload karo app ke saath.")
+
+        resize_mode = gr.Radio(
+            choices=["Fast (same resolution/codec required)", "Safe (auto resize + re-encode, thoda slow)"],
+            value="Fast (same resolution/codec required)",
+            label="Mode"
+        )
+        resolution_choice = gr.Radio(
+            choices=list(RES_MAP.keys()),
+            value="480p (sabse fast)",
+            label="Resolution (sirf Safe mode ke liye)"
+        )
+        change_audio_dna = gr.Checkbox(
+            label="🎵 Audio thoda change karo (pitch/EQ/echo — halka variation)",
+            value=False
+        )
+        custom_code_input = gr.Textbox(
+            label="Job Code (naya banao ya purana daalo — usi code pe bar-bar submit kar sakta hai)",
+            placeholder="jaise: DEEPU01"
+        )
+
+        submit_btn = gr.Button("➕ Queue Mein Add Karo", variant="primary")
+        submit_status = gr.Markdown()
+        code_box = gr.Textbox(label="Tera Job Code (save kar le, dobara isi se submit/status check kar sakta hai)", interactive=False)
+
+        submit_btn.click(
+            fn=submit_job,
+            inputs=[video1_input, video2_input, resize_mode, resolution_choice, change_audio_dna, bgm_volume, custom_code_input],
+            outputs=[submit_status, code_box]
+        )
+
+    with gr.Tab("📋 Task History & Downloads"):
+        gr.Markdown("Apna Job Code daalo — live digital meter, sab tasks ki history aur download yahin milega.\n\n_(History 5 ghante baad auto-delete ho jati hai)_")
+        code_input = gr.Textbox(label="Job Code")
+        check_btn = gr.Button("🔄 Refresh History", variant="primary")
+        status_output = gr.Markdown()
+        cards_output = gr.HTML()
+        result_video = gr.Video(label="Latest Ready Video")
+
+        check_btn.click(fn=check_status, inputs=[code_input], outputs=[status_output, cards_output, result_video])
+
+        timer = gr.Timer(2.0, active=True)
+        timer.tick(fn=check_status, inputs=[code_input], outputs=[status_output, cards_output, result_video])
+
+    with gr.Tab("📜 Sabki History"):
+        gr.Markdown("Sabhi codes ki summary (5 ghante ke andar wali)")
+        history_output = gr.Markdown()
+        refresh_all_btn = gr.Button("🔄 Refresh")
+        refresh_all_btn.click(fn=get_history, inputs=[], outputs=[history_output])
+        demo.load(fn=get_history, inputs=[], outputs=[history_output])
+
+if __name__ == "__main__":
+    demo.launch()