Add video quality selector

app.py

@@ -1,977 +1,142 @@
 import gradio as gr
-import os
 import cv2
 import numpy as np
-import shutil
-import subprocess
-import time
-from SinglePhoto import FaceSwapper
-import argparse
-
-wellcomingMessage = """
-    <h1>Face Swapping Suite</h1>
-    <p>All-in-one face swapping: single photo, video, multi-source, and multi-destination!</p>
-"""
-
-swapper = FaceSwapper()
-
-#Photo Swapping Functions
-def swap_single_photo(src_img, src_idx, dst_img, dst_idx, progress=gr.Progress(track_tqdm=True)):
-    log = ""
-    start_time = time.time()
-    try:
-        progress(0, desc="Preparing files")
-        src_path = "SinglePhoto/data_src.jpg"
-        dst_path = "SinglePhoto/data_dst.jpg"
-        output_path = "SinglePhoto/output_swapped.jpg"
-        os.makedirs(os.path.dirname(src_path), exist_ok=True)
-        os.makedirs(os.path.dirname(dst_path), exist_ok=True)
-        os.makedirs(os.path.dirname(output_path), exist_ok=True)
-        src_img_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
-        dst_img_bgr = cv2.cvtColor(dst_img, cv2.COLOR_RGB2BGR)
-        cv2.imwrite(src_path, src_img_bgr)
-        cv2.imwrite(dst_path, dst_img_bgr)
-        log += f"Saved source to {src_path}, destination to {dst_path}\n"
-        progress(0.5, desc="Swapping faces")
-        result = swapper.swap_faces(src_path, int(src_idx), dst_path, int(dst_idx))
-        cv2.imwrite(output_path, result)
-        log += f"Swapped and saved result to {output_path}\n"
-        progress(0.8, desc="Cleaning up")
-        try:
-            if os.path.exists(src_path):
-                os.remove(src_path)
-            if os.path.exists(dst_path):
-                os.remove(dst_path)
-            log += "Cleaned up temp files.\n"
-        except Exception as cleanup_error:
-            log += f"Cleanup error: {cleanup_error}\n"
-        progress(1, desc="Done")
-        elapsed = time.time() - start_time
-        log += f"Elapsed time: {elapsed:.2f} seconds\n"
-        return output_path, log
-    except Exception as e:
-        log += f"Error: {e}\n"
-        progress(1, desc="Error")
-        elapsed = time.time() - start_time
-        log += f"Elapsed time: {elapsed:.2f} seconds\n"
-        return None, log
-
-def swap_single_src_multi_dst(src_img, dst_imgs, dst_indices, progress=gr.Progress(track_tqdm=True)):
-    log = ""
-    results = []
-    src_dir = "SingleSrcMultiDst/src"
-    dst_dir = "SingleSrcMultiDst/dst"
-    output_dir = "SingleSrcMultiDst/output"
-    os.makedirs(src_dir, exist_ok=True)
-    os.makedirs(dst_dir, exist_ok=True)
-    os.makedirs(output_dir, exist_ok=True)
-
-    if isinstance(dst_img, tuple):
-        dst_img = dst_img[0]
-    dst_img_bgr = cv2.cvtColor(dst_img, cv2.COLOR_RGB2BGR)
-    dst_path = os.path.join(dst_dir, "data_dst.jpg")
-    cv2.imwrite(dst_path, dst_img_bgr)
-    log += f"Saved destination image to {dst_path}\n"
-    progress(0.05, desc="Saved destination image")
-
-    for i, src_img in enumerate(src_imgs):
-        if isinstance(src_img, tuple):
-            src_img = src_img[0]
-        src_path = os.path.join(src_dir, f"data_src_{i}.jpg")
-        output_path = os.path.join(output_dir, f"output_swapped_{i}.jpg")
-        src_img_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
-        cv2.imwrite(src_path, src_img_bgr)
-        log += f"Saved source image {i} to {src_path}\n"
-        try:
-            result = swapper.swap_faces(src_path, 1, dst_path, int(dst_idx))
-            cv2.imwrite(output_path, result)
-            results.append(output_path)
-            log += f"Swapped and saved result to {output_path}\n"
-        except Exception as e:
-            results.append(f"Error: {e}")
-            log += f"Error swapping source {i}: {e}\n"
-        progress((i + 1) / len(src_imgs), desc=f"Swapping source {i+1}/{len(src_imgs)}")
-    progress(1, desc="Done")
-    return results, log
-
-def swap_multi_src_single_dst(src_imgs, dst_img, dst_idx, progress=gr.Progress(track_tqdm=True)):
-    log = ""
-    results = []
-    src_dir = "MultiSrcSingleDst/src"
-    dst_dir = "MultiSrcSingleDst/dst"
-    output_dir = "MultiSrcSingleDst/output"
-    os.makedirs(src_dir, exist_ok=True)
-    os.makedirs(dst_dir, exist_ok=True)
-    os.makedirs(output_dir, exist_ok=True)
-
-    if isinstance(dst_img, tuple):
-        dst_img = dst_img[0]
-    dst_img_bgr = cv2.cvtColor(dst_img, cv2.COLOR_RGB2BGR)
-    dst_path = os.path.join(dst_dir, "data_dst.jpg")
-    cv2.imwrite(dst_path, dst_img_bgr)
-    log += f"Saved destination image to {dst_path}\n"
-    progress(0.05, desc="Saved destination image")
-
-    for i, src_img in enumerate(src_imgs):
-        if isinstance(src_img, tuple):
-            src_img = src_img[0]
-        src_path = os.path.join(src_dir, f"data_src_{i}.jpg")
-        output_path = os.path.join(output_dir, f"output_swapped_{i}.jpg")
-        src_img_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
-        cv2.imwrite(src_path, src_img_bgr)
-        log += f"Saved source image {i} to {src_path}\n"
-        try:
-            result = swapper.swap_faces(src_path, 1, dst_path, int(dst_idx))
-            cv2.imwrite(output_path, result)
-            results.append(output_path)
-            log += f"Swapped and saved result to {output_path}\n"
-        except Exception as e:
-            results.append(f"Error: {e}")
-            log += f"Error swapping source {i}: {e}\n"
-        progress((i + 1) / len(src_imgs), desc=f"Swapping source {i+1}/{len(src_imgs)}")
-    progress(1, desc="Done")
-    return results, log
-
-def swap_multi_src_multi_dst(src_imgs, dst_imgs, dst_indices, progress=gr.Progress(track_tqdm=True)):
-    log = ""
-    results = []
-    src_dir = "MultiSrcMultiDst/src"
-    dst_dir = "MultiSrcMultiDst/dst"
-    output_dir = "MultiSrcMultiDst/output"
-    os.makedirs(src_dir, exist_ok=True)
-    os.makedirs(dst_dir, exist_ok=True)
-    os.makedirs(output_dir, exist_ok=True)
-
-    if isinstance(dst_indices, str):
-        dst_indices_list = [int(idx.strip()) for idx in dst_indices.split(",") if idx.strip().isdigit()]
-    else:
-        dst_indices_list = [int(idx) for idx in dst_indices]
-
-    total = max(1, len(src_imgs) * len(dst_imgs))
-    count = 0
-    for i, src_img in enumerate(src_imgs):
-        if isinstance(src_img, tuple):
-            src_img = src_img[0]
-        if src_img is None:
-            results.append(f"Error: Source image at index {i} is None")
-            log += f"Source image at index {i} is None\n"
-            continue
-        src_path = os.path.join(src_dir, f"data_src_{i}.jpg")
-        if isinstance(src_img, np.ndarray):
-            src_img_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
-            cv2.imwrite(src_path, src_img_bgr)
-            log += f"Saved source image {i} to {src_path}\n"
-        elif isinstance(src_img, str) and os.path.exists(src_img):
-            shutil.copy(src_img, src_path)
-            log += f"Copied source image {i} from {src_img} to {src_path}\n"
-        else:
-            results.append(f"Error: Invalid source image at index {i}")
-            log += f"Invalid source image at index {i}\n"
-            continue
-        for j, dst_img in enumerate(dst_imgs):
-            if isinstance(dst_img, tuple):
-                dst_img = dst_img[0]
-            if dst_img is None:
-                results.append(f"Error: Destination image at index {j} is None")
-                log += f"Destination image at index {j} is None\n"
-                continue
-            dst_path = os.path.join(dst_dir, f"data_dst_{j}.jpg")
-            output_path = os.path.join(output_dir, f"output_swapped_{i}_{j}.jpg")
-            if isinstance(dst_img, np.ndarray):
-                dst_img_bgr = cv2.cvtColor(dst_img, cv2.COLOR_RGB2BGR)
-                cv2.imwrite(dst_path, dst_img_bgr)
-                log += f"Saved destination image {j} to {dst_path}\n"
-            elif isinstance(dst_img, str) and os.path.exists(dst_img):
-                shutil.copy(dst_img, dst_path)
-                log += f"Copied destination image {j} from {dst_img} to {dst_path}\n"
-            else:
-                results.append(f"Error: Invalid destination image at index {j}")
-                log += f"Invalid destination image at index {j}\n"
-                continue
-            try:
-                dst_idx = dst_indices_list[j] if j < len(dst_indices_list) else 1
-                result = swapper.swap_faces(src_path, 1, dst_path, int(dst_idx))
-                cv2.imwrite(output_path, result)
-                results.append(output_path)
-                log += f"Swapped src {i} with dst {j} and saved to {output_path}\n"
-            except Exception as e:
-                results.append(f"Error: {e}")
-                log += f"Error swapping src {i} with dst {j}: {e}\n"
-            count += 1
-            progress(count / total, desc=f"Swapping ({count}/{total})")
-    progress(1, desc="Done")
-    return results, log
-
-def swap_single_src_multi_dst(src_img, dst_imgs, dst_indices, progress=gr.Progress(track_tqdm=True)):
-    log = ""
-    results = []
-    src_dir = "SingleSrcMultiDst/src"
-    dst_dir = "SingleSrcMultiDst/dst"
-    output_dir = "SingleSrcMultiDst/output"
-    os.makedirs(src_dir, exist_ok=True)
-    os.makedirs(dst_dir, exist_ok=True)
-    os.makedirs(output_dir, exist_ok=True)
-
-    if isinstance(src_img, tuple):
-        src_img = src_img[0]
-    src_path = os.path.join(src_dir, "data_src.jpg")
-    src_img_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
-    cv2.imwrite(src_path, src_img_bgr)
-    log += f"Saved source image to {src_path}\n"
-    progress(0.05, desc="Saved source image")
-
-    if isinstance(dst_indices, str):
-        dst_indices_list = [int(idx.strip()) for idx in dst_indices.split(",") if idx.strip().isdigit()]
-    else:
-        dst_indices_list = [int(idx) for idx in dst_indices]
-
-    for j, dst_img in enumerate(dst_imgs):
-        if isinstance(dst_img, tuple):
-            dst_img = dst_img[0]
-        dst_path = os.path.join(dst_dir, f"data_dst_{j}.jpg")
-        output_path = os.path.join(output_dir, f"output_swapped_{j}.jpg")
-        dst_img_bgr = cv2.cvtColor(dst_img, cv2.COLOR_RGB2BGR)
-        cv2.imwrite(dst_path, dst_img_bgr)
-        log += f"Saved destination image {j} to {dst_path}\n"
-        try:
-            dst_idx = dst_indices_list[j] if j < len(dst_indices_list) else 1
-            result = swapper.swap_faces(src_path, 1, dst_path, int(dst_idx))
-            cv2.imwrite(output_path, result)
-            results.append(output_path)
-            log += f"Swapped and saved result to {output_path}\n"
-        except Exception as e:
-            results.append(f"Error: {e}")
-            log += f"Error swapping with destination {j}: {e}\n"
-        progress((j + 1) / len(dst_imgs), desc=f"Swapping destination {j+1}/{len(dst_imgs)}")
-    progress(1, desc="Done")
-    return results, log
-
-def swap_faces_custom(src_imgs, dst_img, mapping_str, progress=gr.Progress(track_tqdm=True)):
-    """
-    src_imgs: list of source images (numpy arrays)
-    dst_img: destination image (numpy array)
-    mapping_str: comma-separated string, e.g. "2,1,3"
-    """
-    log = ""
-    start_time = time.time()
-    dst_path = "CustomSwap/data_dst.jpg"
-    output_path = "CustomSwap/output_swapped.jpg"
-    src_dir = "CustomSwap/src"
-    temp_dir = "CustomSwap/temp"
-    os.makedirs(src_dir, exist_ok=True)
-    os.makedirs(temp_dir, exist_ok=True)
-    os.makedirs(os.path.dirname(dst_path), exist_ok=True)
-    os.makedirs(os.path.dirname(output_path), exist_ok=True)
-
-    # Save destination image
-    dst_img_bgr = cv2.cvtColor(dst_img, cv2.COLOR_RGB2BGR)
-    cv2.imwrite(dst_path, dst_img_bgr)
-    log += f"Saved destination image to {dst_path}\n"
-
-    # Save all source images
-    src_paths = []
-    for i, src_img in enumerate(src_imgs):
-        src_path = os.path.join(src_dir, f"data_src_{i+1}.jpg")
-        if isinstance(src_img, tuple):
-            src_img = src_img[0]
-        if src_img is None:
-            log += f"Source image {i+1} is None, skipping.\n"
-            continue
-        if isinstance(src_img, np.ndarray):
-            src_img_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
-            cv2.imwrite(src_path, src_img_bgr)
-            src_paths.append(src_path)
-            log += f"Saved source image {i+1} to {src_path}\n"
-        elif isinstance(src_img, str) and os.path.exists(src_img):
-            shutil.copy(src_img, src_path)
-            src_paths.append(src_path)
-            log += f"Copied source image {i+1} from {src_img} to {src_path}\n"
-        else:
-            log += f"Source image {i+1} is not a valid image, skipping.\n"
-
-    # Parse mapping
-    try:
-        mapping = [int(x.strip()) for x in mapping_str.split(",") if x.strip().isdigit()]
-    except Exception as e:
-        log += f"Error parsing mapping: {e}\n"
-        elapsed = time.time() - start_time
-        log += f"Elapsed time: {elapsed:.2f} seconds\n"
-        return None, log
-
-    # Use a temp file for iterative swapping
-    temp_dst_path = os.path.join(temp_dir, "temp_dst.jpg")
-    shutil.copy(dst_path, temp_dst_path)
-
-    for face_idx, src_idx in enumerate(mapping, start=1):
-        if src_idx < 1 or src_idx > len(src_paths):
-            log += f"Invalid source index {src_idx} for face {face_idx}, skipping.\n"
-            continue
-        try:
-            swapped_img = swapper.swap_faces(src_paths[src_idx-1], 1, temp_dst_path, face_idx)
-            cv2.imwrite(temp_dst_path, swapped_img)
-            log += f"Swapped face {face_idx} in destination with source {src_idx}\n"
-        except Exception as e:
-            log += f"Failed to swap face {face_idx} with source {src_idx}: {e}\n"
-
-    shutil.copy(temp_dst_path, output_path)
-    log += f"Saved swapped image to {output_path}\n"
-    if os.path.exists(temp_dst_path):
-        os.remove(temp_dst_path)
-    elapsed = time.time() - start_time
-    log += f"Elapsed time: {elapsed:.2f} seconds\n"
-    return output_path, log
-
-#Video Swapping Functions
-def add_audio_to_video(original_video_path, video_no_audio_path, output_path):
-    cmd = [
-        "ffmpeg",
-        "-y",
-        "-i", video_no_audio_path,
-        "-i", original_video_path,
-        "-c:v", "copy",
-        "-c:a", "aac",
-        "-map", "0:v:0",
-        "-map", "1:a:0?",
-        "-shortest",
-        output_path
-    ]
-    try:
-        subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        return True, ""
-    except subprocess.CalledProcessError as e:
-        return False, e.stderr.decode()
-
-def swap_video(src_img, src_idx, video, dst_idx, delete_frames_dir=True, add_audio=True, copy_to_drive=False, progress=gr.Progress()):
-    log = ""
-    start_time = time.time()
-    src_path = "VideoSwapping/data_src.jpg"
-    dst_video_path = "VideoSwapping/data_dst.mp4"
-    frames_dir = "VideoSwapping/video_frames"
-    swapped_dir = "VideoSwapping/swapped_frames"
-    output_video_path = "VideoSwapping/output_tmp_output_video.mp4"
-    final_output_path = "VideoSwapping/output_with_audio.mp4"
-
-    os.makedirs(os.path.dirname(src_path), exist_ok=True)
-    os.makedirs(os.path.dirname(dst_video_path), exist_ok=True)
-    os.makedirs(frames_dir, exist_ok=True)
-    os.makedirs(swapped_dir, exist_ok=True)
-
-    src_img_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
-    cv2.imwrite(src_path, src_img_bgr)
-    log += f"Saved source image to {src_path}\n"
-    progress(0.05, desc="Saved source image")
-
-    if isinstance(video, str) and os.path.exists(video):
-        shutil.copy(video, dst_video_path)
-        log += f"Copied video to {dst_video_path}\n"
-    else:
-        dst_video_path = video
-
-    from VideoSwapping import extract_frames, frames_to_video
-
-    frame_paths = extract_frames(dst_video_path, frames_dir)
-    log += f"Extracted {len(frame_paths)} frames to {frames_dir}\n"
-    progress(0.15, desc="Extracted frames")
-
-    swapped_files = set(os.listdir(swapped_dir))
-    total_frames = len(frame_paths)
-    start_loop_time = time.time()
-    for idx, frame_path in enumerate(frame_paths):
-        swapped_name = f"swapped_{idx:05d}.jpg"
-        out_path = os.path.join(swapped_dir, swapped_name)
-        if swapped_name in swapped_files and os.path.exists(out_path):
-            log += f"Frame {idx}: already swapped, skipping.\n"
-            elapsed = time.time() - start_loop_time
-            avg_time = elapsed / (idx + 1) if idx + 1 > 0 else 0
-            remaining = avg_time * (total_frames - (idx + 1))
-            mins, secs = divmod(int(remaining), 60)
-            progress(0.15 + 0.6 * (idx + 1) / total_frames, desc=f"Swapping {idx+1}/{total_frames} | {mins:02d}:{secs:02d} left")
-            continue
-        try:
-            try:
-                swapped = swapper.swap_faces(src_path, int(src_idx), frame_path, int(dst_idx))
-            except ValueError as ve:
-                if int(dst_idx) != 1 and "Target image contains" in str(ve):
-                    swapped = swapper.swap_faces(src_path, int(src_idx), frame_path, 1)
-                    log += f"Frame {idx}: dst_idx {dst_idx} not found, used 1 instead.\n"
-                else:
-                    raise ve
-            cv2.imwrite(out_path, swapped)
-            log += f"Swapped frame {idx} and saved to {out_path}\n"
-        except Exception as e:
-            cv2.imwrite(out_path, cv2.imread(frame_path))
-            log += f"Failed to swap frame {idx}: {e}\n"
-        elapsed = time.time() - start_loop_time
-        avg_time = elapsed / (idx + 1) if idx + 1 > 0 else 0
-        remaining = avg_time * (total_frames - (idx + 1))
-        mins, secs = divmod(int(remaining), 60)
-        progress(0.15 + 0.6 * (idx + 1) / total_frames, desc=f"Swapping {idx+1}/{total_frames} | {mins:02d}:{secs:02d} left")
-    cap = cv2.VideoCapture(dst_video_path)
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    cap.release()
-    frames_to_video(swapped_dir, output_video_path, fps)
-    log += f"Combined swapped frames into video {output_video_path}\n"
-    progress(0.8, desc="Muxing audio")
-
-    # Copy to Google Drive if requested
-    if copy_to_drive:
-        drive_path = "/content/drive/MyDrive/" + os.path.basename(output_video_path)
-        try:
-            shutil.copy(output_video_path, drive_path)
-            log += f"Copied swapped video without audio to Google Drive: {drive_path}\n"
-        except Exception as e:
-            log += f"Failed to copy to Google Drive: {e}\n"
-
-    if add_audio:
-        ok, audio_log = add_audio_to_video(dst_video_path, output_video_path, final_output_path)
-        if ok:
-            log += f"Added audio to {final_output_path}\n"
-        else:
-            log += f"Audio muxing failed: {audio_log}\n"
-            final_output_path = output_video_path
-    else:
-        final_output_path = output_video_path
-        log += "Audio was not added as per user request.\n"
-
-    try:
-        if os.path.exists(src_path):
-            os.remove(src_path)
-        if os.path.exists(dst_video_path):
-            os.remove(dst_video_path)
-        if delete_frames_dir and os.path.exists(frames_dir):
-            shutil.rmtree(frames_dir)
-            log += "Deleted video_frames directory.\n"
-        elif not delete_frames_dir:
-            log += "Kept video_frames directory as requested.\n"
-        if os.path.exists(swapped_dir):
-            shutil.rmtree(swapped_dir)
-        log += "Cleaned up temp files and folders.\n"
-    except Exception as cleanup_error:
-        log += f"Cleanup error: {cleanup_error}\n"
-    progress(1, desc="Done")
-    elapsed = time.time() - start_time
-    log += f"Elapsed time: {elapsed:.2f} seconds\n"
-    return final_output_path, log
-
-def swap_video_all_faces(src_img, video, num_faces_to_swap, delete_frames_dir=True, add_audio=True, copy_to_drive=False, progress=gr.Progress()):
-    log = ""
-    start_time = time.time()
-    src_path = "VideoSwappingAllFaces/data_src.jpg"
-    dst_video_path = "VideoSwappingAllFaces/data_dst.mp4"
-    frames_dir = "VideoSwappingAllFaces/video_frames"
-    swapped_dir = "VideoSwappingAllFaces/swapped_frames"
-    output_video_path = "VideoSwappingAllFaces/output_tmp_output_video.mp4"
-    final_output_path = "VideoSwappingAllFaces/output_with_audio.mp4"
-
-    os.makedirs(os.path.dirname(src_path), exist_ok=True)
-    os.makedirs(os.path.dirname(dst_video_path), exist_ok=True)
-    os.makedirs(frames_dir, exist_ok=True)
-    os.makedirs(swapped_dir, exist_ok=True)
-
-    src_img_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
-    cv2.imwrite(src_path, src_img_bgr)
-    log += f"Saved source image to {src_path}\n"
-    progress(0.05, desc="Saved source image")
-
-    if isinstance(video, str) and os.path.exists(video):
-        shutil.copy(video, dst_video_path)
-        log += f"Copied video to {dst_video_path}\n"
-    else:
-        dst_video_path = video
-
-    from VideoSwapping import extract_frames, frames_to_video
-
-    frame_paths = extract_frames(dst_video_path, frames_dir)
-    log += f"Extracted {len(frame_paths)} frames to {frames_dir}\n"
-    progress(0.15, desc="Extracted frames")
-
-    swapped_files = set(os.listdir(swapped_dir))
-    temp_dir = os.path.join(swapped_dir, "temp_swap")
-    os.makedirs(temp_dir, exist_ok=True)
-    total_frames = len(frame_paths)
-    start_loop_time = time.time()
-
-    for idx, frame_path in enumerate(frame_paths):
-        swapped_name = f"swapped_{idx:05d}.jpg"
-        out_path = os.path.join(swapped_dir, swapped_name)
-        temp_frame_path = os.path.join(temp_dir, "temp.jpg")
-        if swapped_name in swapped_files and os.path.exists(out_path):
-            log += f"Frame {idx}: already swapped, skipping.\n"
-            elapsed = time.time() - start_loop_time
-            avg_time = elapsed / (idx + 1) if idx + 1 > 0 else 0
-            remaining = avg_time * (total_frames - (idx + 1))
-            mins, secs = divmod(int(remaining), 60)
-            progress(0.15 + 0.6 * (idx + 1) / total_frames, desc=f"Swapping {idx+1}/{total_frames} | {mins:02d}:{secs:02d} left")
-            continue
-        try:
-            shutil.copy(frame_path, temp_frame_path)
-            for face_idx in range(1, int(num_faces_to_swap) + 1):
-                try:
-                    swapped_img = swapper.swap_faces(src_path, 1, temp_frame_path, face_idx)
-                    cv2.imwrite(temp_frame_path, swapped_img)
-                except Exception as e:
-                    log += f"Failed to swap face {face_idx} in frame {idx}: {e}\n"
-            shutil.copy(temp_frame_path, out_path)
-            log += f"Swapped all faces in frame {idx} and saved to {out_path}\n"
-            if os.path.exists(temp_frame_path):
-                os.remove(temp_frame_path)
-        except Exception as e:
-            cv2.imwrite(out_path, cv2.imread(frame_path))
-            log += f"Failed to swap frame {idx}: {e}\n"
-        elapsed = time.time() - start_loop_time
-        avg_time = elapsed / (idx + 1) if idx + 1 > 0 else 0
-        remaining = avg_time * (total_frames - (idx + 1))
-        mins, secs = divmod(int(remaining), 60)
-        progress(0.15 + 0.6 * (idx + 1) / total_frames, desc=f"Swapping {idx+1}/{total_frames} | {mins:02d}:{secs:02d} left")
-    if os.path.exists(temp_dir):
-        shutil.rmtree(temp_dir)
-
-    cap = cv2.VideoCapture(dst_video_path)
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    cap.release()
-    frames_to_video(swapped_dir, output_video_path, fps)
-    log += f"Combined swapped frames into video {output_video_path}\n"
-    progress(0.8, desc="Muxing audio")
-
-    # Copy to Google Drive if requested
-    if copy_to_drive:
-        drive_path = "/content/drive/MyDrive/" + os.path.basename(output_video_path)
-        try:
-            shutil.copy(output_video_path, drive_path)
-            log += f"Copied swapped video without audio to Google Drive: {drive_path}\n"
-        except Exception as e:
-            log += f"Failed to copy to Google Drive: {e}\n"
-
-    if add_audio:
-        ok, audio_log = add_audio_to_video(dst_video_path, output_video_path, final_output_path)
-        if ok:
-            log += f"Added audio to {final_output_path}\n"
-        else:
-            log += f"Audio muxing failed: {audio_log}\n"
-            final_output_path = output_video_path
-    else:
-        final_output_path = output_video_path
-        log += "Audio was not added as per user request.\n"
-
-    try:
-        if os.path.exists(src_path):
-            os.remove(src_path)
-        if os.path.exists(dst_video_path):
-            os.remove(dst_video_path)
-        if delete_frames_dir and os.path.exists(frames_dir):
-            shutil.rmtree(frames_dir)
-            log += "Deleted video_frames directory.\n"
-        elif not delete_frames_dir:
-            log += "Kept video_frames directory as requested.\n"
-        if os.path.exists(swapped_dir):
-            shutil.rmtree(swapped_dir)
-        log += "Cleaned up temp files and folders.\n"
-    except Exception as cleanup_error:
-        log += f"Cleanup error: {cleanup_error}\n"
-    progress(1, desc="Done")
-    elapsed = time.time() - start_time
-    log += f"Elapsed time: {elapsed:.2f} seconds\n"
-    return final_output_path, log
-
-def swap_video_custom_mapping(src_imgs, video, mapping_str, delete_frames_dir=True, add_audio=True, copy_to_drive=False, progress=gr.Progress()):
-    log = ""
-    start_time = time.time()
-    src_dir = "CustomVideoSwap/src"
-    temp_dir = "CustomVideoSwap/temp"
-    frames_dir = "CustomVideoSwap/frames"
-    swapped_dir = "CustomVideoSwap/swapped_frames"
-    output_video_path = "CustomVideoSwap/output_tmp_output_video.mp4"
-    final_output_path = "CustomVideoSwap/output_with_audio.mp4"
-    dst_video_path = "CustomVideoSwap/data_dst.mp4"
-
-    os.makedirs(src_dir, exist_ok=True)
-    os.makedirs(temp_dir, exist_ok=True)
-    os.makedirs(frames_dir, exist_ok=True)
-    os.makedirs(swapped_dir, exist_ok=True)
-
-    # Save all source images
-    src_paths = []
-    for i, src_img in enumerate(src_imgs):
-        src_path = os.path.join(src_dir, f"data_src_{i+1}.jpg")
-        if isinstance(src_img, tuple):
-            src_img = src_img[0]
-        if src_img is None:
-            log += f"Source image {i+1} is None, skipping.\n"
-            continue
-        if isinstance(src_img, np.ndarray):
-            src_img_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
-            cv2.imwrite(src_path, src_img_bgr)
-            src_paths.append(src_path)
-            log += f"Saved source image {i+1} to {src_path}\n"
-        elif isinstance(src_img, str) and os.path.exists(src_img):
-            shutil.copy(src_img, src_path)
-            src_paths.append(src_path)
-            log += f"Copied source image {i+1} from {src_img} to {src_path}\n"
-        else:
-            log += f"Source image {i+1} is not a valid image, skipping.\n"
-
-    # Parse mapping
-    try:
-        mapping = [int(x.strip()) for x in mapping_str.split(",") if x.strip().isdigit()]
-    except Exception as e:
-        log += f"Error parsing mapping: {e}\n"
-        elapsed = time.time() - start_time
-        log += f"Elapsed time: {elapsed:.2f} seconds\n"
-        return None, log
-
-    # Prepare video
-    if isinstance(video, str) and os.path.exists(video):
-        shutil.copy(video, dst_video_path)
-        log += f"Copied video to {dst_video_path}\n"
-    else:
-        dst_video_path = video
-
-    from VideoSwapping import extract_frames, frames_to_video
-
-    frame_paths = extract_frames(dst_video_path, frames_dir)
-    log += f"Extracted {len(frame_paths)} frames to {frames_dir}\n"
-    progress(0.1, desc="Extracted frames")
-
-    swapped_files = set(os.listdir(swapped_dir))
-    temp_frame_path = os.path.join(temp_dir, "temp.jpg")
-    total_frames = len(frame_paths)
-    start_loop_time = time.time()
+import insightface
+from insightface.app import FaceAnalysis
+from insightface.model_zoo import get_model
+import urllib.request
+import os
+import tempfile
 
