Hace un tiempo escribí un par de funciones para trabajar con wavs en python como si fuesen vectores, es decir, al “estilo” matlab (para más detalles ver este post “Funciones para trabajar con wav’s vectorialmente en python“).

Casualmente en la misma semana 2 personas, Cesar Perez (Colombia) y Elizabeth Coixet (España), me escribieron a este blog comentandome que estaban usando mis funciones con éxito pero tenian problemas al leer wav’s de 8 bits. Les recomendé que lo charlaramos en el grupo Buena Señal ya que entre todos (y posiblemente alguna contribución de alguno más de los del grupo) seguramente iba a ser más fácil y todos podriamos aprender algo de ello (ver estos 2 threads: 1, 2).

Y asi fue

Luego de que Cesar planteara el problema y yo hiciese mis apreciaciones sobre el asunto, Elizabeth encontró que el wav de 8 bits era unsigned y no signed (como el de 16 bits) con lo que se termino de resolver el misterio de porque la solución que manejabamos leia en forma extraña…

Bueno la función queda asi:

# Example: [ y, Fs, bits ] = wavread8bits( 'filename' )
def wavread8bits( name ):
	file = wave.open( name, 'r' )
	[Channels,Bytes,Fs,Frames,Compress,CompressName] = file.getparams() # (nchannels, sampwidth in bytes, sampling frequency, nframes, comptype, compname)
	Bits = Bytes*8 # 8 bits per sample
	Data = file.readframes( Frames )
	Data = (fromstring( Data, UInt8 ) / 128.0 ) - 1.0 # -1..1 values
	print "Fs: ",Fs,"\nBits: ",Bits,"\nChannels: ",Channels
	file.close()
	return Data, Fs, Bits

 
De paso también escribí la función para escribir un wav de 8 bits.

# Example: wavwrite8bits( y, Fs, filename )
def wavwrite8bits( data_array, Fs, name ):
	file = wave.open( name, 'w' )
	file.setframerate( Fs ) # sets sampling frequency
	file.setnchannels( 1 ) # sets number of channels
	file.setsampwidth( 1 ) # number of bytes, 8 bits per sample
 
	clipped = False
	block_size = 1024*10 # write block size: 10k
	a_max = 255 # max amp
	a_min = 0 # min amp
	n = 0
	len_data_array = len( data_array ) # 1 byte (UInt8) data
	while n < len_data_array :
		frame = '' # string frame of 'block_size'
		for i in range( block_size ) :
			if n < len_data_array :
				newbyte = int( (data_array[n]+1.0) * 128 ) # ~ 255/2
				if newbyte > a_max or newbyte < a_min : clipped = True
				newbyte = min( max(newbyte,a_min), a_max ) # normalization, 0..255
				#newbyte.clip( min=a_min, max=a_max ) # normalization, 0..255
				frame += chr( newbyte & 0xFF ) # takes the byte, converts it to char and adds it to the frame
				n += 1
		file.writeframes( frame )
	if clipped == True : print "Warning: Some values were clipped"
	print "Final length:", len_data_array/512,"kb" # n*2/1024 (bytes size/1024) = n/512
	file.close()

El archivo con todas estas funciones de lectura/escritura (8 y 16 bits) es este: wav_array.py

Gracias a todos!

algorithms , audio , Castellano , formats , GPL , programming , python

Share This/Compártelo

This post has the main purpose of showing my support to the Free Software Foundation campaign called “playogg” which was launched by the FSF this 16 of May of 2007, in Boston, Massachusetts, U.S.A. and basically wants to spread the use of the ogg vorbis codec in all platforms.

To begin, the ogg vorbis format is technically better than mp3, compressing with better quality and less space. For example, among other things, whereas an mp3 with normal quality takes 128kb with an ogg vorbis file “is enough” with 64kb.

More technical info about the format here: xiph.org

• Specification
• Reference implementation both of the standard encoder and decoder

On the other hand, although in my country (Argentina), at least so far there are no problems with software patents, that’s not the case of countries like United States and many others, where indeed they can’t use free programs with an excellent implementation from the mp3 standard like LAME.

In order to have an idea about the costs of mp3, you can check: http://www.mp3licensing.com/royalty

