How to Improve Lower Volume with Pydub

When working with audio files, you may encounter segments with low volume, making them difficult to hear. In this tutorial, we’ll explore how to use the Pydub library in Python to improve the volume of these low-volume segments and enhance the overall audio quality.

You can follow along with the code examples in this article or access the complete Jupyter Notebook by clicking the button below:

Prerequisites

Before we begin, make sure you have the following prerequisites:

• Python installed on your system
• Pydub library installed (pip install pydub)

Step 1: Increase Low Volume

The first step is to identify the low-volume segments in the audio and increase their volume. Here’s a function that takes an audio segment and increases the volume if it falls below a specified threshold:

from pydub import AudioSegment

def increase_low_volume(audio_segment, threshold=-15, factor=1):
    loudness = audio_segment.dBFS
    if loudness < threshold:
        audio_segment = audio_segment + (threshold - loudness)
    return audio_segment

This function checks the loudness of the audio segment and increases the volume by the difference between the threshold and the actual loudness, if it falls below the threshold.

Step 2: Apply Dynamic Range Compression

Dynamic range compression can help even out the volume levels and make the audio sound more balanced. Here's a function that applies dynamic range compression to an audio segment:

from pydub import AudioSegment
from pydub.effects import compress_dynamic_range

def apply_drc(audio_segment, threshold=-20, ratio=2.0, attack=5, release=50):
    compressed_audio = compress_dynamic_range(
        audio_segment,
        threshold=threshold,
        ratio=ratio,
        attack=attack,
        release=release
    )
    return compressed_audio

This function uses the compress_dynamic_range function from Pydub to apply dynamic range compression with customizable parameters such as threshold, ratio, attack, and release.

Step 3: Improve Low-Volume Segments

To further improve the low-volume segments, we can use the Librosa library to analyze the audio frames and apply gain to the low-volume frames. Here's a function that improves the low-volume segments:

import librosa
import numpy as np
import soundfile as sf

def improve_low_volume_segments(audio_file, output_file, min_volume_dB=-30, target_dB=-10, frame_length=1024, hop_length=512):
    # Load the audio file
    audio, sr = librosa.load(audio_file)

    # Convert audio to mono if it's stereo
    if audio.ndim > 1:
        audio = librosa.to_mono(audio)

    # Calculate the RMS energy of each frame
    rms_energy = librosa.feature.rms(y=audio, frame_length=frame_length, hop_length=hop_length)[0]

    # Convert RMS energy to dB
    rms_db = librosa.amplitude_to_db(rms_energy)

    # Create a gain array filled with ones
    gain = np.ones_like(rms_db)

    # Identify low-volume frames and calculate the required gain
    low_volume_frames = rms_db < min_volume_dB
    gain[low_volume_frames] = target_dB - rms_db[low_volume_frames]

    # Convert gain from dB to linear scale
    gain = librosa.db_to_amplitude(gain)

    # Repeat gain values to match the audio length
    gain_expanded = np.repeat(gain, hop_length)
    gain_expanded = gain_expanded[:len(audio)]  # Truncate gain_expanded to match audio length

    # Apply the gain to the audio
    improved_audio = audio * gain_expanded

    # Normalize the improved audio to avoid clipping
    improved_audio = librosa.util.normalize(improved_audio)

    # Save the improved audio to a file
    sf.write(output_file, improved_audio, sr)

This function loads the audio file, calculates the RMS energy of each frame, identifies the low-volume frames, and applies gain to those frames to bring them up to the target volume level. Finally, it saves the improved audio to an output file.

Step 4: Noise Reduction (Optional)

If the audio contains background noise, you can apply noise reduction using the Noisereduce library. Here's a code snippet that demonstrates noise reduction:

import noisereduce as nr
from scipy.io import wavfile
from pydub import AudioSegment

# Load the MP3 file
mp3_file = "input.mp3"
wav_file = "temp.wav"

# Convert MP3 to WAV
sound = AudioSegment.from_mp3(mp3_file)
sound.export(wav_file, format="wav")

# Load the WAV file
rate, data = wavfile.read(wav_file)

# Perform noise reduction
reduced_noise = nr.reduce_noise(y=data, sr=rate)

# Save the noise-reduced audio as WAV
wavfile.write("output.wav", rate, reduced_noise)

# Convert WAV back to MP3
sound = AudioSegment.from_wav("output.wav")
sound.export("output.mp3", format="mp3")

This code snippet converts the MP3 file to WAV, applies noise reduction using the Noisereduce library, and then converts the noise-reduced audio back to MP3.

Conclusion

Improving low-volume segments in audio files is a common task in audio processing. With the Pydub library and the techniques described in this tutorial, you can easily enhance the volume of low-volume segments and improve the overall audio quality.

Remember to experiment with different parameters and adjust them according to your specific audio files and requirements. Additionally, noise reduction can be applied as an optional step to further enhance the audio quality.

Happy audio processing!