-    for idx, frame_path in enumerate(frame_paths):
-        swapped_name = f"swapped_{idx:05d}.jpg"
-        out_path = os.path.join(swapped_dir, swapped_name)
-        if swapped_name in swapped_files and os.path.exists(out_path):
-            log += f"Frame {idx}: already swapped, skipping.\n"
-            elapsed = time.time() - start_loop_time
-            avg_time = elapsed / (idx + 1) if idx + 1 > 0 else 0
-            remaining = avg_time * (total_frames - (idx + 1))
-            mins, secs = divmod(int(remaining), 60)
-            progress(0.1 + 0.7 * (idx + 1) / total_frames, desc=f"Swapping {idx+1}/{total_frames} | {mins:02d}:{secs:02d} left")
-            continue
-        try:
-            shutil.copy(frame_path, temp_frame_path)
-            for face_idx, src_idx in enumerate(mapping, start=1):
-                if src_idx < 1 or src_idx > len(src_paths):
-                    log += f"Invalid source index {src_idx} for face {face_idx} in frame {idx}, skipping.\n"
-                    continue
-                try:
-                    swapped_img = swapper.swap_faces(src_paths[src_idx-1], 1, temp_frame_path, face_idx)
-                    cv2.imwrite(temp_frame_path, swapped_img)
-                    log += f"Frame {idx}: Swapped face {face_idx} with source {src_idx}\n"
-                except Exception as e:
-                    log += f"Frame {idx}: Failed to swap face {face_idx} with source {src_idx}: {e}\n"
-            shutil.copy(temp_frame_path, out_path)
-            log += f"Swapped all faces in frame {idx} and saved to {out_path}\n"
-            if os.path.exists(temp_frame_path):
-                os.remove(temp_frame_path)
-        except Exception as e:
-            cv2.imwrite(out_path, cv2.imread(frame_path))
-            log += f"Failed to swap frame {idx}: {e}\n"
-        elapsed = time.time() - start_loop_time
-        avg_time = elapsed / (idx + 1) if idx + 1 > 0 else 0
-        remaining = avg_time * (total_frames - (idx + 1))
-        mins, secs = divmod(int(remaining), 60)
-        progress(0.1 + 0.7 * (idx + 1) / total_frames, desc=f"Swapping {idx+1}/{total_frames} | {mins:02d}:{secs:02d} left")
-    if os.path.exists(temp_dir):
-        shutil.rmtree(temp_dir)
+# Download model if not exists
+MODEL_URL = "https://huggingface.co/ezioruan/inswapper_128.onnx/resolve/main/inswapper_128.onnx"
+MODEL_PATH = "inswapper_128.onnx"
 