The ogg vorbis specification is in the public domain so anyone can use the format or write software to use it without being dependent on a patent holder for permission.

In addition, this format was recently extended also to personal music players (I believe that was one of the main problems for normal users). And more, recently I found out a very interesting project to replace the firmware of those gadgets by free versions, and of course most of them also implements the ogg vorbis codec, I’m speaking about the Rockbox project.

Update: Mobile players known to support ogg vorbis here: PortablePlayers.

algorithms , audio , codecs , english , formats , free culture , free software , hardware , music , projects , standards

Share This/Compártelo

Este post tiene como finalidad mostrar mi apoyo a la campaña organizada por la Free Software Foundation denominada “playogg” la cual fue lanzada por la FSF este 16 de mayo de 2007, en Boston, Massachusetts, EEUU y básicamente prentende fomentar el uso del codec ogg vorbis en todas las plataformas.

Para empezar, el formato ogg vorbis es muy superior técnicamente al mp3, comprimiendo con mejor calidad y ocupando menos espacio. Por ejemplo, entre otras cosas, mientras que un mp3 de calidad aceptable arranca en los 128kb un archivo ogg vorbis “ya se escucha bien” con 64kb.

Más info técnica del formato aca: xiph.org

• Especificación
• Implementación de referencia del encoder y del decoder

Por otro lado, a pesar de que en mi país (Argentina), al menos por ahora no hay problemas con las patentes de software, ese no es el caso de países como Estados Unidos y muchos otros más en los que incluso hay trabas para utilizar programas libres que implementan de forma excelente el standard mp3 como LAME.

Para tener una idea de los costos del mp3 se puede consultar: http://www.mp3licensing.com/royalty

La especificación de ogg vorbis está en el dominio público y cualquiera puede implementarla y darle la utilización que prefiera sin depender de ningún permiso de algún tenedor de patentes.

Además, recientemente este formato se extendió también entre los reproductores personales de música (creo una de las trabas más grandes que habia para el usuario común). Y es más, hace poco me enteré de un interesante proyecto para reemplazar los firmwares de estos aparatos por versiones libres y que generalmente también implementan ogg vorbis por las razones antes mencionadas, hablo del proyecto Rockbox.

Update: Para saber que reproductores portátiles soportan ogg vorbis consultar el siguiente link: PortablePlayers.

algorithms , audio , Castellano , codecs , formats , free culture , free software , hardware , projects , standards

Share This/Compártelo

Algunos ecos de lo que fue LAC2007:

• Fotos oficiales
• Back from LAC2007@TU-Berlin - The Aftermath y fotos
• Más fotos
• GNU/Linux Audio Conference en Berlín (repercusiones en LAU de este artículo)

Parece que todo el “streaming recolectado” va a estar disponible para bajar en esta dir: link.

Por otra parte, estos días (del 27 al 31 de marzo) se esta llevando a cabo en Frankfurt, Alemania, la exposición (creo más grande del mundo) de instrumentos, software y hardware musical y accesorios denominada Musikmesse.

Conclusión: LAC2007 en Berlin, Musikmesse en Frankfurt, parece que todo pasa por Alemania…

algorithms , alsa , audio , c++ , Castellano , codecs , conferences , effects , events , formats , free culture , free software , GNU/Linux , GPL , hardware , instruments , libraries , lutheria , midi , music , open source , programming , publications , python , signal processing , talks

Share This/Compártelo

Aprovecho la información que organicé para contestar un mail en una lista de Musix para hacer un post sobre conversión de audio a MIDI. El mail que contesté era de alguien que estaba buscando software de código abierto que hiciera eso (conversión audio-midi).

Dentro de los proyectos software libre yo conozco:

El wave2mid, que fue desarrollado como un proyecto de fin de carrera (Ingeniería Electrónica en la Universidad de Granada) por Pablo Busto González. Originalmente codificado en Matlab, luego fue migrado a Octave por la misma persona para poder distribuirlo libremente! Aún no tuve la oportunidad de probarlo ni examinar el código fuente, pero al menos parece estar bastante bien documentado (aunque en la misma página web anticipan que es muy lento, como era de esperar por estar desarrollado sobre este tipo de programas que en todo lo que no sea multiplicación de matrices dejan mucho que desear en cuanto a velocidad).

