Upload 6 files

SinglePhoto.py

@@ -0,0 +1,96 @@
+import cv2
+import insightface
+from insightface.app import FaceAnalysis
+import os
+
+class FaceSwapper:
+    def __init__(self):
+        self.app = FaceAnalysis(name='buffalo_l')
+        self.app.prepare(ctx_id=0, det_size=(640, 640))
+        self.swapper = insightface.model_zoo.get_model(
+            'inswapper_128.onnx', download=True, download_zip=True
+        )
+
+    def swap_faces(self, source_path, source_face_idx, target_path, target_face_idx):
+        source_img = cv2.imread(source_path)
+        target_img = cv2.imread(target_path)
+
+        if source_img is None or target_img is None:
+            raise ValueError("Could not read one or both images")
+
+        source_faces = self.app.get(source_img)
+        target_faces = self.app.get(target_img)
+
+        source_faces = sorted(source_faces, key=lambda x: x.bbox[0])
+        target_faces = sorted(target_faces, key=lambda x: x.bbox[0])
+
+        if len(source_faces) < source_face_idx or source_face_idx < 1:
+            raise ValueError(f"Source image contains {len(source_faces)} faces, but requested face {source_face_idx}")
+        if len(target_faces) < target_face_idx or target_face_idx < 1:
+            raise ValueError(f"Target image contains {len(target_faces)} faces, but requested face {target_face_idx}")
+
+        source_face = source_faces[source_face_idx - 1]
+        target_face = target_faces[target_face_idx - 1]
+
+        result = self.swapper.get(target_img, target_face, source_face, paste_back=True)
+        return result
+
+    def count_faces(self, img_path):
+        """
+        Counts the number of faces in the given image file.
+        """
+        img = cv2.imread(img_path)
+        # Use your face detector here. For example, with OpenCV's Haar cascade:
+        face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
+        return len(faces)
+
+def main():
+    # Paths relative to root
+    source_path = os.path.join("SinglePhoto", "data_src.jpg")
+    target_path = os.path.join("SinglePhoto", "data_dst.jpg")
+    output_dir = os.path.join("SinglePhoto", "output")
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    swapper = FaceSwapper()
+
+    try:
+        # Ask user for target_face_idx, default to 1 if no input or invalid input
+        try:
+            user_input = input("Enter the target face index (starting from 1, default is 1): ")
+            target_face_idx = int(user_input) if user_input.strip() else 1
+            if target_face_idx < 1:
+                print("Invalid index. Using default value 1.")
+                target_face_idx = 1
+        except ValueError:
+            print("Invalid input. Using default value 1.")
+            target_face_idx = 1
+
+        try:
+            result = swapper.swap_faces(
+                source_path=source_path,
+                source_face_idx=1,
+                target_path=target_path,
+                target_face_idx=target_face_idx
+            )
+        except ValueError as ve:
+            if "Target image contains" in str(ve):
+                print(f"Target face idx {target_face_idx} not found, trying with idx 1.")
+                result = swapper.swap_faces(
+                    source_path=source_path,
+                    source_face_idx=1,
+                    target_path=target_path,
+                    target_face_idx=1
+                )
+            else:
+                raise ve
+        output_path = os.path.join(output_dir, "swapped_face.jpg")
+        cv2.imwrite(output_path, result)
+        print(f"Face swap completed successfully. Result saved to: {output_path}")
+    except Exception as e:
+        print(f"Error occurred: {str(e)}")
+
+if __name__ == "__main__":
+    main()

VideoSwapping.py