-    cap = cv2.VideoCapture(dst_video_path)
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    cap.release()
-    frames_to_video(swapped_dir, output_video_path, fps)
-    log += f"Combined swapped frames into video {output_video_path}\n"
-    progress(0.9, desc="Muxing audio")
+if not os.path.exists(MODEL_PATH):
+    print("📥 Downloading face swap model...")
+    urllib.request.urlretrieve(MODEL_URL, MODEL_PATH)
 
-    if add_audio:
-        ok, audio_log = add_audio_to_video(dst_video_path, output_video_path, final_output_path)
-        if ok:
-            log += f"Added audio to {final_output_path}\n"
-        else:
-            log += f"Audio muxing failed: {audio_log}\n"
-            final_output_path = output_video_path
-    else:
-        final_output_path = output_video_path
-        log += "Audio was not added as per user request.\n"
+# Initialize face analysis
+print("🔄 Loading face analysis models...")
+face_app = FaceAnalysis(name="buffalo_l", providers=["CPUExecutionProvider"])
+face_app.prepare(ctx_id=0, det_size=(640, 640))
+face_swapper = get_model(MODEL_PATH, providers=["CPUExecutionProvider"])
+print("✅ Models ready!")
 
+def process_video(source_img, target_video, quality_choice):
     try:
