Última actualización: 12 de septiembre

Generar y visualizar formas de onda de audio con Go

Kevin van Zonneveld

Cofundador · Ámsterdam, Países Bajos ·

La visualización de formas de onda de audio es una herramienta potente para quienes trabajan con datos de audio. Ofrece una representación visual de las señales de audio, lo que facilita analizar, editar y mejorar los archivos de audio. En este DevTip, exploraremos cómo puedes generar y visualizar formas de onda de audio con Go, un lenguaje de programación robusto y eficiente para el procesamiento de audio.

Introducción a la visualización de formas de onda y sus aplicaciones

La visualización de formas de onda traduce las señales de audio en representaciones gráficas que, por lo general, muestran la amplitud a lo largo del tiempo. Esta técnica se usa ampliamente en software de edición de audio, producción musical, podcasting e incluso investigación científica. Entre las aplicaciones prácticas se incluyen:

Edición y mezcla de audio
Producción de podcasts y videos
Análisis y diagnóstico de audio
Visualizaciones de audio interactivas para aplicaciones web

Configurar tu entorno de Go para el procesamiento de audio

Dependencias

Antes de comenzar, asegúrate de tener instaladas las siguientes dependencias:

Go 1.16 o posterior
github.com/go-audio/audio v1.0.0
github.com/go-audio/wav v1.1.0
github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b

Primero, asegúrate de tener Go instalado. Puedes verificar tu instalación ejecutando:

go version

Luego, inicializa un nuevo proyecto de Go e instala las dependencias necesarias con versiones específicas para garantizar la reproducibilidad:

mkdir waveform-generator
cd waveform-generator
go mod init waveform-generator
go get github.com/go-audio/audio@v1.0.0
go get github.com/go-audio/wav@v1.1.0
go get github.com/ajstarks/svgo@v0.0.0-20211024235047-1546f124cd8b

Generar formas de onda básicas (senoidal, cuadrada, triangular) con Go

Así puedes generar una forma de onda senoidal simple con Go, incluyendo un manejo de errores adecuado y validación de la entrada:

package main

import (
	"fmt"
	"log"
	"math"
	"os"

	"github.com/go-audio/audio"
	"github.com/go-audio/wav"
)

