Noise reduction working, bug in plosive detection algo

app.py

@@ -1,37 +1,72 @@
 import streamlit as st
 import noisereduce as nr
-import soundfile as sf
-from pedalboard import NoiseGate, Compressor
+from pedalboard.io import AudioFile
+from pedalboard import *
 import numpy as np
 from io import BytesIO
-
-# Function to remove background noise and process audio
+import librosa
 
 
 def process_audio(input_file):
-    # Load the audio file
-    data, sr = sf.read(input_file)
-
-    # Reduce stationary noise using noisereduce
-    reduced_noise = nr.reduce_noise(y=data, sr=sr)
+    sr = 44100
+    with AudioFile(input_file).resampled_to(sr) as f:
+        audio = f.read(f.frames)
 
-    # Create a noise gate to further reduce noise using pedalboard
-    noise_gate = NoiseGate(threshold=0.02, attack=10, release=100)
-    # Create a compressor to enhance the audio
-    compressor = Compressor(threshold_db=-25, ratio=3,
-                            attack_ms=10, release_ms=200)
+    # Reduce stationary noise
+    reduced_noise = nr.reduce_noise(
+        y=audio, sr=sr, stationary=True, prop_decrease=0.75)
 
-    # Create a pedalboard and add the noise gate and compressor to it
-    board = noise_gate >> compressor
+    # Apply audio effects
+    board = Pedalboard([
+        NoiseGate(threshold_db=-30, ratio=1.5, release_ms=250),
+        Compressor(threshold_db=-16, ratio=2.5),
+        LowShelfFilter(cutoff_frequency_hz=400, gain_db=10, q=1),
+        Gain(gain_db=10)
+    ])
 
-    # Process the audio through the pedalboard
-    processed_audio = board(np.array([reduced_noise]))
+    processed_audio = board(reduced_noise, sr)
 
     return processed_audio, sr
 
 
+def detect_plosives(audio, sr):
+    # Define frequency bands for plosive detection
+    frequency_bands = [(0, 200), (200, 500)]
+
+    # Calculate short-time Fourier transform (STFT)
+    stft = librosa.stft(audio)
+
+    # Convert amplitude to energy (power) spectrogram
+    power = np.abs(stft) ** 2
+
+    # Calculate energy in each frequency band
+    band_energies = []
+    for band in frequency_bands:
+        freq_range = librosa.core.fft_frequencies(sr=sr)
+        indices = np.where((freq_range >= band[0]) & (freq_range < band[1]))[0]
+        if len(indices) > 0:  # Check if indices exist before proceeding
+            # Sum along frequency axis
+            band_energy = np.sum(power[indices, :], axis=0)
+            band_energies.append(band_energy)
+
+    if not band_energies:  # If no bands have energy, return empty plosives
+        return []
+
+    # Calculate overall energy as the sum of energy in all bands
+    overall_energy = np.sum(band_energies, axis=0)
+
+    # Apply thresholding to detect plosives
+    threshold = np.max(overall_energy) * 0.5
+    plosive_frames = np.where(overall_energy > threshold)[0]
+
+    # Convert frame indices to time in seconds
+    plosives = librosa.frames_to_time(plosive_frames, sr=sr)
+
+    return plosives
+
+
 def main():
-    st.title("Background Noise Reduction")
+    st.title("Audio Enhancement")
 
     # Upload audio file
     uploaded_file = st.file_uploader("Upload audio file", type=["wav"])
@@ -42,23 +77,37 @@ def main():
         processed_audio, sr = process_audio(uploaded_file)
 
         # Display processing progress
-        with st.spinner('Processing audio...'):
-            processed_audio_bytes = BytesIO()
-            sf.write(processed_audio_bytes,
-                     processed_audio[0], sr, format='wav')
-            st.write("Audio processed successfully!")
-
-        # Allow user to play original and edited audio
-        st.subheader("Play Audio")
-        st.audio(uploaded_file, format='audio/wav',
-                 start_time=0, caption='Original Audio')
-        st.audio(processed_audio_bytes, format='audio/wav',
-                 start_time=0, caption='Processed Audio')
+        st.write("Audio processed successfully!")
+
+        # Allow user to play original and processed audio
+        # st.subheader("Play Audio")
+        # st.audio(uploaded_file, format='audio/wav', start_time=0)
+        # st.audio(processed_audio, format='audio/wav',
+        #          start_time=0, sample_rate=None)
+        st.subheader("Play Origional Audio")
+        st.audio(uploaded_file, format='audio/wav', start_time=0)
+        st.subheader("Play Enhanced Audio")
+        st.audio(processed_audio, format='audio/wav',
+                 start_time=0, sample_rate=sr)
 
         # Allow user to download processed audio
-        st.subheader("Download Processed Audio")
-        st.download_button("Download", processed_audio_bytes.getvalue(
-        ), file_name="processed_audio.wav", mime='audio/wav')
+        st.subheader("Download Enhanced Audio")
+        processed_audio_bytes = BytesIO()
+        with AudioFile(processed_audio_bytes, 'w', sr, len(processed_audio), format='wav') as f:
+            f.write(processed_audio)
+        st.download_button("Download", processed_audio_bytes.getvalue(),
+                           file_name="processed_audio.wav", mime='audio/wav')
+
+        # Button to detect plosives
+        if st.button("Detect Plosives"):
+            st.write("Detecting plosives...")
+            plosives = detect_plosives(processed_audio, sr)
+            if plosives:
+                st.subheader("Detected Plosives")
+                st.write("Plosives detected at time(s):", ", ".join(
+                    [str(round(p, 2)) for p in plosives]))
+            else:
+                st.write("No plosives detected.")
 
 
 if __name__ == "__main__":