-        if os.path.exists(dst_video_path):
-            os.remove(dst_video_path)
-        if delete_frames_dir and os.path.exists(frames_dir):
-            shutil.rmtree(frames_dir)
-            log += "Deleted video_frames directory.\n"
-        elif not delete_frames_dir:
-            log += "Kept video_frames directory as requested.\n"
-        if os.path.exists(swapped_dir):
-            shutil.rmtree(swapped_dir)
-        log += "Cleaned up temp files and folders.\n"
-    except Exception as cleanup_error:
-        log += f"Cleanup error: {cleanup_error}\n"
-    progress(1, desc="Done")
-    elapsed = time.time() - start_time
-    log += f"Elapsed time: {elapsed:.2f} seconds\n"
-    return final_output_path, log
-
-def swap_single_src_multi_video(src_img, dst_videos, dst_indices, delete_frames_dir=True, add_audio=True, copy_to_drive=False, progress=gr.Progress(track_tqdm=True)):
-    """
-    Swaps a single source image onto multiple videos, with a mapping for destination face indices.
-    Each video is processed one by one.
-    """
-    log = ""
-    results = []
-    start_time = time.time()
-    base_dir = "SingleSrcMultiVideo"
-    dst_dir = os.path.join(base_dir, "dst")
-    frames_dir = os.path.join(base_dir, "video_frames")
-    swapped_dir = os.path.join(base_dir, "swap_frames")
-    output_dir = os.path.join(base_dir, "output")
-    os.makedirs(dst_dir, exist_ok=True)
-    os.makedirs(frames_dir, exist_ok=True)
-    os.makedirs(swapped_dir, exist_ok=True)
-    os.makedirs(output_dir, exist_ok=True)
-
-    # Parse indices
-    if isinstance(dst_indices, str):
-        dst_indices_list = [int(idx.strip()) for idx in dst_indices.split(",") if idx.strip().isdigit()]
-    else:
-        dst_indices_list = [int(idx) for idx in dst_indices]
-
-    # Save source image
-    src_path = os.path.join(base_dir, "data_src.jpg")
-    src_img_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
-    cv2.imwrite(src_path, src_img_bgr)
-    log += f"Saved source image to {src_path}\n"
-
-    from VideoSwapping import extract_frames, frames_to_video
-
-    for i, video in enumerate(dst_videos):
-        dst_idx = dst_indices_list[i] if i < len(dst_indices_list) else 1
-        video_name = f"video_{i}.mp4"
-        dst_video_path = os.path.join(dst_dir, video_name)
-        output_video_path = os.path.join(output_dir, f"output_{i}.mp4")
-        output_video_with_audio = os.path.join(output_dir, f"output_with_audio_{i}.mp4")
-
-        # Copy video to dst_dir
-        if isinstance(video, str) and os.path.exists(video):
-            shutil.copy(video, dst_video_path)
-            log += f"Copied video {video} to {dst_video_path}\n"
+        # Quality settings map
+        quality_map = {
+            "320p (Fastest)": {"width": 320, "fps_reduction": 3, "bitrate": "300k"},
+            "480p (Balanced)": {"width": 480, "fps_reduction": 2, "bitrate": "500k"},
+            "720p (Good)": {"width": 720, "fps_reduction": 1, "bitrate": "1000k"},
+            "1080p (Original)": {"width": None, "fps_reduction": 1, "bitrate": "2000k"}
+        }
+        
+        settings = quality_map[quality_choice]
+        
+        # Open video
+        cap = cv2.VideoCapture(target_video)
+        original_fps = cap.get(cv2.CAP_PROP_FPS)
+        original_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        original_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        
+        # Calculate new dimensions
+        if settings["width"]:
+            new_width = settings["width"]
+            aspect = original_height / original_width
+            new_height = int(new_width * aspect)
         else:
