updated sound lib

app.py

@@ -585,26 +585,18 @@ def continue_automatic_composition():
         print(f"DEBUG continue: Completed movements: {completed_movements}")
         
         if len(completed_movements) > 0:
-            print(f"DEBUG continue: Showing individual sounds that will layer together: {list(completed_movements)}")
-            
+            # Track and print only the sounds that have been added
+            sounds_added = [sounds[m] for m in completed_movements if m in sounds]
+            print(f"DEBUG: Sounds added to composition: {sounds_added}")
             # Display each completed movement sound in its respective player
             if 'left_hand' in completed_movements and 'left_hand' in sounds:
                 left_hand_audio = sounds['left_hand']
-                print(f"DEBUG continue: Left hand playing: {sounds['left_hand']}")
             if 'right_hand' in completed_movements and 'right_hand' in sounds:
                 right_hand_audio = sounds['right_hand']
-                print(f"DEBUG continue: Right hand playing: {sounds['right_hand']}")
             if 'left_leg' in completed_movements and 'left_leg' in sounds:
                 left_leg_audio = sounds['left_leg']
-                print(f"DEBUG continue: Left leg playing: {sounds['left_leg']}")
             if 'right_leg' in completed_movements and 'right_leg' in sounds:
                 right_leg_audio = sounds['right_leg']
-                print(f"DEBUG continue: Right leg playing: {sounds['right_leg']}")
-            # if 'tongue' in completed_movements and 'tongue' in sounds:
-            #     tongue_audio = sounds['tongue']
-            #     print(f"DEBUG continue: Tongue playing: {sounds['tongue']}")
-                
-            print(f"DEBUG continue: {len(completed_movements)} individual sounds will play together creating layered composition")
     
     # Format display with progress information
     completed_count = len(sound_manager.movements_completed)

data_processor.py

@@ -146,9 +146,9 @@ class EEGDataProcessor:
             
         return combined_raw, fs
     
-    def prepare_loso_split(self, file_paths: List[str], test_subject_idx: int = 0) -> Tuple:
+    def prepare_loso_split(self, file_paths: List[str], test_session_idx: int = 0) -> Tuple:
         """
-        Prepare Leave-One-Subject-Out (LOSO) split for EEG data.
+        Prepare Leave-One-Session-Out (LOSO) split for EEG data.
         
         Args:
             file_paths: List of .mat file paths (one per subject)
@@ -157,8 +157,8 @@ class EEGDataProcessor:
         Returns:
             X_train, y_train, X_test, y_test, subject_info
         """
-        all_subjects_data = []
-        subject_info = []
+        all_sessions_data = []
+        session_info = []
         
         # Load each subject separately
         for i, file_path in enumerate(file_paths):
@@ -170,9 +170,8 @@ class EEGDataProcessor:
             # Convert to arrays
             X_subject = epochs.get_data().astype("float32")
             y_subject = (epochs.events[:, -1] - 1).astype("int64")