Programados en C++, están el Free Audio Note Recognition, también conocido simplemente como fanr (polifónico) y el Midingsolo (monofónico).

Nunca los probé y no se en que estado están. Tampoco se cual es el “estado del arte” en este tema, no se si hay algún programa (de código abierto o no) que realmente lo haga bien. La última vez que probé programas de este tipo fue hace muchos años y no quedé para nada conforme.

Algunas cosas relacionadas que conozco, que no hacen específicamente esto pero creo que pueden servir de referencia son:

El Voice2MIDI, que como su nombre lo indica esta orientado a la conversión de voz a midi, no de instrumentos. El trabajo que le dió origen parece estar aqui. Es parte del framework CLAM y según el pdf antes citado fue presentado como proyecto de fin de carrera de Ingeniería Técnica en Informática de Sistemas en la Universitat Pompeu Fabra y lo tuvo como director a Xavier Amatriain (uno de los principales desarrolladores del proyecto CLAM). Fue revisado aqui (en realidad se revisa el proyecto CLAM en general, pero también se le dedican unas palabras a este soft)

Tartini, una herramienta de análisis musical en tiempo real que esta orientado a una completa visualización del timbre de notas interpretadas por instrumentos o voz (tiene varios tipos de vistas) y entre otras cosas sirve para identificarlas (aunque creo que no de forma automatizada) y analizar su contenido espectral de diferentes maneras. Fue resultado de un trabajo para obtener un PhD y el autor, Philip McLeod ofrece un par de papers al respecto en su web (yo se los pedí hace un tiempo y me los envío enseguida).

Reciéntemente Avelino Herrera Morales hizo en su blog varios posts sobre separación de fuentes de sonido (que pueden venir bien para que sea polifónico!) y algunas implementaciones de algoritmos (liberadas bajo GPL!) para lograrlo:

• DUET
• El análisis de componentes independientes o la estadística aplicada al DSP
• Una tesis interesante
• Implementación en C del algoritmo de separación de fuentes de sonido

¿Alguien conoce algo más?

algorithms , audio , Castellano , CLAM , formats , free software , GPL , instruments , matlab , midi , programming , signal processing

Share This/Compártelo

SoX (Sound eXchange) es un conjunto de comandos muy potentes para procesar archivos de audio. Estos resultan tan diversos que normalmente esta herramienta se hace conocer como “la navaja suiza de las herramientas de sonido”.

Entre otras cosas, permite conversión entre formatos, aplicar efectos (por ejemplo distintos tipos de filtros), resamplear, grabar, reproducir, etc.

Otra cosa curiosa que tiene es que estas funcionalidades también estan disponibles como biblioteca (denominada libst). Se trata de una biblioteca estática que puede ser usada desde otras aplicaciones.

Recientemente hice algunos scripts para Musix que valiéndose de esta herramienta convierten en forma masiva de formato y resamplean desde el menú contextual de konqueror (ver mi otro post).
Los .desktop hay que agregarlos en “~/.kde/share/apps/konqueror/servicemenus/” para que este solo disponible para un usuario y en “/usr/share/apps/konqueror/servicemenus/” para que lo este para todos los usuarios del sistema. También hay que editar los .desktop con el path correcto donde van a estar ubicados los .sh, nada más.

Tres tienen acciones sobre directorios, convierten todo lo que tenga extensión mp3 o wav (según se elija) dentro del directorio a wav 44kHz o 48kHz y hay uno que actua sobre archivos individuales mp3 convirtiendolos a wav.

Se pueden hacer muchas variaciones de todo esto y es aplicar la misma idea.

(bajar conv_masiva_sox.tar.gz)

Otros ejemplos:

Grabar lo que entra por la entrada de línea: rec -c 2 -r 44100 -s w my_file.wav

Resampleo (resamplea a 44100Hz): sox test.wav -r 44100 test_44100.wav resample

Cambiar el bitrate a 16bits: sox test.wav -w test_out.wav

Convertir a PCM: sox test.wav -u -w test_44100_pcm.wav

Pasa bajo (frecuencia de corte): sox test.wav test_LP.wav lowpass 1000

audio , Castellano , codecs , formats , free software , GNU/Linux , libraries