-            dst_video_path = video
-
-        # Extract frames
-        frame_paths = extract_frames(dst_video_path, frames_dir)
-        log += f"Extracted {len(frame_paths)} frames from {dst_video_path} to {frames_dir}\n"
-        progress(i / len(dst_videos), desc=f"Processing video {i+1}/{len(dst_videos)}")
-
-        swapped_files = set(os.listdir(swapped_dir))
-        total_frames = len(frame_paths)
-        temp_frame_path = os.path.join(swapped_dir, "temp.jpg")
-        start_loop_time = time.time()
-
-        for idx, frame_path in enumerate(frame_paths):
-            swapped_name = f"swapped_{idx:05d}.jpg"
-            out_path = os.path.join(swapped_dir, swapped_name)
-            if swapped_name in swapped_files and os.path.exists(out_path):
-                continue
-            try:
-                shutil.copy(frame_path, temp_frame_path)
-                try:
-                    swapped_img = swapper.swap_faces(src_path, 1, temp_frame_path, int(dst_idx))
-                    cv2.imwrite(temp_frame_path, swapped_img)
-                except Exception as e:
-                    log += f"Failed to swap face in frame {idx} of video {i}: {e}\n"
-                shutil.copy(temp_frame_path, out_path)
-                if os.path.exists(temp_frame_path):
-                    os.remove(temp_frame_path)
-            except Exception as e:
-                cv2.imwrite(out_path, cv2.imread(frame_path))
-                log += f"Failed to swap frame {idx} of video {i}: {e}\n"
-
-        # Combine frames to video
-        cap = cv2.VideoCapture(dst_video_path)
-        fps = cap.get(cv2.CAP_PROP_FPS)
+            new_width = original_width
+            new_height = original_height
+        
+        # Calculate new fps
+        new_fps = original_fps // settings["fps_reduction"]
+        
+        # Setup output
+        temp_output = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        out = cv2.VideoWriter(temp_output, fourcc, new_fps, (new_width, new_height))
+        
+        # Get source face
+        source_rgb = cv2.cvtColor(source_img, cv2.COLOR_BGR2RGB)
+        source_faces = face_app.get(source_rgb)
+        
+        if len(source_faces) == 0:
+            return None, "❌ No face detected in source image"
+        
+        source_face = source_faces[0]
+        
+        # Process video
+        frame_count = 0
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            # Resize frame
+            if settings["width"]:
+                frame = cv2.resize(frame, (new_width, new_height))
+            
+            # Convert and swap face
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            target_faces = face_app.get(frame_rgb)
+            
+            if len(target_faces) > 0:
+                result = face_swapper.get(frame_rgb, target_faces[0], source_face, paste_back=True)
+                frame_rgb = result
+            
+            # Convert back and write
+            frame_bgr = cv2.cvtColor(frame_rgb, cv2.COLOR_RGB2BGR)
+            out.write(frame_bgr)
+            
+            frame_count += 1
+        
         cap.release()