-            
-            all_subjects_data.append((X_subject, y_subject))
-            subject_info.append({
+            all_sessions_data.append((X_subject, y_subject))
+            session_info.append({
                 'file_path': file_path,
                 'subject_id': f"Subject_{i+1}",
                 'n_epochs': len(X_subject),
@@ -180,25 +179,25 @@ class EEGDataProcessor:
                 'fs': fs
             })
         
-        # LOSO split: one subject for test, others for train
-        test_subject = all_subjects_data[test_subject_idx]
-        train_subjects = [all_subjects_data[i] for i in range(len(all_subjects_data)) if i != test_subject_idx]
-        
-        # Combine training subjects
-        if len(train_subjects) > 1:
-            X_train = np.concatenate([subj[0] for subj in train_subjects], axis=0)
-            y_train = np.concatenate([subj[1] for subj in train_subjects], axis=0)
+        # LOSO split: one session for test, others for train
+        test_sessions = all_sessions_data[test_session_idx]
+        train_sessions = [all_sessions_data[i] for i in range(len(all_sessions_data)) if i != test_session_idx]
+
+        # Combine training sessions
+        if len(train_sessions) > 1:
+            X_train = np.concatenate([sess[0] for sess in train_sessions], axis=0)
+            y_train = np.concatenate([sess[1] for sess in train_sessions], axis=0)
         else:
-            X_train, y_train = train_subjects[0]
-        
-        X_test, y_test = test_subject
-        
+            X_train, y_train = train_sessions[0]
+
+        X_test, y_test = test_sessions
+
         print("LOSO Split:")
-        print(f"  Test Subject: {subject_info[test_subject_idx]['subject_id']} ({len(X_test)} epochs)")
-        print(f"  Train Subjects: {len(train_subjects)} subjects ({len(X_train)} epochs)")
-        
-        return X_train, y_train, X_test, y_test, subject_info
-    
+        print(f"  Test Subject: {session_info[test_session_idx]['subject_id']} ({len(X_test)} epochs)")
+        print(f"  Train Subjects: {len(train_sessions)} subjects ({len(X_train)} epochs)")
+
+        return X_train, y_train, X_test, y_test, session_info
+
     def simulate_real_time_data(self, X: np.ndarray, y: np.ndarray, mode: str = "random") -> Tuple[np.ndarray, int]:
         """
         Simulate real-time EEG data for demo purposes.
@@ -227,31 +226,31 @@ class EEGDataProcessor:
             
         return X[idx], y[idx]
     
-    def simulate_continuous_stream(self, raw_data: np.ndarray, fs: int, window_size: float = 1.5) -> np.ndarray:
-        """
-        Simulate continuous EEG stream by extracting sliding windows from raw data.
+    # def simulate_continuous_stream(self, raw_data: np.ndarray, fs: int, window_size: float = 1.5) -> np.ndarray:
+    #     """
+    #     Simulate continuous EEG stream by extracting sliding windows from raw data.
         
-        Args:
-            raw_data: Continuous EEG data [n_channels, n_timepoints]
-            fs: Sampling frequency
-            window_size: Window size in seconds
+    #     Args:
+    #         raw_data: Continuous EEG data [n_channels, n_timepoints]
+    #         fs: Sampling frequency
+    #         window_size: Window size in seconds
             
-        Returns:
-            Single window of EEG data [n_channels, window_samples]
-        """
-        window_samples = int(window_size * fs)  # e.g., 1.5s * 200Hz = 300 samples
+    #     Returns:
+    #         Single window of EEG data [n_channels, window_samples]
+    #     """
+    #     window_samples = int(window_size * fs)  # e.g., 1.5s * 200Hz = 300 samples
         
-        # Ensure we don't go beyond the data
-        max_start = raw_data.shape[1] - window_samples
-        if max_start <= 0:
-            return raw_data  # Return full data if too short
+    #     # Ensure we don't go beyond the data
+    #     max_start = raw_data.shape[1] - window_samples
+    #     if max_start <= 0:
+    #         return raw_data  # Return full data if too short
         
-        # Random starting point in the continuous stream
-        start_idx = np.random.randint(0, max_start)
-        end_idx = start_idx + window_samples
+    #     # Random starting point in the continuous stream
+    #     start_idx = np.random.randint(0, max_start)
+    #     end_idx = start_idx + window_samples
         
-        # Extract window
-        window = raw_data[:, start_idx:end_idx]
+    #     # Extract window
+    #     window = raw_data[:, start_idx:end_idx]
         
-        return window
+    #     return window
 

sound_library.py

@@ -19,28 +19,19 @@ from scipy import signal
 import librosa
 
 class AudioEffectsProcessor:
-    """Professional audio effects for DJ mode using scipy and librosa."""
-    
     @staticmethod
-    def apply_volume_fade(data: np.ndarray, fade_type: str = "out", fade_length: float = 0.5) -> np.ndarray:
-        """Apply volume fade effect with linear fade in/out."""
+    def apply_echo(data: np.ndarray, samplerate: int, delay_time: float = 0.3, feedback: float = 0.4) -> np.ndarray:
+        """Echo/delay effect (tempo-sync if delay_time is set to fraction of beat)."""
         try:
-            samples = len(data)
-            fade_samples = int(fade_length * samples)
-            
-            if fade_type == "out":
-                # Fade out: linear decrease from 1.0 to 0.3
-                fade_curve = np.linspace(1.0, 0.3, fade_samples)
-                data[-fade_samples:] *= fade_curve
-            elif fade_type == "in":
-                # Fade in: linear increase from 0.3 to 1.0
-                fade_curve = np.linspace(0.3, 1.0, fade_samples)
-                data[:fade_samples] *= fade_curve
-            
-            return data
+            delay_samples = int(delay_time * samplerate)
+            echo_data = np.copy(data)
+            for i in range(delay_samples, len(data)):
+                echo_data[i] += feedback * echo_data[i - delay_samples]
+            return 0.7 * data + 0.3 * echo_data
         except Exception as e:
-            print(f"Volume fade effect failed: {e}")
+            print(f"Echo failed: {e}")
             return data
+    """Professional audio effects for DJ mode using scipy and librosa."""
     
     @staticmethod
     def apply_high_pass_filter(data: np.ndarray, samplerate: int, cutoff: float = 800.0) -> np.ndarray:
@@ -79,8 +70,8 @@ class AudioEffectsProcessor:
         """Apply simple reverb effect using delay and feedback."""
         try:
             # Simple reverb using multiple delayed copies
-            delay_samples = int(0.1 * samplerate)  # 100ms delay
-            decay = 0.3 * room_size
+            delay_samples = int(0.08 * samplerate)  # 80ms delay
+            decay = 0.4 * room_size 
             
             # Create reverb buffer
             reverb_data = np.copy(data)
@@ -98,6 +89,19 @@ class AudioEffectsProcessor:
             print(f"Reverb effect failed: {e}")
             return data
     
+    @staticmethod
+    def apply_echo(data: np.ndarray, samplerate: int, delay_time: float = 0.3, feedback: float = 0.4) -> np.ndarray:
+        """Echo/delay effect (tempo-sync if delay_time is set to fraction of beat)."""
+        try:
+            delay_samples = int(delay_time * samplerate)
+            echo_data = np.copy(data)
+            for i in range(delay_samples, len(data)):
+                echo_data[i] += feedback * echo_data[i - delay_samples]
+            return 0.7 * data + 0.3 * echo_data
+        except Exception as e:
+            print(f"Echo failed: {e}")
+            return data
+    
     @staticmethod
     def apply_bass_boost(data: np.ndarray, samplerate: int, boost_db: float = 6.0) -> np.ndarray:
         """Apply bass boost using low-frequency shelving filter."""
@@ -127,9 +131,10 @@ class AudioEffectsProcessor:
             print(f"Bass boost failed: {e}")
             return data
     
+    # --- DJ MODE WRAPPER ---
     @staticmethod
-    def process_with_effects(audio_file: str, active_effects: Dict[str, bool]) -> str:
-        """Process the full track (mixed composition) with DJ effects only."""
+    def process_layer_with_effects(audio_file: str, movement: str, active_effects: Dict[str, bool]) -> str:
+        """Process a single layer with its corresponding DJ effect if active."""
         try:
             if not audio_file or not os.path.exists(audio_file):
                 print(f"Invalid audio file: {audio_file}")
@@ -138,36 +143,39 @@ class AudioEffectsProcessor:
             if len(data.shape) > 1:
                 data = np.mean(data, axis=1)
             processed_data = np.copy(data)
-            effect_names = []
-            # Apply DJ effects to the full track
-            if active_effects.get("left_hand", False):
-                processed_data = AudioEffectsProcessor.apply_volume_fade(processed_data, "out")
-                effect_names.append("fade")
-            if active_effects.get("right_hand", False):
-                processed_data = AudioEffectsProcessor.apply_high_pass_filter(processed_data, samplerate)
-                effect_names.append("hpf")
-            if active_effects.get("left_leg", False):
-                processed_data = AudioEffectsProcessor.apply_reverb(processed_data, samplerate)
-                effect_names.append("rev")
-            if active_effects.get("right_leg", False):
-                processed_data = AudioEffectsProcessor.apply_low_pass_filter(processed_data, samplerate)
-                effect_names.append("lpf")
-            if active_effects.get("tongue", False):
-                processed_data = AudioEffectsProcessor.apply_bass_boost(processed_data, samplerate)
-                effect_names.append("bass")
-            # Create unique filename based on active effects
+
+            # Map movement to effect
+            effect_map = {
+                "left_hand": AudioEffectsProcessor.apply_echo,
+                "right_hand": AudioEffectsProcessor.apply_high_pass_filter,
+                "left_leg": AudioEffectsProcessor.apply_reverb,
+                "right_leg": AudioEffectsProcessor.apply_low_pass_filter,
+            }
+            effect_names = {
+                "left_hand": "echo",
+                "right_hand": "hpf",
+                "left_leg": "rev",
+                "right_leg": "lpf",
+            }
+            effect_func = effect_map.get(movement)
+            effect_name = effect_names.get(movement, "clean")
+            if active_effects.get(movement, False) and effect_func:
+                processed_data = effect_func(processed_data, samplerate)
+                suffix = f"_fx_{effect_name}"
+            else:
+                suffix = "_fx_clean"
+
             base_name = os.path.splitext(audio_file)[0]
-            effects_suffix = "_".join(effect_names) if effect_names else "clean"
-            processed_file = f"{base_name}_fx_{effects_suffix}.wav"
+            processed_file = f"{base_name}{suffix}.wav"
             try:
-                #sf.write(processed_file, processed_data, samplerate)
-                print(f"🎛️ Audio processed with effects: {effects_suffix} → {os.path.basename(processed_file)}")
+                sf.write(processed_file, processed_data, samplerate)
+                print(f"🎛️ Layer processed: {os.path.basename(processed_file)}")
                 return os.path.abspath(processed_file)
             except Exception as e:
-                print(f"Failed to save processed audio: {e}")
+                print(f"Failed to save processed layer: {e}")
                 return os.path.abspath(audio_file)
         except Exception as e:
-            print(f"Audio processing failed: {e}")
+            print(f"Layer processing failed: {e}")
             return os.path.abspath(audio_file) if audio_file else None
 
 class SoundManager:
@@ -198,7 +206,7 @@ class SoundManager:
             
             # DJ Effects phase management
             self.current_phase = "building"  # "building" or "dj_effects"
-            self.mixed_composition_file = None  # Path to current mixed composition
+            # self.mixed_composition_file = None  # Path to current mixed composition
             self.active_effects = {  # Track which effects are currently active
                 "left_hand": False,    # Volume fade
                 "right_hand": False,   # Filter sweep
@@ -210,7 +218,7 @@ class SoundManager:
             # All possible movements (neutral is optional for composition)
             self.all_movements = ["left_hand", "right_hand", "neutral", "left_leg", "tongue", "right_leg"]
             
-            # Active movements that contribute to composition (excluding neutral)
+            # Active movements that contribute to composition (excluding neutral and tongue)
             self.active_movements = ["left_hand", "right_hand", "left_leg", "right_leg"]
             
             # Current cycle's random movement sequence (shuffled each cycle)
@@ -417,16 +425,17 @@ class SoundManager:
     
     def transition_to_dj_phase(self):
         """Transition from building phase to DJ effects phase."""
-        # Only start DJ mode if all 5 sound layers are present (not just movements completed)
+        # Only start DJ mode if all 4 sound layers are present (not just movements completed)
         unique_sounds = set()
         for layer in self.composition_layers:
             if layer.get('sound_file'):
                 unique_sounds.add(layer['sound_file'])
         print(f"DEBUG: Unique sound files in composition_layers: {unique_sounds}")
         print(f"DEBUG: Number of unique sounds: {len(unique_sounds)}")
-        if len(unique_sounds) >= 5:
+        if len(unique_sounds) >= 4:
             self.current_phase = "dj_effects"
-            self._create_mixed_composition()
+            # self._create_mixed_composition() 
+            # just keep current stems running
             print("🎵 Composition Complete! Transitioning to DJ Effects Phase...")
             print("🎧 You are now the DJ! Use movements to control effects:")
             print("   👈 Left Hand: Volume Fade")
@@ -439,132 +448,134 @@ class SoundManager:
             print("DEBUG: Not enough unique sounds to transition to DJ mode.")
         return False
     
-    def _create_mixed_composition(self):
-        """Create a mixed audio file from all completed layers."""
-        try:
-            import hashlib
-            movement_hash = hashlib.md5(str(sorted(self.movements_completed)).encode()).hexdigest()[:8]
-            self.mixed_composition_file = os.path.abspath(f"mixed_composition_{movement_hash}.wav")
-            
-            # FILE SAVING DISABLED: Use existing base audio file instead
-            # Try to use the first available completed movement's audio file
-            for movement in self.movements_completed:
-                if movement in self.current_sound_mapping and self.current_sound_mapping[movement] is not None:
-                    sound_file = os.path.join(self.sound_dir, self.current_sound_mapping[movement])
-                    if os.path.exists(sound_file):
-                        self.mixed_composition_file = os.path.abspath(sound_file)
-                        print(f"📀 Using existing audio as mixed composition: {self.mixed_composition_file} (FILE SAVING DISABLED)")
-                        return
-            
-            # If file already exists, use it
-            if os.path.exists(self.mixed_composition_file):
-                print(f"📀 Using existing mixed composition: {self.mixed_composition_file}")
-                return
-            
-            # Create actual mixed composition by layering completed sounds
-            mixed_data = None
-            sample_rate = 44100  # Default sample rate
-            
-            for movement in self.movements_completed:
-                if movement in self.current_sound_mapping and self.current_sound_mapping[movement] is not None:
-                    sound_file = os.path.join(self.sound_dir, self.current_sound_mapping[movement])
-                    if os.path.exists(sound_file):
-                        try:
-                            data, sr = sf.read(sound_file)
-                            sample_rate = sr
+    # def _create_mixed_composition(self):
+    #     """Create a mixed audio file from all completed layers."""
+    #     try:
+    #         import hashlib
+    #         movement_hash = hashlib.md5(str(sorted(self.movements_completed)).encode()).hexdigest()[:8]
+    #         self.mixed_composition_file = os.path.abspath(f"mixed_composition_{movement_hash}.wav")
+            
+    #         # Try to use the first available completed movement's audio file
+    #         for movement in self.movements_completed:
+    #             if movement in self.current_sound_mapping and self.current_sound_mapping[movement] is not None:
+    #                 sound_file = os.path.join(self.sound_dir, self.current_sound_mapping[movement])
+    #                 if os.path.exists(sound_file):
+    #                     self.mixed_composition_file = os.path.abspath(sound_file)
+    #                     print(f"📀 Using existing audio as mixed composition: {self.mixed_composition_file}")
+    #                     return
+            
+    #         # If file already exists, use it
+    #         if os.path.exists(self.mixed_composition_file):
+    #             print(f"📀 Using existing mixed composition: {self.mixed_composition_file}")
+    #             return
+            
+    #         # Create actual mixed composition by layering completed sounds
+    #         mixed_data = None
+    #         sample_rate = 44100  # Default sample rate
+            
+    #         for movement in self.movements_completed:
+    #             if movement in self.current_sound_mapping and self.current_sound_mapping[movement] is not None:
+    #                 sound_file = os.path.join(self.sound_dir, self.current_sound_mapping[movement])
+    #                 if os.path.exists(sound_file):
+    #                     try:
+    #                         data, sr = sf.read(sound_file)
+    #                         sample_rate = sr
                             
-                            # Convert stereo to mono
-                            if len(data.shape) > 1:
-                                data = np.mean(data, axis=1)
+    #                         # Convert stereo to mono
+    #                         if len(data.shape) > 1:
+    #                             data = np.mean(data, axis=1)
                             
-                            # Initialize or add to mixed data
-                            if mixed_data is None:
-                                mixed_data = data * 0.8  # Reduce volume to prevent clipping
-                            else:
-                                # Ensure same length by padding shorter audio
-                                if len(data) > len(mixed_data):
-                                    mixed_data = np.pad(mixed_data, (0, len(data) - len(mixed_data)))
-                                elif len(mixed_data) > len(data):
-                                    data = np.pad(data, (0, len(mixed_data) - len(data)))
+    #                         # Initialize or add to mixed data
+    #                         if mixed_data is None:
+    #                             mixed_data = data * 0.8  # Reduce volume to prevent clipping
+    #                         else:
+    #                             # Ensure same length by padding shorter audio
+    #                             if len(data) > len(mixed_data):
+    #                                 mixed_data = np.pad(mixed_data, (0, len(data) - len(mixed_data)))
+    #                             elif len(mixed_data) > len(data):
+    #                                 data = np.pad(data, (0, len(mixed_data) - len(data)))
                                 
-                                # Mix the audio (layer them)
-                                mixed_data += data * 0.8
-                        except Exception as e:
-                            print(f"Error mixing {sound_file}: {e}")
-            
-            # Save mixed composition or create silent fallback
-            if mixed_data is not None:
-                # Normalize to prevent clipping
-                max_val = np.max(np.abs(mixed_data))
-                if max_val > 0.95:
-                    mixed_data = mixed_data * 0.95 / max_val
+    #                             # Mix the audio (layer them)
+    #                             mixed_data += data * 0.8
+    #                     except Exception as e:
+    #                         print(f"Error mixing {sound_file}: {e}")
+            
+    #         # Save mixed composition or create silent fallback
+    #         if mixed_data is not None:
+    #             # Normalize to prevent clipping
+    #             max_val = np.max(np.abs(mixed_data))
+    #             if max_val > 0.95:
+    #                 mixed_data = mixed_data * 0.95 / max_val
                 
-                # sf.write(self.mixed_composition_file, mixed_data, sample_rate)
-                print(f"📀 Mixed composition created: {self.mixed_composition_file} (FILE SAVING DISABLED)")
-            else:
-                # Create silent fallback file
-                silent_data = np.zeros(int(sample_rate * 2))  # 2 seconds of silence
-                # sf.write(self.mixed_composition_file, silent_data, sample_rate)
-                print(f"📀 Silent fallback composition created: {self.mixed_composition_file} (FILE SAVING DISABLED)")
+    #             sf.write(self.mixed_composition_file, mixed_data, sample_rate)
+    #             print(f"📀 Mixed composition created: {self.mixed_composition_file} (FILE SAVING ENABLED)")
+    #         else:
+    #             # Create silent fallback file
+    #             silent_data = np.zeros(int(sample_rate * 2))  # 2 seconds of silence
+    #             sf.write(self.mixed_composition_file, silent_data, sample_rate)
+    #             print(f"📀 Silent fallback composition created: {self.mixed_composition_file}")
                 
-        except Exception as e:
-            print(f"Error creating mixed composition: {e}")
-            # Create minimal fallback file with actual content
-            self.mixed_composition_file = os.path.abspath("mixed_composition_fallback.wav")
-            try:
-                # Create a short silent audio file as fallback
-                sample_rate = 44100
-                silent_data = np.zeros(int(sample_rate * 2))  # 2 seconds of silence
-                # sf.write(self.mixed_composition_file, silent_data, sample_rate)
-                print(f"📀 Silent fallback composition created: {self.mixed_composition_file} (FILE SAVING DISABLED)")
-            except Exception as fallback_error:
-                print(f"Failed to create fallback file: {fallback_error}")
-                self.mixed_composition_file = None
+    #     except Exception as e:
+    #         print(f"Error creating mixed composition: {e}")
+    #         # Create minimal fallback file with actual content
+    #         self.mixed_composition_file = os.path.abspath("mixed_composition_fallback.wav")
+    #         try:
+    #             # Create a short silent audio file as fallback
+    #             sample_rate = 44100
+    #             silent_data = np.zeros(int(sample_rate * 2))  # 2 seconds of silence
+    #             sf.write(self.mixed_composition_file, silent_data, sample_rate)
+    #             print(f"📀 Silent fallback composition created: {self.mixed_composition_file}")
+    #         except Exception as fallback_error:
+    #             print(f"Failed to create fallback file: {fallback_error}")
+    #             self.mixed_composition_file = None
     
     def toggle_dj_effect(self, movement: str) -> dict:
-        """Toggle a DJ effect for the given movement and process audio."""
+        """Toggle a DJ effect for the given movement and process the corresponding layer."""
         if self.current_phase != "dj_effects":
             return {"effect_applied": False, "message": "Not in DJ effects phase"}
-        
+
         if movement not in self.active_effects:
             return {"effect_applied": False, "message": f"Unknown movement: {movement}"}
-        
-        # Simple toggle logic, no BPM/beat duration, no auto-off
+
+        # Toggle effect
         self.active_effects[movement] = not self.active_effects[movement]
         effect_status = "ON" if self.active_effects[movement] else "OFF"
         effect_names = {
-            "left_hand": "Volume Fade",
+            "left_hand": "Echo",
             "right_hand": "High Pass Filter",
-            "left_leg": "Reverb Effect", 
+            "left_leg": "Reverb Effect",
             "right_leg": "Low Pass Filter",
-            #"tongue": "Bass Boost"
         }
         effect_name = effect_names.get(movement, movement)
         print(f"🎛️ {effect_name}: {effect_status}")
-        # Process audio with current active effects
-        if self.mixed_composition_file and os.path.exists(self.mixed_composition_file):
-            processed_file = AudioEffectsProcessor.process_with_effects(
-                self.mixed_composition_file, 
-                self.active_effects
+
+        # Find the audio file for this movement
+        sound_file = self.current_sound_mapping.get(movement)
+        audio_path = os.path.join(self.sound_dir, sound_file) if sound_file else None
+        processed_file = None
+        if audio_path and os.path.exists(audio_path):
+            processed_file = AudioEffectsProcessor.process_layer_with_effects(
+                audio_path, movement, self.active_effects
             )
         else:
-            # If no mixed composition exists, create one from current sounds
-            self._create_mixed_composition()
-            # Only process if we successfully created a mixed composition
-            if self.mixed_composition_file and os.path.exists(self.mixed_composition_file):
-                processed_file = AudioEffectsProcessor.process_with_effects(
-                    self.mixed_composition_file, 
-                    self.active_effects
-                )
-            else:
-                print("Failed to create mixed composition, using fallback")
-                processed_file = self.mixed_composition_file
+            print(f"No audio file found for movement: {movement}")
+            processed_file = None
 
+        # For DJ phase, always play all base layers (with effects if toggled)
+        all_layers = {}
+        for m in self.active_movements:
+            sf_name = self.current_sound_mapping.get(m)
+            apath = os.path.join(self.sound_dir, sf_name) if sf_name else None
+            if apath and os.path.exists(apath):
+                all_layers[m] = AudioEffectsProcessor.process_layer_with_effects(
+                    apath, m, self.active_effects
+                )
         return {
             "effect_applied": True,
             "effect_name": effect_name,
             "effect_status": effect_status,
-            "mixed_composition": processed_file
+            "processed_layer": processed_file,
+            "all_layers": all_layers
         }
         
     def get_cycle_success_rate(self) -> float:
@@ -641,8 +652,8 @@ class SoundManager:
         # Create a unique identifier for this composition
         import hashlib
         composition_hash = hashlib.md5(''.join(sorted(audio_files)).encode()).hexdigest()[:8]
-        
-        # FILE SAVING DISABLED: Return first available audio file instead of creating mixed composition
+
+        # FILE SAVING ENABLED: Return first available audio file instead of creating mixed composition
         mixed_audio_path = os.path.join(self.sound_dir, f"mixed_composition_{composition_hash}.wav")
         
         # Since file saving is disabled, use the first available audio file from the list
@@ -650,7 +661,7 @@ class SoundManager:
             # Use the first audio file as the "mixed" composition
             first_audio_file = os.path.join(self.sound_dir, audio_files[0])
             if os.path.exists(first_audio_file):
-                print(f"DEBUG: Using first audio file as mixed composition: {os.path.basename(first_audio_file)} (FILE SAVING DISABLED)")
+                print(f"DEBUG: Using first audio file as mixed composition: {os.path.basename(first_audio_file)}")
                 # Estimate BPM from the mixed composition audio file
                 try:
                     import librosa