@@ -0,0 +1,168 @@
+import cv2
+import os
+import shutil
+import time
+from SinglePhoto import FaceSwapper
+
+def extract_frames(video_path, frames_dir):
+    if not os.path.exists(frames_dir):
+        os.makedirs(frames_dir)
+        last_idx = -1
+    else:
+        # Find the last extracted frame index
+        existing = [f for f in os.listdir(frames_dir) if f.startswith("frame_") and f.endswith(".jpg")]
+        if existing:
+            last_idx = max([int(f.split("_")[1].split(".")[0]) for f in existing])
+        else:
+            last_idx = -1
+
+    cap = cv2.VideoCapture(video_path)
+    frame_paths = []
+    idx = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frame_path = os.path.join(frames_dir, f"frame_{idx:05d}.jpg")
+        if idx > last_idx:
+            cv2.imwrite(frame_path, frame)
+        frame_paths.append(frame_path)
+        idx += 1
+    cap.release()
+    return frame_paths
+
+def frames_to_video(frames_dir, output_video_path, fps):
+    frames = sorted([os.path.join(frames_dir, f) for f in os.listdir(frames_dir) if f.endswith('.jpg')])
+    if not frames:
+        print("No frames found in directory.")
+        return
+    first_frame = cv2.imread(frames[0])
+    height, width, layers = first_frame.shape
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_video_path, fourcc, fps, (width, height))
+    for frame_path in frames:
+        frame = cv2.imread(frame_path)
+        out.write(frame)
+    out.release()
+
+def main():
+    # Use files from VideoSwapping folder
+    video_path = os.path.join("VideoSwapping", "data_dst.mp4")
+    source_image_path = os.path.join("VideoSwapping", "data_src.jpg")
+    frames_dir = os.path.join("VideoSwapping", "video_frames")
+    swapped_dir = os.path.join("VideoSwapping", "swapped_frames")
+    output_video_path = os.path.join("VideoSwapping", "output_swapped_video.mp4")
+    source_face_idx = 1
+
+    # Ask user for target_face_idx
+    while True:
+        try:
+            user_input = input("Enter target_face_idx (default is 1): ").strip()
+            if user_input == "":
+                dest_face_idx = 1
+                break
+            dest_face_idx = int(user_input)
+            break
+        except ValueError:
+            print("Invalid input. Please enter an integer value.")
+
+    print("Choose an option:")
+    print("1. Extract frames only")
+    print("2. Face swap only (requires extracted frames)")
+    print("3. Both extract frames and face swap")
+    choice = input("Enter 1, 2, or 3: ").strip()
+
+    frame_paths = []
+    if choice == "1" or choice == "3":
+        print("Extracting frames from video (resuming if needed)...")
+        frame_paths = extract_frames(video_path, frames_dir)
+        print(f"Extracted {len(frame_paths)} frames to {frames_dir}.")
+        if choice == "1":
+            return
+
+    if choice == "2":
+        # If only face swap, ensure frames are present
+        if not os.path.exists(frames_dir):
+            print("Frames directory does not exist. Please extract frames first.")
+            return
+        frame_paths = sorted([os.path.join(frames_dir, f) for f in os.listdir(frames_dir) if f.endswith('.jpg')])
+
+    if choice == "2" or choice == "3":
+        # Prepare output directory
+        if not os.path.exists(swapped_dir):
+            os.makedirs(swapped_dir)
+
+        # Initialize face swapper
+        swapper = FaceSwapper()
+
+        # Swap faces on each frame
+        print("Swapping faces on frames...")
+        start_time = time.time()
+        for idx, frame_path in enumerate(frame_paths):
+            frame_name = os.path.basename(frame_path)
+            # Replace 'frame_' with 'swapped_' in the filename
+            if frame_name.startswith("frame_"):
+                swapped_name = "swapped_" + frame_name[len("frame_"):]
+            else:
+                swapped_name = "swapped_" + frame_name
+            out_path = os.path.join(swapped_dir, swapped_name)
+            if os.path.exists(out_path):
+                # Skip already swapped frames
+                print(f"Frame {idx+1}/{len(frame_paths)} already swapped, skipping...", end='\r')
+                continue
+            try:
+                try:
+                    swapped = swapper.swap_faces(
+                        source_path=source_image_path,
+                        source_face_idx=source_face_idx,
+                        target_path=frame_path,
+                        target_face_idx=dest_face_idx
+                    )
+                except ValueError as ve:
+                    if "Target image contains" in str(ve):
+                        print(f"\nFrame {idx}: Target face idx {dest_face_idx} not found, trying with idx 1.",end='\r')
+                        swapped = swapper.swap_faces(
+                            source_path=source_image_path,
+                            source_face_idx=source_face_idx,
+                            target_path=frame_path,
+                            target_face_idx=1
+                        )
+                    else:
+                        raise ve
+                cv2.imwrite(out_path, swapped)
+            except Exception as e:
+                print(f"\nFrame {idx}: {e}")
+                # Optionally, copy the original frame if swap fails
+                cv2.imwrite(out_path, cv2.imread(frame_path))
+            # Estimate time left
+            elapsed = time.time() - start_time
+            avg_time = elapsed / (idx + 1)
+            remaining = avg_time * (len(frame_paths) - (idx + 1))
+            mins, secs = divmod(int(remaining), 60)
+            print(f"Swapping frame {idx+1}/{len(frame_paths)} | Est. time left: {mins:02d}:{secs:02d}", end='\r')
+        print()  # Move to the next line after the loop
+
+        # Get FPS from original video
+        cap = cv2.VideoCapture(video_path)
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        cap.release()
+
+        # Combine swapped frames into video
+        print("Combining swapped frames into video...")
+        frames_to_video(swapped_dir, output_video_path, fps)
+        print(f"Done! Output video saved as {output_video_path}")
+
+        # Ask user if they want to keep the extracted frames and swapped images
+        answer = input("Do you want to keep the extracted frames and swapped images? (y/n): ").strip().lower()
+        if answer == 'n':
+            try:
+                shutil.rmtree(frames_dir)
+                shutil.rmtree(swapped_dir)
+                print("Temporary folders deleted.")
+            except Exception as e:
+                print(f"Error deleting folders: {e}")
+        else:
+            print("Temporary folders kept.")
+
+if __name__ == "__main__":
+    main()

app.py

@@ -0,0 +1,977 @@
+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()
+
+    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)
+
+    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 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(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"
+        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)
+        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
+
+
+
+# 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)
+            ],
+        )
+    
+    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)
+            ],
+        )
+    
+
+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)

inswapper_128.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4a3f08c753cb72d04e10aa0f7dbe3deebbf39567d4ead6dce08e98aa49e16af
+size 554253681

packages.txt

@@ -0,0 +1 @@
+ffmpeg

requirements.txt

@@ -0,0 +1,9 @@
+numpy
+opencv-python
+onnxruntime-gpu
+scikit-learn
+scikit-image
+tqdm
+mxnet
+insightface
+gradio