-        frames_to_video(swapped_dir, output_video_path, fps)
-        log += f"Combined swapped frames into video {output_video_path}\n"
-
-        # Copy to Google Drive if requested
-        if copy_to_drive:
-            drive_path = "/content/drive/MyDrive/" + os.path.basename(output_video_path)
-            try:
-                shutil.copy(output_video_path, drive_path)
-                log += f"Copied swapped video without audio to Google Drive: {drive_path}\n"
-            except Exception as e:
-                log += f"Failed to copy to Google Drive: {e}\n"
-
-        # Mux audio if requested
-        if add_audio:
-            ok, audio_log = add_audio_to_video(dst_video_path, output_video_path, output_video_with_audio)
-            if ok:
-                log += f"Added audio to {output_video_with_audio}\n"
-                results.append(output_video_with_audio)
-            else:
-                log += f"Audio muxing failed for video {i}: {audio_log}\n"
-                results.append(output_video_path)
-        else:
-            results.append(output_video_path)
-            log += f"Audio was not added for video {i} as per user request.\n"
-
-        # Cleanup frames for next video
-        if delete_frames_dir and os.path.exists(frames_dir):
-            shutil.rmtree(frames_dir)
-            os.makedirs(frames_dir, exist_ok=True)
-            log += f"Deleted video_frames directory after video {i}.\n"
-        elif not delete_frames_dir:
-            log += f"Kept video_frames directory after video {i} as requested.\n"
-        if os.path.exists(swapped_dir):
-            shutil.rmtree(swapped_dir)
-            os.makedirs(swapped_dir, exist_ok=True)
-            log += f"Cleared swap_frames directory after video {i}.\n"
-
-    elapsed = time.time() - start_time
-    log += f"Elapsed time: {elapsed:.2f} seconds\n"
-    return results, log
-
-
+        out.release()
+        
+        return temp_output, f"✅ Video processed at {quality_choice} - {frame_count} frames"
+        
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
 
