If you ever wrote at least 2 audio plugins in your life, for sure you have noticed you had to write a lot of duplicated code. In other words, most of the times, writing a plugin there is very little entropy from your code.

My first approach to this problem was some years ago when i did a simple code generator of the base code of a clam plugin (see these clam-devel threads for more info ‘Commit #11195: templated plugins generator‘ and ‘Frontend for automatic generation of plugin code‘)

Now i’m with a simple but i think powerful project (derived from the needs i noticed at club de audio de la fiuba) to have an application to generate code of different standards using XML based specifications. Then, as before, you nearly only need to write the signal processing code of the plugin (and can forget about the mechanical work).

The idea is to get VST, LADSPA, lv2, CLAM, Audio Units and possibly others standards base code ready to compile for different operating systems and using different build systems. Indeed, once finished, will be easy to implement new modules for others plugins specifications since will consist only into implement an interface.

My proposed xml specification (comments and suggestions are welcome!), showed as a clam plugin definition example is here. Basically contains metadata, input and output ports and controls and other build definitions:

< ?xml version="1.0" encoding="UTF-8"?>
< !DOCTYPE AudioPlugin SYSTEM "AudioPluginDef.dtd">
<audioplugin Version="0.1">
        <metadata>
                <name>TestRtPlugin</name>
                <description>This is a test realtime audio plugin</description>
                <authors>Fulano, Sultano, Mengano</authors>
                <copyright Year="2010">Club de Audio FIUBA</copyright>
                <license>GPL</license>
                <category>Plugins</category>
        </metadata>
 
        <inputs>
                <port Name="L Input">AudioInPort</port>
                <port Name="R Input">AudioInPort</port>
 
                <control Name="Gain" Min="0." Max="1.0" DefaultValue=".5">InControlFloat</control>
        </inputs>
 
        <outputs>
                <port Name="L Output">AudioOutPort</port>
                <port Name="R Output">AudioOutPort</port>
        </outputs>
 
        <outputplugin Standard="CLAM" BuildSystem="Scons" OS="Linux">
                <basetemplatename>Default</basetemplatename>
 
                <clam_defaultconfig> <!--  CLAM plugin specific configuration -->
                        <baseclass>Processing</baseclass>
                        <withconfig>True</withconfig>
                </clam_defaultconfig>
        </outputplugin>
</audioplugin>

I also thought about an UID (Uniqued ID) field at metadata, there is not showed in the example since is not needed to clam plugins.

There is also a .dtd file to check the correctness of the plugin spec.

audio , CLAM , ClubAudioFiuba , english , free software , ideas , plugins , programming , projects , python , signal processing , specifications , standards

Share This/Compártelo

(Note: I wrote this as something to tell to the clam-devel mailing list about some of my source-code commits)

About eight months ago, there was a foundation of something like an “audio club” in my university [1]. As soon i learned about that, i quickly got in touch with them and noticed that there was a major interest in analog issues (the only audio area with at least elective, courses in the university). So i told them about all the cool things that are available and ready to do with digital audio, mostly signal processing related. I talked in general, but of course i also talked about clam, with all its prototyping, real-time and easy development of plugins features. Even many of them ended installing and using it, and some even developing with more or less help. One thing to notice is that most of them are students from first years and most (but not all) are students with a basic programming level (because they are from electronics) but strong dsp knowledge (behind this is an university with more emphasis in theory than practice)
We started specifying plugins from a more abstract level (inputs/outputs/controls) and generating the source code base using
CLAM’s Templated Plugins Code Generator [2] and prototyping some simple applications. But one of the things we ended up doing was to take advantage of clam as platform to prototype medic related applications like filter ECG signal from noise in realtime, and some like _vice-versa_, i mean applying some processing knowledge from that area to audio.

Some of that work (one hour per week average) it’s now in the repo, most remarkable i think are filters work, by above the adaptative notch one (which even was used as a demo of a talk of one of the members about the steepest descent algorithm and its application to filter ECG signals)

Some development screenshots:
http://clam-project.org/wiki/Image:FilterByCoefExample.jpg
http://clam-project.org/wiki/Image:FilterExample-LP-HP.jpg
http://clam-project.org/wiki/Image:ThreeBandFilterOutputWithWhiteNoiseAsInput.jpg
http://clam-project.org/wiki/Image:GaussianWhiteNoiseHistogram.jpg
http://clam-project.org/wiki/Image:UniformWhiteNoiseHistogram.jpg

[0] FIUBA: Engineering Faculty of Buenos Aires University
[1] Group: http://code.google.com/p/club-audio-fiuba
Source code repo: http://groups.google.com/group/club_de_audio_fiuba
[2] http://audiores.uint8.com.ar/blog/2009/08/17/showing-a-little-about-clam-as-a-prototyping-tool-at-the-audio-club-of-fiuba/

algorithms , audio , blog , c++ , CLAM , ClubAudioFiuba , effects , english , free software , GPL , ideas , math , matlab , news , noise , plugins , programming , projects , python , signal processing

Share This/Compártelo

Recently I been playing with python bindings for the CLAM library. Here is a demo demonstrating how to interactively build a network and play a file using the IPython shell:

 
Related scripts: playfile.py fft_example.py.
 
PyCLAM source. INSTALL.

audio , c++ , CLAM , english , free software , GPL , ideas , libraries , programming , projects , python , signal processing

Share This/Compártelo

This script is about a basic code generation of a CLAM plugin. In some point I think this is some kind of meta-programming or perhaps the term “automatic programming” fits better. The basic idea is to specify some basic features of the planned new processing in a plain text and then, generate some code with the script, saving in this way many of the often repetitive and mechanical work needed to set-up a new processing from scratch. Main intention is to allow concentrate in the Do() function or plugin details quickly.

As an example, I will reproduce here how I worked with me some time ago:
 
One day, in the irc #clam channel:
“[11:51] <groton> Consul, do you know if there is any trigger-like processing unit, list when the volume gets louder than a threshold or something like that”

I’m not Consul in the irc (I’m hordia), but next day at my console…

cd CLAM/scripts/TemplatedPluginsGenerator
vi ThresholdTrigger.template

Name:ThresholdTriggerTemplate
BaseClass:Processing
i:AudioInPort,Audio Input
ic:0,1,Threshold
oc:0,1,Trigger

In words, this means a Processing template named “ThresholdTriggerTemplate” using “Processing” as a base class and with one input of “AudioInPort” type named “Audio Input”, with one in control in the 0..1 range named “Threshold” and one out control named “Trigger”. Of course, you can add as many inputs/outputs of ports or controls as you want.
 

This script creates the template:

./TemplateGenerator.py ThresholdTrigger.template

 
And this one the processing plugin:

./TemplatedPluginsGenerator.py ThresholdTrigger ThresholdTriggerTemplate "Hernán Ordiales" GPL 2008

Again in words, this means create a new processing called “ThresholdTrigger” based on the “ThresholdTriggerTemplate” filling the copyright with my name plus the current year and the license with the GPL text.

 
A final edit just typing the required code for the Do() function:

cd CLAM/plugins/ThresholdTrigger
vi ThresholdTrigger.hxx

#include <cmath>
 
bool Do()
{
       bool result = Do( mAudioInput.GetAudio() );
       mAudioInput.Consume();
       return result;
}
 
bool Do(const Audio& in)
{
       int size = in.GetSize();
       const DataArray& inb = in.GetBuffer();
       TData threshold = mThreshold.GetLastValue();
       bool trigger = 0;
       for (int i=0;i<size ;i++)
       {
               if (std::fabs(inb[i])>threshold)
                       trigger = 1;
       }
       mTrigger.SendControl(trigger);
       return true;
}
</size></cmath>

At this point, just remains add the basic SConstruct file for a CLAM plugin, compile it with the corresponding clam_prefix and install it:

scons install clam_prefix=$CLAM_PATH
NetworkEditor

And ready to use…

This example it’s very simple and has a poor implementation but was just to show the idea of how those scripts can save a lot of work.

Update: I made a frontend for these scripts: ProcessingCodeGenerator

audio , c++ , CLAM , english , library , plugin , plugins , programming , python

Share This/Compártelo

Este post surge dado que recientemente redescubrí la radio de last.fm. Principalmente gracias a que me bajé el programa que proveen ellos (btw, multiplaforma y Software Libre). Digo que redescubrí porque antes la usaba desde el amarok, cosa que esta bien, ya que uno centraliza todo ahi, pero este programita tiene algunas cosas piolas y en algunas situaciones es mucho más cómodo de usar, sobre todo para cambiar de radios, por artistas o tags, etc y encima te tira algo de data (parecido a lo que tiene el amarok que busca en wikipedia, nada más que “propiedad” de last.fm). Pero lo que me hizo “engancharme” es el tema de poner un artista que me guste y que me empiece a tirar temas con la misma onda, cosa que me hace conocer canciones e interpretes nuevos. ¿Por qué cuento esto? Por que desencadeno en que comience a usar seguido el botón de “Love”/”Favorito” de la aplicación, que es una forma de decirle a last.fm que ese tema te gusta y que lo tenga en cuenta para volverlo a pasar en el futuro o para (supongo) que tengan más probabilidad de aparecer temas similares (si no te gusta para nada, también se puede “bannear”). Bueno, todo esto viene dado que de tanto presionar “love” (y descubrir/redescubrir varios artistas, sobre todo en blues y jazz) queria tener una forma de acceder a todo eso (nombre del tema + interprete). El programa en cuestión muestra una lista de las canciones recientemente maracadas como favoritas, pero no permite copy&paste y tampoco vía web hay forma de acceder a esa información, como si pasa con otras cosas, por ejemplo las canciones recientemente escuchadas… (con la nueva versión del sitio si se puede: Last.fm: The Next Generation)

Bueno, buscando un poco di con la API (versión 2.0), al parecer reciente, pero sin la capacidad de “recuperar” las últimas loved songs… asi que me remití a la versión 1.0 que si lo permite y además se puede usar sin api key. Entonces lo que hice fue armarme un script en python que descargara las últimas canciones “favoritas” y las vaya guardando en un xml (o .txt), es decir a medida que aparecen nuevas, las agrega y elimina los duplicados…

El script es este: recentLovedTracksList.py

Tip: si uno quiere estar seguro de no perderse ninguna canción, dado que las “canciones favoritas recientes” son solo 10, puede poner este script a correr en cron… (si es que va marcar muchas canciones como favoritas, pero a lo sumo y con mucha suerte uno marca como “loved” una por hora y la frecuencia por supuesto tiende bajar)

Ya que estaba jugando con la api, hice otro script para descargarme todo el historial de escucha (otra “feature” que no vi disponible vía web, pero por suerte con un poco de “hacking” se puede hacer con la API):

lastfmProfileBackup.py

No se para que me puede servir, pero es info mía y ya que la tiene otra persona, al menos me gusta poder tenerla yo

Otras aplicaciones

Ya que escribo sobre last.fm aprovecho para comentar un par de “nuevos usos” que se me ocurrieron de este tipo de sistemas, ambos se aplican a un player haciendo scrobbling en una fiesta/reunión:

• Con esto se tiene automáticamente trackeada y publicada la lista de canciones que se escucharon. ¿Cuantas veces uno quiere saber como se llama esa canción que le gustó el día anterior para poder volverla a escucharla?
• Si uno no quiere estar eligiendo música, pero quiere asegurarse que va a escuchar algo de su agrado, puede poner su radio personalizada y listo… “satisfacción garantizada” . Esta feature ahora es paga, pero dado que cualquier usuario puede escuchar la radio del otro… no es difícil imaginarse como se puede salvaguardar este punto… de todas formas, la suscripción no es cara, alrededor de 3 euros por mes (creo).

audio , Castellano , free software , ideas , MIR , music , python , web

Share This/Compártelo

Ayer tuve la oportunidad de presentar mi trabajo realizado para el google summer of code en el marco de las VI Jornadas de Acústica, Electroacústica y áreas vinculadas (CADAE), les dejó la presentación de la misma:

Transformaciones espectrales en tiempo real para CLAM

| View | Upload your own

Download: Transformaciones espectrales en tiempo real para CLAM.pdf

acoustics , algorithms , audio , c++ , Castellano , CLAM , conferences , dissertation , effects , free software , GNU/Linux , GPL , GSoC2007 , GUI , libraries , midi , music , open source , programming , projects , python , signal processing , talks

Share This/Compártelo

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

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

Del 22 al 25 de marzo de este año se desarrollaran las 5tas jornadas de Linux Audio Conference (LAC) en Berlin, Alemania.

LAC2007 tiene como objetivo reunir a desarrolladores y usuarios de linux y software de audio open source con el objetivo de compartir información y discutir sobre proyectos y música.

Puntos más importantes:

• Charlas públicas y workshops
• Conciertos
• Tutoriales
• Presentación de papers
• Audio en vivo/streaming de video
• Entrada gratuita a todos los eventos (excepto para los conciertos)

(info de prensa del evento aqui)

El programa detallado del evento aca (por días)

Títulos de las charlas y workshops:

• A Tetrahedral Microphone Processor for Ambisonic Recording
  Fons Adriaensen
• Renewed architecture of the sWONDER software for Wave Field Synthesis on large scale systems
  Marije Baalman, Simon Schampijer, Torben Hohn, Thilo Koch, Daniel Plewe, Eddie Mond
• Music Composition through Spectral Modeling Synthesis and Pure Data.
  Edgar Barroso
• A Software-based Mixing Desk for Acousmatic Sound Diffusion
  André Bartetzki
• pnpd, a new audio synthesis engine with a dataflow language
  Tim Blechman
• openSUSE JAD - Tutorials for installation and producing music
  Michael Bohle
• Integrating Documentation, End-User Support, and Developer Resources using *.linuxaudio.org
  Ivica Ico Bukvic, Robin Gareus, Daniel James
• Audio Metering and Linux
  Andres Cabrera
• Qtractor - A Audio/MIDI multi-track sequencer
  Rui Nuno Capela
• Compiling Simulink Models as SuperCollider UnitGenerators
  Martin Carlé, Sönke Hahn
• Python for Sound Manipulation - A versatile creation environment Tutorial
  Renato Fabbri and Fábio Furlanete
• Developing Shared Tools: a Researchers Integration Medium Workshop
  Fábio Furlanete and Renato Fabbri
• Visual prototyping of audio applications (CLAM)
  David Garcia, Pau Arumi, Xavier Amatriain
• Interfacing Pure Data with Faust
  Albert Gräf
• Faust Hands On Demo
  Yann Orlarey and Albert Gräf
• Proposal for an XML format for Time, Positions and Parts of Audio Waveforms
  Jens Gulden and Hanns Holger Rutz
• JJack: Using the JACK Audio Connection Kit with Java
  Jens Gulden
• Model Driven Software Development with SuperCollider and UML
  Jens Gulden
• Offener Schaltkreis, An interactive Sound Installation
  Christoph Haag, Martin Rumori, Franziska Windisch, Ludwig Zeller
• Stereo, Multichannel and Binaural Sound Spatialization in Pure-Data
  Georg Holzmann
• Canorus - a music score editor - Workshop
  Reinhard Katzmann, Matevz Jekovec
• Buzztard Music Production Environment Demo
  Stefan Kost and Thomas Wabner
• The One Laptop Per Child (OLPC) Audio Subsystem
  Jaya Kumar
• Musical Signal Scripting with PySndObj
  Victor Lazzarini
• Stochastic Composition with SuperCollider
  Sergio Luque
• Beyond open source music software: extending open source philosophy to the music with CODES
  Evandro Manara MILETTO, Luciano Vargas FLORES, Daniel Eugenio KUCK, Marcelo Soares PIMENTA and Jerome RUTILY
• pure-dyne
  Aymeric Mansoux, Antonios Galanopoulos and Chun Lee
• Getting Linux to produce Music fast and powerful
  Hartmut Noack
• Firewire Audio on Linux - Demo
  Pieter Palmers
• The Linux MIDI Studio - A workshop with Dave Phillips
  Dave Philips
• From resistors to samples: Developing open hardware instruments using Arduino, Pure Data and Processing - Workshop
  Recursive Dog collective (Dolo Piqueras, Emanuele Mazza and Enrique Tomás)
• Video Editing with the Open Movie Editor
  Richard Spindler
• Developing LADSPA Plugins with Csound
  Rory Walsh and Victor Lazzarini
• Real-Time Multiple-Description Coding of Speech Signals
  Jan Weil, Kai Clüver, and Thomas Sikora
• blue: a music composition environment for Csound
  Steven Yi
• Livecoding with SuperCollider
  Alberto de Campo

Link a las descripciones de cada uno de los papers: abstracts

Update:

• Más info sobre “Qtractor - A Audio/MIDI multi-track sequencer” en el blog de Rui Nuno Capela: posts “Thoughts on Readyness” y “The Road to Berlin“.
• “Audio Metering and Linux“ de Andrés Cabrera es una exposición sobre los diferentes sistemas y estándares de medición de nivel de audio y de volumen. Además, presenta el estado de medición de audio en linux y propone una aplicación en la que esta trabajando que puede hacer diferentes tipos de medición de audio con logging, histogramas, etc. Para los interesados, el paper lo pueden ver aqui y el código aqui.
• Sobre “Visual prototyping of audio applications“ (del proyecto CLAM), más info en “See you in Berlin“.

Update 2:
Hay streaming de audio y video en tiempo real de todas las conferencias y conciertos (luego también estará en diferido)

• El programa
• Info sobre el streaming

acoustics , algorithms , audio , c++ , Castellano , CLAM , codecs , conferences , effects , español , events , free software , GNU/Linux , libraries , midi , music , open source , programming , publications , python , signal processing , talks

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