func generateWaveform() error {
	const sampleRate = 44100
	const frequency = 440.0 // A4 note
	const duration = 2      // seconds

	// Validate input parameters
	if sampleRate <= 0 || duration <= 0 || frequency <= 0 {
		return fmt.Errorf("sampleRate, duration, and frequency must be positive")
	}

	numSamples := sampleRate * duration
	buf := &audio.IntBuffer{
		Format: &audio.Format{NumChannels: 1, SampleRate: sampleRate},
		Data:   make([]int, numSamples),
	}

	// Generate sine wave
	amplitude := 32767.0 // Max amplitude for 16-bit audio
	for i := 0; i < numSamples; i++ {
		time := float64(i) / float64(sampleRate)
		buf.Data[i] = int(amplitude * math.Sin(2*math.Pi*frequency*time))
	}

	// Create output file with proper error handling
	f, err := os.OpenFile("sine.wav", os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
	if err != nil {
		return fmt.Errorf("create sine.wav: %w", err)
	}
	completed := false
	defer func() {
		f.Close()
		if !completed {
			os.Remove(f.Name())
		}
	}()

	// Encode audio data to WAV format
	// Parameters: output io.WriteSeeker, sample rate, bit depth, num channels, audio format (1 = PCM)
	encoder := wav.NewEncoder(f, sampleRate, 16, 1, 1)
	if err := encoder.Write(buf); err != nil {
		return fmt.Errorf("write WAV data: %w", err)
	}
	// Close the encoder to finalize the WAV file
	if err := encoder.Close(); err != nil {
		return fmt.Errorf("finalize WAV: %w", err)
	}
	if err := f.Close(); err != nil {
		return err
	}
	completed = true
	return nil
}

func main() {
	if err := generateWaveform(); err != nil {
		log.Fatal(err)
	}
	log.Println("Successfully generated sine.wav")
}

Para generar una onda cuadrada, reemplaza la declaración de amplitude y el bucle de generación senoidal por:

// Generate square wave
amplitude := 32767.0
for i := 0; i < numSamples; i++ {
	time := float64(i) / float64(sampleRate)
	if math.Sin(2*math.Pi*frequency*time) >= 0 {
		buf.Data[i] = int(amplitude)
	} else {
		buf.Data[i] = int(-amplitude)
	}
}

Para una onda triangular, reemplaza esa misma declaración y ese mismo bucle por:

// Generate triangle wave
amplitude := 32767.0
period := float64(sampleRate) / frequency
for i := 0; i < numSamples; i++ {
	// Calculate phase within the period (0.0 to 1.0)
	phase := math.Mod(float64(i), period) / period
	if phase < 0.5 {
		// Rising edge: scales from -1 to 1 over the first half
		buf.Data[i] = int(amplitude * (phase*4.0 - 1.0))
	} else {
		// Falling edge: scales from 1 to -1 over the second half
		buf.Data[i] = int(amplitude * (3.0 - phase*4.0))
	}
}

Visualizar formas de onda con SVG

Guarda el siguiente programa por separado del generador y ejecútalo después de crear sine.wav. Acepta archivos WAV con PCM entero y muestras de 8, 16, 24 o 32 bits, y grafica el primer canal a lo largo de toda la duración. Muestrea un frame por píxel, por lo que esta vista general puede pasar por alto picos breves; usa una agregación de mínimo/máximo por píxel cuando necesites una envolvente de amplitud. Ambos programas se niegan a sobrescribir archivos de salida existentes.

package main

import (
	"bufio"
	"fmt"
	"log"
	"math"
	"os"

	"github.com/ajstarks/svgo"
	"github.com/go-audio/wav"
)

func visualizeWaveform() error {
	// Open the WAV file
	file, err := os.Open("sine.wav") // Or any other .wav file
	if err != nil {
		return fmt.Errorf("open audio file: %w", err)
	}
	defer func() {
		if err := file.Close(); err != nil {
			log.Printf("Warning: Failed to close audio file: %v", err)
		}
	}()

	// Create a new decoder
	decoder := wav.NewDecoder(file)
	if !decoder.IsValidFile() {
		return fmt.Errorf("invalid WAV file")
	}
	if decoder.WavAudioFormat != 1 {
		return fmt.Errorf("only integer PCM WAV files are supported")
	}

	// Read the full PCM buffer
	// Note: For large audio files, consider processing the audio in chunks
	// rather than loading the entire file into memory with FullPCMBuffer().
	buf, err := decoder.FullPCMBuffer()
	if err != nil {
		return fmt.Errorf("read PCM data: %w", err)
	}
	channels := buf.Format.NumChannels
	if channels <= 0 || len(buf.Data) == 0 || len(buf.Data)%channels != 0 {
		return fmt.Errorf("empty or incomplete PCM frames")
	}
	if buf.SourceBitDepth != 8 && buf.SourceBitDepth != 16 && buf.SourceBitDepth != 24 && buf.SourceBitDepth != 32 {
		return fmt.Errorf("unsupported PCM bit depth: %d", buf.SourceBitDepth)
	}

	// Define SVG dimensions
	width := 800
	height := 200
	centerY := height / 2

	// Create SVG file
	svgFile, err := os.OpenFile("waveform.svg", os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
	if err != nil {
		return fmt.Errorf("create waveform.svg: %w", err)
	}
	completed := false
	defer func() {
		svgFile.Close()
		if !completed {
			os.Remove(svgFile.Name())
		}
	}()

	// Initialize SVG canvas
	writer := bufio.NewWriter(svgFile)
	canvas := svg.New(writer)
	canvas.Start(width, height)
	canvas.Rect(0, 0, width, height, "fill:white") // Background

	// Draw center line
	canvas.Line(0, centerY, width, centerY, "stroke:#cccccc;stroke-width:1")

	// WAV samples are interleaved by channel; choose the first channel in each frame.
	numFrames := len(buf.Data) / channels
	sampleAt := func(x int) float64 {
		frame := x * numFrames / width
		sample := float64(buf.Data[frame*channels])
		// 8-bit WAV PCM is unsigned.
		if buf.SourceBitDepth == 8 {
			sample -= 128
		}
		return sample
	}

	// Draw waveform lines from center to amplitude
	maxAmplitude := math.Ldexp(1, buf.SourceBitDepth-1)
	scale := float64(centerY) / maxAmplitude // Scale factor for amplitude to fit height

	for x := 0; x < width; x++ {
		sampleValue := sampleAt(x)
		// Calculate y coordinate, inverting for SVG (0 is top)
		y := centerY - int(sampleValue*scale)
		canvas.Line(x, centerY, x, y, "stroke:#0066cc;stroke-width:1")
	}

	canvas.End()
	if err := writer.Flush(); err != nil {
		return err
	}
	if err := svgFile.Close(); err != nil {
		return err
	}
	completed = true
	return nil
}

func main() {
	if err := visualizeWaveform(); err != nil {
		log.Fatal(err)
	}
	log.Println("Successfully generated waveform.svg")
}

Técnicas avanzadas de personalización de formas de onda

Puedes mejorar tus visualizaciones SVG con estas técnicas:

Ajustar los colores y el grosor de línea

Reemplaza las instrucciones de dibujo del fondo, la línea central y la forma de onda por estos estilos, conservando los cálculos de sampleAt y scale:

// Define custom colors and styles
backgroundColor := "#f5f5f5"
waveformColor := "#2a9d8f"
centerLineColor := "#e76f51"
waveformStrokeWidth := 2

// Apply to SVG
canvas.Rect(0, 0, width, height, "fill:"+backgroundColor)
canvas.Line(0, centerY, width, centerY, "stroke:"+centerLineColor+";stroke-width:1")

// Draw waveform with custom style
for x := 0; x < width; x++ {
	sampleValue := sampleAt(x)
	y := centerY - int(sampleValue*scale)
	// Use fmt.Sprintf for cleaner style string construction
	style := fmt.Sprintf("stroke:%s;stroke-width:%d", waveformColor, waveformStrokeWidth)
	canvas.Line(x, centerY, x, y, style)
}

Crear una forma de onda rellena

Reemplaza el bucle de la línea de la forma de onda por un polígono para lograr una visualización estilo gráfico de área:

// Draw a filled waveform (area chart style)
fillColor := "#2a9d8f"
fillOpacity := 0.5

// Collect points for the polygon (top edge)
// Allocate slice capacity for efficiency
xs := make([]int, 0, width+2)
ys := make([]int, 0, width+2)
xs = append(xs, 0)
ys = append(ys, centerY)

lastX := 0
for x := 0; x < width; x++ {
	sampleValue := sampleAt(x)
	y := centerY - int(sampleValue*scale)
	xs = append(xs, x)
	ys = append(ys, y)
	lastX = x
}

// Add the final point on the center line to close the shape
xs = append(xs, lastX)
ys = append(ys, centerY)

// Draw the polygon
style := fmt.Sprintf("fill:%s;fill-opacity:%.2f;stroke:none", fillColor, fillOpacity)
canvas.Polygon(xs, ys, style)

Casos de uso prácticos e ideas de proyectos

Estas son algunas ideas para integrar la visualización de formas de onda en tus proyectos de Go:

Herramientas de edición de audio: muestra formas de onda para ayudar a los usuarios a identificar y editar partes específicas de los archivos de audio.
Plataformas de alojamiento de podcasts: muestra las formas de onda de los episodios para que los oyentes naveguen visualmente por el contenido.
Reproductores de música interactivos: crea visualizaciones adaptables que reaccionen a la música que se está reproduciendo.
Herramientas educativas: visualiza distintas formas de onda (senoidal, cuadrada, triangular, diente de sierra) para enseñar conceptos de ingeniería de audio.
Aplicaciones de análisis del habla: identifica patrones como pausas o cambios de volumen en grabaciones de voz mediante el análisis de formas de onda.

Conclusión y recursos adicionales

La generación y visualización de formas de onda en Go son sencillas y potentes, y te permiten crear visualizaciones de audio detalladas con rapidez. La combinación del rendimiento de Go con la flexibilidad de SVG la convierte en una excelente opción para diversas aplicaciones de procesamiento de audio.

Para explorar más a fondo, considera estos recursos:

Si necesitas generar formas de onda a partir de varios formatos de audio a gran escala, considera usar un servicio dedicado. El 🤖 Robot /audio/waveform de Transloadit admite varios formatos de salida (imagen o JSON), dimensiones personalizables (ancho/alto), colores de fondo y de la forma de onda, y opciones de anti-aliasing como parte de nuestro servicio de Encoding de audio. Este Robot puede agilizar la generación de formas de onda en tus flujos de trabajo de producción.