-# Gradio UI
-with gr.Blocks() as demo:
-    gr.Markdown(wellcomingMessage)
-    with gr.Tab("Single Photo Swapping"):
-        gr.Interface(
-            fn=swap_single_photo,
-            inputs=[
-                gr.Image(label="Source Image"),
-                gr.Number(value=1, label="Source Face Index"),
-                gr.Image(label="Destination Image"),
-                gr.Number(value=1, label="Destination Face Index"),
-            ],
-            outputs=[
-                gr.Image(label="Swapped Image"),
-                gr.Textbox(label="Log Output", lines=8, interactive=False)
-            ],
-        )
+# Create UI
+with gr.Blocks(theme=gr.themes.Soft(), title="FaceSwapAll") as demo:
+    gr.Markdown("# FaceSwapAll with Quality Control")
+    
+    with gr.Row():
+        with gr.Column():
+            source = gr.Image(label="Source Face", type="numpy", height=300)
+        with gr.Column():
+            target = gr.Video(label="Target Video", height=300)
+    
+    # Quality dropdown
+    quality = gr.Dropdown(
+        label="Video Output Quality",
+        choices=["320p (Fastest)", "480p (Balanced)", "720p (Good)", "1080p (Original)"],
+        value="480p (Balanced)",
+        info="Lower quality = faster processing on free CPU"
+    )
+    
+    swap_btn = gr.Button("Swap Face in Video", variant="primary", size="lg")
+    
+    with gr.Row():
+        result = gr.Video(label="Result Video")
+        status = gr.Textbox(label="Status", lines=3)
     
