refactor(face-swapper): extract pair-building helpers, deduplicate constants

- Extract _build_pairs_from_file_map and _build_pairs_live from
  process_frame_v2, reducing nesting from 7 levels to 1
- Remove local DETECTION_INTERVAL; use modules.globals.DETECTION_INTERVAL
- Both helpers snapshot maps under MAP_LOCK before iterating

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: laurigates

modules/processors/frame/face_swapper.py

@@ -33,7 +33,6 @@
 FRAME_CACHE = deque(maxlen=3)  # Cache for frame reuse
 FACE_DETECTION_CACHE = {}  # Cache face detections
 LAST_DETECTION_TIME = 0
-DETECTION_INTERVAL = 0.033  # ~30 FPS detection rate for live mode
 FRAME_SKIP_COUNTER = 0
 ADAPTIVE_QUALITY = True
 # --- END: Mac M1-M5 Optimizations ---
@@ -273,7 +272,7 @@ def get_faces_optimized(frame: Frame, use_cache: bool = True) -> Optional[List[F
     time_since_last = current_time - LAST_DETECTION_TIME
 
     # Skip detection if too soon (adaptive frame skipping)
-    if time_since_last < DETECTION_INTERVAL and FACE_DETECTION_CACHE:
+    if time_since_last < modules.globals.DETECTION_INTERVAL and FACE_DETECTION_CACHE:
         return FACE_DETECTION_CACHE.get('faces')
 
     # Perform detection
@@ -412,6 +411,90 @@ def process_frame(source_face: Face, temp_frame: Frame) -> Frame:
     return final_frame
 
 
+def _build_pairs_from_file_map(temp_frame_path: str) -> list:
+    """Build (source_face, target_face) pairs from source_target_map for image/video files."""
+    pairs = []
+    with modules.globals.MAP_LOCK:
+        source_target_map = list(getattr(modules.globals, "source_target_map", []))
+    if not source_target_map:
+        return pairs
+
+    if modules.globals.many_faces:
+        source_face = default_source_face()
+        if not source_face:
+            return pairs
+        for map_data in source_target_map:
+            if is_image(modules.globals.target_path):
+                target_face = map_data.get("target", {}).get("face")
+                if target_face:
+                    pairs.append((source_face, target_face))
+            elif is_video(modules.globals.target_path):
+                for frame_data in map_data.get("target_faces_in_frame", []):
+                    if frame_data and frame_data.get("location") == temp_frame_path:
+                        for target_face in frame_data.get("faces", []):
+                            pairs.append((source_face, target_face))
+    else:
+        for map_data in source_target_map:
+            source_face = map_data.get("source", {}).get("face")
+            if not source_face:
+                continue
+            if is_image(modules.globals.target_path):
+                target_face = map_data.get("target", {}).get("face")
+                if target_face:
+                    pairs.append((source_face, target_face))
+            elif is_video(modules.globals.target_path):
+                for frame_data in map_data.get("target_faces_in_frame", []):
+                    if frame_data and frame_data.get("location") == temp_frame_path:
+                        for target_face in frame_data.get("faces", []):
+                            pairs.append((source_face, target_face))
+    return pairs
+
+
+def _build_pairs_live(processed_frame: Frame) -> list:
+    """Build (source_face, target_face) pairs for live/webcam mode."""
+    pairs = []
+    detected_faces = get_many_faces(processed_frame)
+    if not detected_faces:
+        return pairs
+
+    with modules.globals.MAP_LOCK:
+        simple_map = dict(getattr(modules.globals, "simple_map", None) or {})
+
+    if modules.globals.many_faces:
+        source_face = default_source_face()
+        if source_face:
+            for target_face in detected_faces:
+                pairs.append((source_face, target_face))
+    elif simple_map:
+        source_faces = simple_map.get("source_faces", [])
+        target_embeddings = simple_map.get("target_embeddings", [])
+        if source_faces and target_embeddings and len(source_faces) == len(target_embeddings):
+            if len(detected_faces) <= len(target_embeddings):
+                for detected_face in detected_faces:
+                    if detected_face.normed_embedding is None:
+                        continue
+                    closest_idx, _ = find_closest_centroid(target_embeddings, detected_face.normed_embedding)
+                    if 0 <= closest_idx < len(source_faces):
+                        pairs.append((source_faces[closest_idx], detected_face))
+            else:
+                detected_embeddings = [f.normed_embedding for f in detected_faces if f.normed_embedding is not None]
+                detected_faces_with_embedding = [f for f in detected_faces if f.normed_embedding is not None]
+                if not detected_embeddings:
+                    return pairs
+                for i, target_embedding in enumerate(target_embeddings):
+                    if 0 <= i < len(source_faces):
+                        closest_idx, _ = find_closest_centroid(detected_embeddings, target_embedding)
+                        if 0 <= closest_idx < len(detected_faces_with_embedding):
+                            pairs.append((source_faces[i], detected_faces_with_embedding[closest_idx]))
+    else:
+        source_face = default_source_face()
+        # Reuse already-detected faces instead of running detection again
+        target_face = min(detected_faces, key=lambda x: x.bbox[0])
+        if source_face and target_face:
+            pairs.append((source_face, target_face))
+    return pairs
+
+
 def process_frame_v2(temp_frame: Frame, temp_frame_path: str = "") -> Frame:
     """Handles complex mapping scenarios (map_faces=True) and live streams."""
     if getattr(modules.globals, "opacity", 1.0) == 0:
@@ -425,100 +508,14 @@ def process_frame_v2(temp_frame: Frame, temp_frame_path: str = "") -> Frame:
     swapped_face_bboxes = [] # Keep track of where swaps happened
 
     # Determine source/target pairs based on mode
-    source_target_pairs = []
-
-    # Ensure maps exist before accessing them
-    source_target_map = getattr(modules.globals, "source_target_map", None)
-    simple_map = getattr(modules.globals, "simple_map", None)
-
-    # Check if target is a file path (image or video) or live stream
-    is_file_target = modules.globals.target_path and (is_image(modules.globals.target_path) or is_video(modules.globals.target_path))
+    is_file_target = modules.globals.target_path and (
+        is_image(modules.globals.target_path) or is_video(modules.globals.target_path)
+    )
 
     if is_file_target:
-        # Processing specific image or video file with pre-analyzed maps
-        if source_target_map:
-            if modules.globals.many_faces:
-                source_face = default_source_face() # Use default source for all targets
-                if source_face:
-                    for map_data in source_target_map:
-                        if is_image(modules.globals.target_path):
-                            target_info = map_data.get("target", {})
-                            if target_info: # Check if target info exists
-                                target_face = target_info.get("face")
-                                if target_face:
-                                    source_target_pairs.append((source_face, target_face))
-                        elif is_video(modules.globals.target_path):
-                             # Find faces for the current frame_path in video map
-                             target_frames_data = map_data.get("target_faces_in_frame", [])
-                             if target_frames_data: # Check if frame data exists
-                                 target_frames = [f for f in target_frames_data if f and f.get("location") == temp_frame_path]
-                                 for frame_data in target_frames:
-                                     faces_in_frame = frame_data.get("faces", [])
-                                     if faces_in_frame: # Check if faces exist
-                                         for target_face in faces_in_frame:
-                                             source_target_pairs.append((source_face, target_face))
-            else: # Single face or specific mapping
-                 for map_data in source_target_map:
-                    source_info = map_data.get("source", {})
-                    if not source_info: continue # Skip if no source info
-                    source_face = source_info.get("face")
-                    if not source_face: continue # Skip if no source defined for this map entry
-
-                    if is_image(modules.globals.target_path):
-                        target_info = map_data.get("target", {})
-                        if target_info:
-                           target_face = target_info.get("face")
-                           if target_face:
-                              source_target_pairs.append((source_face, target_face))
-                    elif is_video(modules.globals.target_path):
-                        target_frames_data = map_data.get("target_faces_in_frame", [])
-                        if target_frames_data:
-                           target_frames = [f for f in target_frames_data if f and f.get("location") == temp_frame_path]
-                           for frame_data in target_frames:
-                               faces_in_frame = frame_data.get("faces", [])
-                               if faces_in_frame:
-                                  for target_face in faces_in_frame:
-                                      source_target_pairs.append((source_face, target_face))
-
+        source_target_pairs = _build_pairs_from_file_map(temp_frame_path)
     else:
-        # Live stream or webcam processing (analyze faces on the fly)
-        detected_faces = get_many_faces(processed_frame)
-        if detected_faces:
-            if modules.globals.many_faces:
-                 source_face = default_source_face() # Use default source for all detected targets
-                 if source_face:
-                     for target_face in detected_faces:
-                        source_target_pairs.append((source_face, target_face))
-            elif simple_map:
-                # Use simple_map (source_faces <-> target_embeddings)
-                source_faces = simple_map.get("source_faces", [])
-                target_embeddings = simple_map.get("target_embeddings", [])
-
-                if source_faces and target_embeddings and len(source_faces) == len(target_embeddings):
-                     # Match detected faces to the closest target embedding
-                     if len(detected_faces) <= len(target_embeddings):
-                          # More targets defined than detected - match each detected face
-                          for detected_face in detected_faces:
-                              if detected_face.normed_embedding is None: continue
-                              closest_idx, _ = find_closest_centroid(target_embeddings, detected_face.normed_embedding)
-                              if 0 <= closest_idx < len(source_faces):
-                                  source_target_pairs.append((source_faces[closest_idx], detected_face))
-                     else:
-                          # More faces detected than targets defined - match each target embedding to closest detected face
-                          detected_embeddings = [f.normed_embedding for f in detected_faces if f.normed_embedding is not None]
-                          detected_faces_with_embedding = [f for f in detected_faces if f.normed_embedding is not None]
-                          if not detected_embeddings: return processed_frame # No embeddings to match
-
-                          for i, target_embedding in enumerate(target_embeddings):
-                              if 0 <= i < len(source_faces): # Ensure source face exists for this embedding
-                                 closest_idx, _ = find_closest_centroid(detected_embeddings, target_embedding)
-                                 if 0 <= closest_idx < len(detected_faces_with_embedding):
-                                     source_target_pairs.append((source_faces[i], detected_faces_with_embedding[closest_idx]))
-            else: # Fallback: if no map, use default source for the single detected face (if any)
-                source_face = default_source_face()
-                target_face = get_one_face(processed_frame, detected_faces) # Use faces already detected
-                if source_face and target_face:
-                    source_target_pairs.append((source_face, target_face))
+        source_target_pairs = _build_pairs_live(processed_frame)
 
 
     # Perform swaps based on the collected pairs