Share This/Compártelo

A raíz de que desde hace un tiempo me puse en campaña para intentar reemplazar matlab con python (en realidad usar python para lo que hasta ahora usaba matlab) es que me vi obligado a implementar las siguientes funciones para poder trabajar con archivos wavs como si fueran vectores.

Serían las equivalentes a las funciones wavread y wavwrite de matlab.

wavread: recibe un wav y devuelve un vector normalizado entre -1 y 1, su frecuencia de muestreo y la cantidad de bits por muestra.

# Example: [ y, Fs, bits ] = wavread( 'filename' )
def wavread( name ):
	file = wave.open( name, 'r' )
	[Channels,Bytes,Fs,Frames,Compress,CompressName] = file.getparams() # (nchannels, sampwidth in bytes, sampling frequency, nframes, comptype, compname)
	Bits = Bytes*8 # 16 bits per sample
	Data = file.readframes( Frames )
	Data = fromstring( Data, Int16 ) / 32767.0 # -1..1 values, Int16 because Bits=2x8=16
	print "Fs: ",Fs,"\nBits: ",Bits,"\nChannels: ",Channels
	file.close()
	return Data, Fs, Bits
 
# Example: wavwrite( y, Fs, filename )
def wavwrite( data_array, Fs, name ):
	file = wave.open( name, 'w' )
	file.setframerate( Fs ) # sets sampling frequency
	file.setnchannels( 1 ) # sets number of channels
	file.setsampwidth( 2 ) # number of bytes: 16bits/8=2, 16 bits per sample
 
	clipped = False
	block_size = 1024*10 # write block size: 10k
	a_max = 32767 # max amp
	a_min = -32767 # min amp
	n = 0
	len_data_array = len( data_array ) # 2 bytes (int16) data
	while n < len_data_array :
		frame = '' # string frame of 'block_size'
		for i in range( block_size ) :
			if n < len_data_array :
				twodatabytes = int( data_array[n] * a_max )
				if twodatabytes > a_max or twodatabytes < a_min : clipped = True
				twodatabytes = min( max(twodatabytes,a_min), a_max ) # normalization, -32767..32767
				#twodatabytes.clip( min=a_min, max=a_max ) # normalization, -32767..32767
				frame += chr( twodatabytes & 0xFF ) # takes first byte, converts it to char and adds it to the frame
				frame += chr( (twodatabytes >> 8) & 0xFF ) # takes the second byte
				n += 1
		file.writeframes( frame )
	if clipped == True : print "Warning: Some values were clipped"
	print "Final length:", len_data_array/512,"kb" # n*2/1024 (bytes size/1024) = n/512
	file.close()

Nota: recomiendo bajar este archivo wav_array.py y no copiar directamente el código desde aca ya que debido al plugin para syntax highlight, el código puede no haber quedado correctamente indentado y tal vez no funcione bien al ser interpretado por python

Update: Aprovechando estas funciones y a manera de ejemplo también escribí el equivalente al post “Convolución circular rápida (aplicación en reverbs)” pero en python. El código es este: fast_conv.py.

Update 2: Para wavs de 8 bits ver: “Trabajar con wavs de 8 bits en python”

audio , Castellano , formats , GPL , library , programming , python

Share This/Compártelo

Español:

WavTools es un conjunto de utilidades para procesar archivos WAV en Unix.

Actualmente se encuentra en la versión 0.2.1.

Las herramientas son:

* wavcat - concatena archivos WAV, con la opción de convertir de stereo a mono.
* wavpad - agregar “relleno” (padding) a archivos WAV 16 bit 44 kHz que se requiere en algunos programas que graban CD’s.
* wavinfo - Muestra información del encabezado y fragmentos (chunks) de un archivo WAV

English:

WavTools is a set of WAV file processing programs for Unix.
The current version, 0.2.1, was released on Tuesday, 5th April, 2004.

The tools are:

* wavcat - Concatenates WAV files, with options to convert stereo to mono.
* wavpad - Adds padding to 16 bit 44 kHz WAV files, as required by some CD writing software.
* wavinfo - Displays information from the header and chunks of a WAV file.

audio , Castellano , english , formats , free software , GNU/Linux , GPL

Share This/Compártelo