Cómo crear forma de onda desde audio: Python, librerías y métodos visualización

Generar visualización de forma de onda desde archivo audio es tarea fundamental DSP. Ya sea que construyas reproductor podcast, editor audio o visualización datos, aquí tienes tres enfoques — desde librerías one-liner a procesamiento señal raw.

Método 1: Librerías alto nivel (Recomendado — 5 líneas)

Python + Librosa + Matplotlib — maneja decodificación, remuestreo, estéreo-a-mono, normalización automáticamente.

import librosa
import librosa.display
import matplotlib.pyplot as plt

# Carga audio (auto-remuestrea a 22050 Hz mono por defecto)
y, sr = librosa.load("tu_audio.wav")  # o .mp3, .flac, .ogg

# Gráfica forma de onda
plt.figure(figsize=(14, 5))
librosa.display.waveshow(y, sr=sr, alpha=0.8)
plt.title("Forma de onda (Amplitud vs Tiempo)")
plt.xlabel("Tiempo (segundos)")
plt.ylabel("Amplitud")
plt.tight_layout()
plt.savefig("waveform.png", dpi=150)
plt.show()

Instalar: pip install librosa matplotlib numpy

Opciones personalización

  • librosa.load(..., sr=None) — mantiene sample rate nativo.
  • librosa.display.waveshow(..., max_points=50000) — submuestrea para archivos grandes.
  • offset=30, duration=10 — gráfica segmento 10s empezando en 30s.
  • Estilo: color='cyan', linewidth=0.5, fondo oscuro plt.style.use('dark_background').

Método 2: Procesamiento manual (Entender la señal)

Python + wave + NumPy — sin librería DSP, solo std lib + NumPy. Bueno para aprender.

import wave
import numpy as np
import matplotlib.pyplot as plt

# Abre archivo WAV
with wave.open("tu_audio.wav", "rb") as wf:
    n_channels = wf.getnchannels()
    sampwidth = wf.getsampwidth()  # bytes por sample (1, 2, 3, 4)
    framerate = wf.getframerate()
    n_frames = wf.getnframes()
    raw = wf.readframes(n_frames)

# Convierte bytes a array NumPy
dtype = {1: np.int8, 2: np.int16, 3: np.int32, 4: np.int32}[sampwidth]
audio = np.frombuffer(raw, dtype=dtype)

# Maneja estéreo: promedia canales a mono
if n_channels == 2:
    audio = audio.reshape(-1, 2).mean(axis=1)

# Normaliza a [-1, 1]
audio = audio.astype(np.float32) / np.iinfo(dtype).max

# Eje tiempo
time = np.arange(len(audio)) / framerate

# Gráfica
plt.figure(figsize=(14, 5))
plt.plot(time, audio, linewidth=0.5, color='#00d4aa')
plt.title("Forma de onda (Decodificación manual)")
plt.xlabel("Tiempo (s)")
plt.ylabel("Amplitud (normalizada)")
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Pasos clave explicados

  1. wave.open lee headers RIFF/WAV.
  2. getsampwidth determina bit depth → dtype correcto.
  3. frombuffer interpreta bytes raw como enteros.
  4. Estéreo → mono vía media (preserva energía mejor que canal único).
  5. Normaliza por valor entero máximo para dtype (ej. 32767 para int16).
  6. Vector tiempo: índice sample / sample rate.

Método 3: Avanzado — Espectrograma (Frecuencia vs Tiempo)

La forma de onda muestra amplitud. El espectrograma muestra contenido frecuencial en el tiempo — esencial para análisis.

import librosa
import librosa.display
import matplotlib.pyplot as plt
import numpy as np

y, sr = librosa.load("tu_audio.wav", sr=None)
# Calcula espectrograma Mel (frecuencias espaciadas perceptualment)
S = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128, fmax=8000)
S_dB = librosa.power_to_db(S, ref=np.max)

# Gráfica
plt.figure(figsize=(14, 6))
librosa.display.specshow(S_dB, sr=sr, x_axis='time', y_axis='mel', fmax=8000, cmap='magma')
plt.colorbar(format='%+2.0f dB')
plt.title('Espectrograma Mel')
plt.tight_layout()
plt.show()

Otros tipos espectrograma

  • STFT (Lineal): librosa.stft → librosa.amplitude_to_db — espaciado frecuencial lineal.
  • CQT (Constant-Q): librosa.cqt — frecuencial logarítmico, mejor para música.
  • Cromagrama: librosa.feature.chroma_stft — 12 clases tono (análisis armonía).

Alternativa Web / JavaScript

Para visualizador forma de onda en navegador (sin backend):

<canvas id="waveform" width="800" height="200"></canvas>
<script>
const audioCtx = new AudioContext();
fetch('audio.mp3').then(r => r.arrayBuffer())
.then(buf => audioCtx.decodeAudioData(buf))
.then(buffer => {
    const data = buffer.getChannelData(0); // Float32Array [-1,1]
    const canvas = document.getElementById('waveform');
    const ctx = canvas.getContext('2d');
    const step = Math.ceil(data.length / canvas.width);
    ctx.fillStyle = '#00d4aa';
    for (let x = 0; x < canvas.width; x++) {
        const start = x * step;
        const end = Math.min(start + step, data.length);
        let min = 1, max = -1;
        for (let i = start; i < end; i++) {
            min = Math.min(min, data[i]);
            max = Math.max(max, data[i]);
        }
        const yMin = (1 + min) * canvas.height / 2;
        const yMax = (1 + max) * canvas.height / 2;
        ctx.fillRect(x, yMin, 1, yMax - yMin);
    }
});
</script>

Usa Web Audio API decodeAudioData — funciona offline, sin servidor.

Elegir tu enfoque

NecesidadUsar
Script rápido, análisis, investigaciónLibrosa (Método 1)
Aprender DSP, sin dependencias, solo WAVManual (Método 2)
Análisis frecuencia, música, hablaEspectrograma (Método 3)
Visualizador web tiempo realWeb Audio API + Canvas
Producción C++/Rust/Golibsndfile + FFTW / kissfft / rustfft

Para la mayoría tareas Python: Librosa. Maneja casos edge (remuestreo, estéreo, formatos, normalización) que muerden en código manual.