import librosa import numpy as np try: import matplotlib.pyplot as plt except ImportError: plt = None from scipy.stats import mode import warnings warnings.filterwarnings('ignore') # Suppress librosa warnings class MusicAnalyzer: def __init__(self): # Emotion feature mappings - these define characteristics of different emotions self.emotion_profiles = { 'happy': {'tempo': (100, 180), 'energy': (0.6, 1.0), 'major_mode': True, 'brightness': (0.6, 1.0)}, 'sad': {'tempo': (40, 90), 'energy': (0, 0.5), 'major_mode': False, 'brightness': (0, 0.5)}, 'calm': {'tempo': (50, 90), 'energy': (0, 0.4), 'major_mode': True, 'brightness': (0.3, 0.6)}, 'energetic': {'tempo': (110, 200), 'energy': (0.7, 1.0), 'major_mode': True, 'brightness': (0.5, 0.9)}, 'tense': {'tempo': (70, 140), 'energy': (0.5, 0.9), 'major_mode': False, 'brightness': (0.3, 0.7)}, 'nostalgic': {'tempo': (60, 100), 'energy': (0.3, 0.7), 'major_mode': None, 'brightness': (0.4, 0.7)} } # Theme mappings based on musical features self.theme_profiles = { 'love': {'emotion': ['happy', 'nostalgic', 'sad'], 'harmony_complexity': (0.3, 0.7)}, 'triumph': {'emotion': ['energetic', 'happy'], 'harmony_complexity': (0.4, 0.8)}, 'loss': {'emotion': ['sad', 'nostalgic'], 'harmony_complexity': (0.3, 0.7)}, 'adventure': {'emotion': ['energetic', 'tense'], 'harmony_complexity': (0.5, 0.9)}, 'reflection': {'emotion': ['calm', 'nostalgic'], 'harmony_complexity': (0.4, 0.8)}, 'conflict': {'emotion': ['tense', 'energetic'], 'harmony_complexity': (0.6, 1.0)} } # Musical key mapping self.key_names = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'] def load_audio(self, file_path, sr=22050, duration=None): """Load audio file and return time series and sample rate""" try: y, sr = librosa.load(file_path, sr=sr, duration=duration) return y, sr except Exception as e: print(f"Error loading audio file: {e}") return None, None def analyze_rhythm(self, y, sr): """Analyze rhythm-related features: tempo, beats, time signature""" # Tempo and beat detection onset_env = librosa.onset.onset_strength(y=y, sr=sr) tempo, beat_frames = librosa.beat.beat_track(onset_envelope=onset_env, sr=sr) beat_times = librosa.frames_to_time(beat_frames, sr=sr) # Beat intervals and regularity beat_intervals = np.diff(beat_times) if len(beat_times) > 1 else np.array([0]) beat_regularity = 1.0 / np.std(beat_intervals) if len(beat_intervals) > 0 and np.std(beat_intervals) > 0 else 0 # Rhythm pattern analysis through autocorrelation ac = librosa.autocorrelate(onset_env, max_size=sr // 2) ac = librosa.util.normalize(ac, norm=np.inf) # Time signature estimation - a challenging task with many limitations estimated_signature = self._estimate_time_signature(y, sr, beat_times, onset_env) # Compute onset strength to get a measure of rhythm intensity rhythm_intensity = np.mean(onset_env) / np.max(onset_env) if np.max(onset_env) > 0 else 0 # Rhythm complexity based on variation in onset strength rhythm_complexity = np.std(onset_env) / np.mean(onset_env) if np.mean(onset_env) > 0 else 0 return { "tempo": float(tempo), "beat_times": beat_times.tolist(), "beat_intervals": beat_intervals.tolist(), "beat_regularity": float(beat_regularity), "rhythm_intensity": float(rhythm_intensity), "rhythm_complexity": float(rhythm_complexity), "estimated_time_signature": estimated_signature } def _estimate_time_signature(self, y, sr, beat_times, onset_env): """Estimate the time signature based on beat patterns""" # This is a simplified approach - accurate time signature detection is complex if len(beat_times) < 4: return "Unknown" # Analyze beat emphasis patterns to detect meter beat_intervals = np.diff(beat_times) # Look for periodicity in the onset envelope ac = librosa.autocorrelate(onset_env, max_size=sr) # Find peaks in autocorrelation after the first one (which is at lag 0) peaks = librosa.util.peak_pick(ac, pre_max=20, post_max=20, pre_avg=20, post_avg=20, delta=0.1, wait=1) peaks = peaks[peaks > 0] # Remove the first peak which is at lag 0 if len(peaks) == 0: return "4/4" # Default to most common # Convert first significant peak to beats first_peak_time = peaks[0] / sr beats_per_bar = round(first_peak_time / np.median(beat_intervals)) # Map to common time signatures if beats_per_bar == 4 or beats_per_bar == 8: return "4/4" elif beats_per_bar == 3 or beats_per_bar == 6: return "3/4" elif beats_per_bar == 2: return "2/4" else: return f"{beats_per_bar}/4" # Default assumption def analyze_tonality(self, y, sr): """Analyze tonal features: key, mode, harmonic features""" # Compute chromagram chroma = librosa.feature.chroma_cqt(y=y, sr=sr) # Krumhansl-Schmuckler key-finding algorithm (simplified) # Major and minor profiles from music theory research major_profile = np.array([6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88]) minor_profile = np.array([6.33, 2.68, 3.52, 5.38, 2.60, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17]) # Calculate the correlation of the chroma with each key profile chroma_avg = np.mean(chroma, axis=1) major_corr = np.zeros(12) minor_corr = np.zeros(12) for i in range(12): major_corr[i] = np.corrcoef(np.roll(chroma_avg, i), major_profile)[0, 1] minor_corr[i] = np.corrcoef(np.roll(chroma_avg, i), minor_profile)[0, 1] # Find the key with the highest correlation max_major_idx = np.argmax(major_corr) max_minor_idx = np.argmax(minor_corr) # Determine if the piece is in a major or minor key if major_corr[max_major_idx] > minor_corr[max_minor_idx]: mode = "major" key = self.key_names[max_major_idx] else: mode = "minor" key = self.key_names[max_minor_idx] # Calculate harmony complexity (variability in harmonic content) harmony_complexity = np.std(chroma) / np.mean(chroma) if np.mean(chroma) > 0 else 0 # Calculate tonal stability (consistency of tonal center) tonal_stability = 1.0 / (np.std(chroma_avg) + 0.001) # Add small value to avoid division by zero # Calculate spectral brightness (center of mass of the spectrum) spectral_centroid = librosa.feature.spectral_centroid(y=y, sr=sr)[0] brightness = np.mean(spectral_centroid) / (sr/2) # Normalize by Nyquist frequency # Calculate dissonance using spectral contrast spectral_contrast = librosa.feature.spectral_contrast(y=y, sr=sr) dissonance = np.mean(spectral_contrast[0]) # Higher values may indicate more dissonance return { "key": key, "mode": mode, "is_major": mode == "major", "harmony_complexity": float(harmony_complexity), "tonal_stability": float(tonal_stability), "brightness": float(brightness), "dissonance": float(dissonance) } def analyze_energy(self, y, sr): """Analyze energy characteristics of the audio""" # RMS Energy (overall loudness) rms = librosa.feature.rms(y=y)[0] # Energy metrics mean_energy = np.mean(rms) energy_std = np.std(rms) energy_dynamic_range = np.max(rms) - np.min(rms) if len(rms) > 0 else 0 # Energy distribution across frequency ranges spec = np.abs(librosa.stft(y)) # Divide the spectrum into low, mid, and high ranges freq_bins = spec.shape[0] low_freq_energy = np.mean(spec[:int(freq_bins*0.2), :]) mid_freq_energy = np.mean(spec[int(freq_bins*0.2):int(freq_bins*0.8), :]) high_freq_energy = np.mean(spec[int(freq_bins*0.8):, :]) # Normalize to create a distribution total_energy = low_freq_energy + mid_freq_energy + high_freq_energy if total_energy > 0: low_freq_ratio = low_freq_energy / total_energy mid_freq_ratio = mid_freq_energy / total_energy high_freq_ratio = high_freq_energy / total_energy else: low_freq_ratio = mid_freq_ratio = high_freq_ratio = 1/3 return { "mean_energy": float(mean_energy), "energy_std": float(energy_std), "energy_dynamic_range": float(energy_dynamic_range), "frequency_distribution": { "low_freq": float(low_freq_ratio), "mid_freq": float(mid_freq_ratio), "high_freq": float(high_freq_ratio) } } def analyze_emotion(self, rhythm_data, tonal_data, energy_data): """Classify the emotion based on musical features""" # Extract key features for emotion detection tempo = rhythm_data["tempo"] is_major = tonal_data["is_major"] energy = energy_data["mean_energy"] brightness = tonal_data["brightness"] # Calculate scores for each emotion emotion_scores = {} for emotion, profile in self.emotion_profiles.items(): score = 0.0 # Tempo contribution (0-1 score) tempo_range = profile["tempo"] if tempo_range[0] <= tempo <= tempo_range[1]: score += 1.0 else: # Partial score based on distance distance = min(abs(tempo - tempo_range[0]), abs(tempo - tempo_range[1])) max_distance = 40 # Maximum distance to consider score += max(0, 1 - (distance / max_distance)) # Energy contribution (0-1 score) energy_range = profile["energy"] if energy_range[0] <= energy <= energy_range[1]: score += 1.0 else: # Partial score based on distance distance = min(abs(energy - energy_range[0]), abs(energy - energy_range[1])) max_distance = 0.5 # Maximum distance to consider score += max(0, 1 - (distance / max_distance)) # Mode contribution (0-1 score) if profile["major_mode"] is not None: # Some emotions don't have strong mode preference score += 1.0 if profile["major_mode"] == is_major else 0.0 else: score += 0.5 # Neutral contribution # Brightness contribution (0-1 score) brightness_range = profile["brightness"] if brightness_range[0] <= brightness <= brightness_range[1]: score += 1.0 else: # Partial score based on distance distance = min(abs(brightness - brightness_range[0]), abs(brightness - brightness_range[1])) max_distance = 0.5 # Maximum distance to consider score += max(0, 1 - (distance / max_distance)) # Normalize score (0-1 range) emotion_scores[emotion] = score / 4.0 # Find primary emotion primary_emotion = max(emotion_scores.items(), key=lambda x: x[1]) # Calculate valence and arousal (dimensional emotion model) # Mapping different emotions to valence-arousal space valence_map = { 'happy': 0.8, 'sad': 0.2, 'calm': 0.6, 'energetic': 0.7, 'tense': 0.3, 'nostalgic': 0.5 } arousal_map = { 'happy': 0.7, 'sad': 0.3, 'calm': 0.2, 'energetic': 0.9, 'tense': 0.8, 'nostalgic': 0.4 } # Calculate weighted valence and arousal total_weight = sum(emotion_scores.values()) if total_weight > 0: valence = sum(score * valence_map[emotion] for emotion, score in emotion_scores.items()) / total_weight arousal = sum(score * arousal_map[emotion] for emotion, score in emotion_scores.items()) / total_weight else: valence = 0.5 arousal = 0.5 return { "primary_emotion": primary_emotion[0], "confidence": primary_emotion[1], "emotion_scores": emotion_scores, "valence": float(valence), # Pleasure dimension (0-1) "arousal": float(arousal) # Activity dimension (0-1) } def analyze_theme(self, rhythm_data, tonal_data, emotion_data): """Infer potential themes based on musical features and emotion""" # Extract relevant features primary_emotion = emotion_data["primary_emotion"] harmony_complexity = tonal_data["harmony_complexity"] # Calculate theme scores theme_scores = {} for theme, profile in self.theme_profiles.items(): score = 0.0 # Emotion contribution if primary_emotion in profile["emotion"]: # Emotions listed earlier have stronger connection to the theme position_weight = 1.0 / (profile["emotion"].index(primary_emotion) + 1) score += position_weight # Secondary emotions contribution secondary_emotions = [e for e, s in emotion_data["emotion_scores"].items() if s > 0.5 and e != primary_emotion] for emotion in secondary_emotions: if emotion in profile["emotion"]: score += 0.3 # Less weight than primary emotion # Harmony complexity contribution complexity_range = profile["harmony_complexity"] if complexity_range[0] <= harmony_complexity <= complexity_range[1]: score += 1.0 else: # Partial score based on distance distance = min(abs(harmony_complexity - complexity_range[0]), abs(harmony_complexity - complexity_range[1])) max_distance = 0.5 # Maximum distance to consider score += max(0, 1 - (distance / max_distance)) # Normalize score theme_scores[theme] = min(1.0, score / 2.5) # Find primary theme primary_theme = max(theme_scores.items(), key=lambda x: x[1]) # Find secondary themes (scores > 0.5) secondary_themes = [(theme, score) for theme, score in theme_scores.items() if score > 0.5 and theme != primary_theme[0]] secondary_themes.sort(key=lambda x: x[1], reverse=True) return { "primary_theme": primary_theme[0], "confidence": primary_theme[1], "secondary_themes": [t[0] for t in secondary_themes[:2]], # Top 2 secondary themes "theme_scores": theme_scores } def analyze_music(self, file_path): """Main function to perform comprehensive music analysis""" # Load the audio file y, sr = self.load_audio(file_path) if y is None: return {"error": "Failed to load audio file"} # Run all analyses rhythm_data = self.analyze_rhythm(y, sr) tonal_data = self.analyze_tonality(y, sr) energy_data = self.analyze_energy(y, sr) # Higher-level analyses that depend on the basic features emotion_data = self.analyze_emotion(rhythm_data, tonal_data, energy_data) theme_data = self.analyze_theme(rhythm_data, tonal_data, emotion_data) # Combine all results return { "file": file_path, "rhythm_analysis": rhythm_data, "tonal_analysis": tonal_data, "energy_analysis": energy_data, "emotion_analysis": emotion_data, "theme_analysis": theme_data, "summary": { "tempo": rhythm_data["tempo"], "time_signature": rhythm_data["estimated_time_signature"], "key": tonal_data["key"], "mode": tonal_data["mode"], "primary_emotion": emotion_data["primary_emotion"], "primary_theme": theme_data["primary_theme"] } } # def visualize_analysis(self, file_path): # """Create visualizations for the music analysis results""" # # Check if matplotlib is available # if plt is None: # print("Error: matplotlib is not installed. Visualization is not available.") # return # # # Load audio and run analysis # y, sr = self.load_audio(file_path) # if y is None: # print("Error: Failed to load audio file") # return # # results = self.analyze_music(file_path) # # # Create visualization # plt.figure(figsize=(15, 12)) # # Waveform # plt.subplot(3, 2, 1) # librosa.display.waveshow(y, sr=sr, alpha=0.6) # plt.title(f'Waveform (Tempo: {results["rhythm_analysis"]["tempo"]:.1f} BPM)') # # Spectrogram # plt.subplot(3, 2, 2) # D = librosa.amplitude_to_db(np.abs(librosa.stft(y)), ref=np.max) # librosa.display.specshow(D, sr=sr, x_axis='time', y_axis='log') # plt.colorbar(format='%+2.0f dB') # plt.title(f'Spectrogram (Key: {results["tonal_analysis"]["key"]} {results["tonal_analysis"]["mode"]})') # # Chromagram # plt.subplot(3, 2, 3) # chroma = librosa.feature.chroma_cqt(y=y, sr=sr) # librosa.display.specshow(chroma, y_axis='chroma', x_axis='time') # plt.colorbar() # plt.title('Chromagram') # # Onset strength and beats # plt.subplot(3, 2, 4) # onset_env = librosa.onset.onset_strength(y=y, sr=sr) # times = librosa.times_like(onset_env, sr=sr) # plt.plot(times, librosa.util.normalize(onset_env), label='Onset strength') # plt.vlines(results["rhythm_analysis"]["beat_times"], 0, 1, alpha=0.5, color='r', # linestyle='--', label='Beats') # plt.legend() # plt.title('Rhythm Analysis') # # Emotion scores # plt.subplot(3, 2, 5) # emotions = list(results["emotion_analysis"]["emotion_scores"].keys()) # scores = list(results["emotion_analysis"]["emotion_scores"].values()) # plt.bar(emotions, scores, color='skyblue') # plt.ylim(0, 1) # plt.title(f'Emotion Analysis (Primary: {results["emotion_analysis"]["primary_emotion"]})') # plt.xticks(rotation=45) # # Theme scores # plt.subplot(3, 2, 6) # themes = list(results["theme_analysis"]["theme_scores"].keys()) # scores = list(results["theme_analysis"]["theme_scores"].values()) # plt.bar(themes, scores, color='lightgreen') # plt.ylim(0, 1) # plt.title(f'Theme Analysis (Primary: {results["theme_analysis"]["primary_theme"]})') # plt.xticks(rotation=45) # plt.tight_layout() # plt.show() # Create an instance of the analyzer analyzer = MusicAnalyzer() # The following code is for demonstration purposes only # and will only run if executed directly (not when imported) if __name__ == "__main__": # Replace this with a real audio file path when running as a script demo_file = "path/to/your/audio/file.mp3" # Analyze the uploaded audio file results = analyzer.analyze_music(demo_file) # Print analysis summary print("\n=== MUSIC ANALYSIS SUMMARY ===") print(f"Tempo: {results['summary']['tempo']:.1f} BPM") print(f"Time Signature: {results['summary']['time_signature']}") print(f"Key: {results['summary']['key']} {results['summary']['mode']}") print(f"Primary Emotion: {results['summary']['primary_emotion']}") print(f"Primary Theme: {results['summary']['primary_theme']}") # Show detailed results (optional) import json print("\n=== DETAILED ANALYSIS ===") print(json.dumps(results, indent=2)) # Visualize the analysis # analyzer.visualize_analysis(demo_file)