-    with gr.Tab("SingleSrc MultiDst"):
-        gr.Interface(
-            fn=swap_single_src_multi_dst,
-            inputs=[
-                gr.Image(label="Source Image"),
-                gr.Gallery(label="Destination Images", type="numpy", columns=3),
-                gr.Textbox(label="Destination Face Indices (comma-separated, e.g. 1,1,2)"),
-            ],
-            outputs=[
-                gr.Gallery(label="Swapped Images"),
-                gr.Textbox(label="Log Output", lines=8, interactive=False)
-            ],
-        )
-    with gr.Tab("MultiSrc SingleDst"):
-        gr.Interface(
-            fn=swap_multi_src_single_dst,
-            inputs=[
-                gr.Gallery(label="Source Images", type="numpy", columns=3),
-                gr.Image(label="Destination Image"),
-                gr.Number(value=1, label="Destination Face Index"),
-            ],
-            outputs=[
-                gr.Gallery(label="Swapped Images"),
-                gr.Textbox(label="Log Output", lines=8, interactive=False)
-            ],
-        )
-    with gr.Tab("MultiSrc MultiDst"):
-        gr.Interface(
-            fn=swap_multi_src_multi_dst,
-            inputs=[
-                gr.Gallery(label="Source Images", type="numpy", columns=3),
-                gr.Gallery(label="Destination Images", type="numpy", columns=3),
-                gr.Textbox(label="Destination Face Indices (comma-separated, e.g. 1,1,2)"),
-            ],
-            outputs=[
-                gr.Gallery(label="Swapped Images"),
-                gr.Textbox(label="Log Output", lines=8, interactive=False)
-            ],
-        )
-    with gr.Tab("Custom Face Mapping"):
-        gr.Interface(
-            fn=swap_faces_custom,
-            inputs=[
-                gr.Gallery(label="Source Images", type="numpy", columns=3),
-                gr.Image(label="Destination Image"),
-                gr.Textbox(label="Mapping (comma-separated, e.g. 2,1,3)"),
-            ],
-            outputs=[
-                gr.Image(label="Swapped Image"),
-                gr.Textbox(label="Log Output", lines=8, interactive=False)
-            ],
-        )
-    with gr.Tab("Video Swapping"):
-        gr.Interface(
-            fn=swap_video,
-            inputs=[
-                gr.Image(label="Source Image"),
-                gr.Number(value=1, label="Source Face Index"),
-                gr.Video(label="Target Video"),
-                gr.Number(value=1, label="Destination Face Index"),
-                gr.Checkbox(label="Delete video_frames directory after processing", value=True),
-                gr.Checkbox(label="Add audio from original video", value=True),
-                gr.Checkbox(label="Copy swapped video (no audio) to Google Drive root", value=False)
-            ],
-            outputs=[
-                gr.Video(label="Swapped Video"),
-                gr.Textbox(label="Log Output", lines=8, interactive=False)
-            ],
-        )
-    with gr.Tab("Video All Faces"):
-        gr.Interface(
-            fn=swap_video_all_faces,
-            inputs=[
-                gr.Image(label="Source Image"),
-                gr.Video(label="Target Video"),
-                gr.Number(value=1, label="Number of Faces to Swap"),
-                gr.Checkbox(label="Delete video_frames directory after processing", value=True),
-                gr.Checkbox(label="Add audio from original video", value=True),
-                gr.Checkbox(label="Copy swapped video (no audio) to Google Drive root", value=False)
-            ],
-            outputs=[
-                gr.Video(label="Swapped Video"),
-                gr.Textbox(label="Log Output", lines=8, interactive=False)
-            ],
-        )
-    with gr.Tab("Custom Video Face Mapping"):
-        gr.Interface(
-            fn=swap_video_custom_mapping,
-            inputs=[
-                gr.Gallery(label="Source Images", type="numpy", columns=3),
-                gr.Video(label="Target Video"),
-                gr.Textbox(label="Mapping (comma-separated, e.g. 2,1,3)"),
-                gr.Checkbox(label="Delete video_frames directory after processing", value=True),
-                gr.Checkbox(label="Add audio from original video", value=True),
-                gr.Checkbox(label="Copy swapped video (no audio) to Google Drive root", value=False)
-            ],
-            outputs=[
-                gr.Video(label="Swapped Video"),
-                gr.Textbox(label="Log Output", lines=8, interactive=False)
-            ],
-        )
-    with gr.Tab("SingleSrcMultiVideo"):
-        gr.Interface(
-            fn=swap_single_src_multi_video,
-            inputs=[
-                gr.Image(label="Source Image"),
-                gr.File(label="Target Videos (select multiple)", file_count="multiple", type="filepath"),
-                gr.Textbox(label="Destination Face Indices (comma-separated, e.g. 1,2,1)"),
-                gr.Checkbox(label="Delete video_frames directory after processing", value=True),
-                gr.Checkbox(label="Add audio from original video", value=True),
-                gr.Checkbox(label="Copy swapped video (no audio) to Google Drive root", value=False)
-            ],
-            outputs=[
-                gr.Gallery(label="Swapped Videos", type="filepath"),
-                gr.Textbox(label="Log Output", lines=8, interactive=False)
-            ],
-        )
+    swap_btn.click(
+        fn=process_video,
+        inputs=[source, target, quality],
+        outputs=[result, status]
+    )
     
+    gr.Markdown("""
+    ### ⚡ Speed Tips:
+    - **320p**: Fastest (8-10x speedup) - Best for testing
+    - **480p**: Balanced (4-5x speedup) - Good quality/speed tradeoff
+    - **720p**: Good quality (2x speedup)
+    - **1080p**: Original quality - Slowest on free CPU
+    """)
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--share", action="store_true", help="Launch Gradio with share=True")
-    args = parser.parse_args()
-    demo.launch(share=args.share)
+    demo.launch()