Archivo de la categoría: Música Electrónica

Frozen. Grabación en casa de Maria y sus amigas


El martes pasado vinieron a comer Maria y tres de sus amigas (Laia, Adela y Martina), con el objetivo de grabar un par de temas de Frozen. Realmente estas niñas están poseídas por Frozen, Maria ya ha visto la peli 5 veces. La cuestión es que cob dos horas y media teníamos que hacer mucha faena, a parte de comer. La comida la solucionamos rápido, arroz a la cubana para 5 y rapidito que hay mucho trabajo.

Manos a la obra, un poco de calentamiento. Yo lo tenía todo preparado: dos micros para las cuatro niñas, que entraban en una pista de Ardour. En otras dos pistas ya tenía preparado previamente las canciones Vol Volar (Let it Go) y Per primer cop en la Vida (For the First Time in Forever), en sus versiones catalanas, que son las canciones que habíamos planificado de grabar (bien, en principio sólo era Vol Volar, la segunda era de reserva).

Hicimos varias tomas del Let it Go, pero tan sólo dos tomas del Per Primer Cop… El resultado es bastante satisfactorio teniendo en cuenta que son niñas de 9 años. A mejorar realmente las entradas (que tiene solución si se practica), y la afinación (más difícil de solucionar). Además, el hecho de que estuviesen emocionadas con esta experiencia no ayudaba nada.

Al final escogíuna de les tomas. Para exportar el audio sin matarme mucho he equilibrado la pista instrumental con la pista de las voces, y he aplicado a las voces un poco de compresión, chorus y reverb, todo de forma moderada, i ya tengo el mp3. Todo esto hecho con Ardour como DAW multipista. (Linux, of course).

Para el tema del video cometí un error. Me contenté con grabar un solo video, pensando que lo juntaría con la versión buena del audio, y no. En los dos videos que se muestran se ve clarament una falta de sincronía entre el video y las voces. A parte de la falta de sincronía en las entradas, el resultado es un tanto irreal. Para la próxima vez grabaré en video todas las tomas, y siempre seré a tiempo de borrar los videos descartados.

En estas grabaciones lo ideal es utilizar cascos para todas las participantes. Necesitaría una cosa similar a esto. Como no dispongo de un amplificador de auriculares, se ha utilizado un monitor de campo cercano, intentando que el sonido no entre por los micros. Esto se consigue controlando la distancia, el volumen y que el monitor quede detrás de los micros. La parte de señal que ha entrado por los micros es mínima, aunque no nula.

Así pues, el material que se ha utilizado es:

  • Ordenador Linux Ubuntu 12.04 con JACK y Ardour
  • Tarjeta de sonido externa, Edirol UA25EX
  • Mezclador de 4 entradas (sólo se utilizan dos)
  • 2 micrófonos
  • Monitor de campo cercano

A continuación se muestra el resultado: dos videos que se han colgado en Youtube. A las niñas les ha encantado ver cómo su video se mezclaba con las animaciones de las protagonistas de Frozen: Elsa y Anna.

diatonicbaixos v1.0: ayuda para los bajos del acordeón diatónico

Maria está estudiando el acordeón diatónico (y de paso yo también me he enganchado). Una de las cosas que siempre he encontrado difíciles es la coordinación de la mano derecha (con la que tocamos la melodía) y la mano izquierda (los bajos). Igual que pasa con el piano, que siempre me ha parecido difícil tocar con las dos mans al mismo tiempo.

Aquí va un pequeño programa para ayudar a poner la mano izquierda en el acordeón diatónico. Mientras suena la melodía (se necesita el fichero midi de la melodía), por pantalla se muestran las posiciones de los bajos que se han de tocar (en el acordeón diatónico hay 8 botones para los bajos/acordes, que suenan diferente si abres o cierras el fuelle). Cuando se muestra un botón en color verde significa que hay que cerrar el fuelle; en color rojo hay que abrirlo.

Para la interficie gráfica se ha utilizado la librería ncurses, que es la primera vez que programaba en esta llibrería (y estoy muy contento del resultat obtenido). El programa es un cliente de JACK (el servidor de audio para Linux, www.jackaudio.org), y de hecho es el time master, es decir, controla el transporte. Para utilizar la aplicación lo mejor es lanzar el script bash que se proporciona, diatonicbaixos.sh, donde se pone de manifiesto toda la cadena de programas que se utilizan.

Primero de todo se cambia el tempo deseado al fichero midi mediante el script change_tempo_smf (se proporciona el código fuente). Luego se arranca el servidor JACK, y el sintetizador fluidsynth, que es el que hará sonar la melodía. Después arrancamos la utilitat jack-smf-player, que se encargará de hacer sonar la melodía. También arranco el klick, que es un metrónomo cliente de JACK. Finalmente ya puedo lanzar mi aplicación, diatonicbaixos. El resultado, com se ve en el video, es que suena la melodía mientras se van mostrando las posiciones de los bajos. Se puede cambiar el tempo, se puede habilitar o no el metrónomo, y hay otro parámetro que permite mostrar el siguiente bajo que se tendrá que pulsar.

Para hacerse una idea del funcionamiento del programa lo mejor es ver el video:

Descargar diatonicbaixos v1.0

50 ways… #6. Editores de partituras: Lilypond

En el anterior post creamos un soundfont para acordeón diatónico, castagnari.sf2, y con sus sonidos tocamos mi canción preferida: Una Plata d’Enciam, dentro del proyecto 50 ways to play Una Plata d’Enciam. Vamos a ver ahora cómo con el editor de partituras Lilypond podemos crear una partitura muy correcta, que responda a los retos que nos plantea la notación para el acordeón. Lo que haremos en este post no es nada del otro mundo. En el blog amigo Scores of Beauty, http://lilypondblog.org/, se lleva al extremo las posibilidades de lilypond.

Básicamente lo que queremos es visualizar correctamente la melodía, los acordes, y cómo se han de tocar los bajos/acordes de la mano izquierda (es decir, el acompañamiento). La idea es crear unas partituras didácticas que ayuden a mi hija a poner los dedos de la mano izquierda.

Lo primero que haremos es crear la melodía, pondremos encima de las notas los acordes en la forma habitual, y mostraremos cuándo se ha de tocar un bajo (b) o un acorde (a) con la mano izquierda. Esto último lo haremos con \\lyrics, como si fuese la letra de una canción.

\\version «2.12.1»
\\header {
title = «Una Plata d’Enciam»
composer = «tradicional catalana»
}

baixosnotacio = \\chordmode {
c4 c f c f g g c c c f c f g g c
c4 c f c f g g c c c f c f g g c
}

partitura = \\relative c’
<<
\ew ChordNames {
\t\\set chordChanges = ##t
\t\\baixosnotacio
}

\ew Staff = «veu 1»
{
\\clef treble
\\key c \\major
\\time 2/4
\\tempo 4=80

\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f f f g e4
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f e f g e4
}
\\addlyrics {
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
}

>>

\\score {
\\partitura
\\layout { }
\\midi { }
}

Ahora vamos a poner los bajos. Si lo hacemos en la forma habitual funciona, pero queda una partitura que no és útil para su lectura. Además, no es correcta, pues como se ha explicado en el anterior post la asociación entre los acordes CM, DM,… y las notas midi 24, 26,… fue una decisión arbitria. Quedaría de la siguiente manera:

\\version «2.12.1»
\\header {
title = «Una Plata d’Enciam»
composer = «tradicional catalana»
}

baixosnotacio = \\chordmode {
c4 c f c f g g c c c f c f g g c
c4 c f c f g g c c c f c f g g c
}

partitura =
<<
\ew ChordNames {
\t\\set chordChanges = ##t
\t\\baixosnotacio
}

\\relative c’
\ew Staff = «veu 1»
{
\\clef treble
\\key c \\major
\\time 2/4
\\tempo 4=80
\t%notes amb valors relatius
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f f f g e4
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f e f g e4
}
\\addlyrics {
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
}

\ew Staff = «baixosnotes»
{
\\key c \\major
\t%notes amb valors absoluts
\tc,8. r16 c,,8 r f,8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
\tc,8. r16 c,,8 r f’8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
\tc,8. r16 c,,8 r f,8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
\tc,8. r16 c,,8 r f,8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
}
>>

\\score {
\\partitura
\\layout { }
\\midi { }
}

Aquí es importante remarcar que se ha utilizado la notación relativa para la melodía, y la notación absoluta para los bajos, que simplifica mucho escribir la alternancia entre bajos y acordes. Esta partitura no es correcta para su impresión, pero el fichero midi que produce sí que es correcto. ¿Hay una manera de solucionarlo? Sí. Se puede definir un \\score para ser impreso, y otro \\score para generar el fichero midi. El resultado queda de la siguiente manera: la partitura para imprimir es correcta (no aparecen las notas de los bajos, sólo las posiciones donde hemos de poner los dedos de la mano izquierda); y el fichero midi resultante también es correcto:

\\version «2.12.1»
\\header {
title = «Una Plata d’Enciam»
composer = «tradicional catalana»
}

baixosnotacio = \\chordmode {
c4 c f c f g g c c c f c f g g c
c4 c f c f g g c c c f c f g g c
}

partitura = \\relative c’
<<
\ew ChordNames {
\t\\set chordChanges = ##t
\t\\baixosnotacio
}

\ew Staff = «veu 1»
{
\\clef treble
\\key c \\major
\\time 2/4
\\tempo 4=80
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f f f g e4
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f e f g e4
}
\\addlyrics {
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
\tb _ a _ b _ a b _ _ a _ b _ _ a _ b _ a _
}
>>

fitxermidi =
<<
\\relative c’
\ew Staff = «veu 1»
{
\\clef treble
\\key c \\major
\\time 2/4
\\tempo 4=80
\t%notes amb valors relatius
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f f f g e4
\te8 f g g a a g4 \\times 2/3 { a8 a g } f f \\times 2/3 { f f f } g e e f g g a a g4 \\times 2/3 { a8 a g } f e f g e4
}

\ew Staff = «baixosnotes»
{
\\key c \\major
\t%notes amb valors absoluts
\tc,8. r16 c,,8 r f,8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
\tc,8. r16 c,,8 r f’8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
\tc,8. r16 c,,8 r f,8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
\tc,8. r16 c,,8 r f,8. r16 c,,8 r f,8. r16 g,,8 r g,8. r16 c,,8 r
}
>>

\\score {
\\partitura
\\layout { }
}

\\score {
\\fitxermidi
\\midi { }
}

Finalmente podemos escuchar la canción Una Plata d’Enciam tal como quedaría con un acordeón diatónico:

Una Plata d’Enciam by joanillo

Referencias:

Solución portátil para un saxo electrónico: Raspberry PI + soft o hard sinte

EWI-USB and Raspberry Pi

EWI-USB and Raspberry Pi

Para tocar el controlador de viento EWI-USB normalmente me conecto al portátil. Ejecuto el fluidsynth o cualquier otro soft sinte. Por tanto, la solución para practicar es EWI-USB + portátil + auriculares. Existe una solución más portable y autónoma? Definitivamente sí utilizando la Raspberry Pi, buscando una solución puramente consola y totalment desatendida: enchufar y tocar. En esta ocasión no utilizo JACK, es una solución purament ALSA. Se trata de instalar fluidsynth, algún soundfont que suene bien y que no pese demasiado, configurar el usuario pi con prioridad realtime, desinstalar cualquier servicio que no tenga que utilizar.

Con un script en /etc/udev/rules.d/ewiusb.rules conseguimos que en el momento que conecto el EWI-USB por el puerto USB se ejecuten los comandos que me permitirán tocar automáticamente: ejecutar fluidsynth y conectar la salida midi del EWI-USB a la entrada midi del fluidsynth. He tenido bastantes problemas con la letencia, pero el script que se muestra más abajo a mi em funciona bien sin latencia.

Además, con un poco de electrónica simple y utilizando los pins GPIO se podría cambiar fácilmente el programa midi y poder escoger entre diferentes instrumentos: saxo, midi, flauta,…

Otra posibilidad, como se ve en la fotografía, es utilizar un sinte hardware com el Roland JV-1010. Como la entrada del JV-1010 es puramente midi se necesita un cable conversor USB2MIDI (por ej, http://www.amazon.com/dp/B0017H4EBG), que muestra sus puertos a ALSA. Con esta solución no has de temer por la latencia, es una magnífica experiencia de usuario, y podemos escoger entre centenares de sonidos.

/etc/udev/rules.d/ewiusb.rules

#/etc/udev/rules.d/ewiusb.rules
ACTION==»add», SUBSYSTEMS==»usb», ATTRS{product}==»EWI-USB», RUN+=»/home/pi/ewiscript.sh»

/home/pi/ewiscript.sh

#!/bin/sh
#/home/pi/ewiscript.sh
#script que s’ha d’executar quan connectem el EWI-USB. Dos casos: a) synth hardware (roland); b) synth software (fluidsynth)

#mirem si tenim connectat el cable usb-midi
if [ -z `/usr/bin/aconnect -iol | grep USB2.0-MIDI | awk ‘/client/{print $1}’` ]; then

#no està connectat: b) synth software (fluidsynth)
if [ -z `pidof -s fluidsynth` ]; then
screen -d -m -S fluidsynth -t «fluidsynth» /usr/bin/fluidsynth -a alsa -m alsa_seq -g 1 -c 4 -z 256 -r 48000 /home/pi/Natural_Oboe.sf2
/bin/sleep 3
/usr/bin/amixer set Master 40%+ > /dev/null
/bin/sleep 2
FLUIDSYNTH=$(/usr/bin/aconnect -o -l | awk ‘/FLUID/{print $2.»0″}’)
/bin/sleep 2
#echo $FLUIDSYNTH
EWIUSB=$(/usr/bin/aconnect -o -l | awk ‘/client/’ | awk ‘/EWI-USB/{print $2.»0″}’)
/bin/sleep 2
/usr/bin/aconnect $EWIUSB $FLUIDSYNTH
/bin/sleep 2
fi
else
#a) synth hardware (roland)
USBMIDI=$(/usr/bin/aconnect -o -l | awk ‘/client/’ | awk ‘/USB2.0/{print $2.»0″}’)
/usr/bin/aconnect EWI-USB:0 $USBMIDI
/bin/sleep 2
fi

Más información, aunque en catalán, en la wiki

jplay-sndfile: una aplicación educativa para Procesamiento Digital del Señal

jplay-sndfile es una aplicación que he estado programando la última semana y que tiene un carácter didáctico. Básicamente es un reproductor de ficheros de audio que además puede aplicar un cambio de frecuencia, y también puede hacer un barrido continuo de frecuencias sobre la muestra de audio. Es un cliente de JACK (el servidor de audio de Linux), y está basado, como punto de partida, en sndfile-jackplay que se encuentra dentro de las utilidades de la librería libsndfile (http://www.mega-nerd.com/libsndfile/tools/#jackplay).

Todo el mundo saber que cuando se reproduce un fichero de audio al doble de la frecuencia original dura la mitad de tiempo. Sería equivalente a coger una muestra de cada dos, y reproducirlas a la misma frecuencia de muestreo original.

Ahora vamos a hacer el caso contrario, queremos dividir la frecuencia por dos, y el tiempo que durará la reproducción tendría que ser el doble. Para hacerlo, lo más fácil es doblar cada muestra en dos, y reproducirlo a la frecuencia de muestreo original.

Estos dos casos especiales, multiplicar por dos y dividir por dos, son los casos fáciles y más evidentes. Un análisis de estos casos y estudiar el código fuente proporcionado puede aclarar muchos conceptos a losestudiantes de Procesamiento Digital del Señal. Ahora bien, más difícil es hacer frecuencias intermedias entre 0.5 y 2; y más difícil todavía es hacer un barrido continuo de frecuencias en un rango determinado. Todo esto es lo que se puede ver y se puede estudiar en esta aplicación que tiene un carácter didáctico.

La salida de la ayuda del programa proporciona la siguiente información:

$ jplay-sndfile -h

jplay-sndfile 1.00
Created by Joan Quintana Compte (joanillo)
joanqc arroba gmail.com – www.joanillo.org
Licensed under GPL v.3

jplay-sndfile is a JACK client intended for playing audio files (wav) and pitch shifting, written basically for learning, testing and educational purposes, and the first stage for future developments. A part of playing an audio file, you can change the pitch (between *0.5 and *2) of your audio file, you can play the audio file combing the pitch between two ranges. For testing is useful a sine wave, but remember that you can use any mono (one channel) audio files.
This Jack Audio client connects automatically to system:playback_1 and system:playback_2

usage: jplay-sndfile [-h] [[pitch-shift] | [pitch-shift-start pitch-shift-end]] wav-file

\t-h –help: this usage information
\t[pitch-shift] (0.5,2): shifting pitch
\t[pitch-shift-start] (0.5,2): shifting pitch start range
\t[pitch-shift-end] (0.5,2): shifting pitch end range
\twav file: mono channel audio file
\t

\tExamples:
\t./jplay_sndfile samples/hellosine.wav
\t./jplay_sndfile 0.65 samples/hellosine.wav
\t./jplay_sndfile 0.5 2 samples/hellosine.wav

La muestra de audio que se presenta quiere ser un compendio de qué puede hacer jplay-sndfile, y contempla los siguientes casos:

  • ./jplay_sndfile samples/test_44100.wav
  • ./jplay_sndfile .5 samples/test_44100.wav
  • ./jplay_sndfile .8 samples/test_44100.wav
  • ./jplay_sndfile 1.4 samples/test_44100.wav
  • ./jplay_sndfile 2 samples/test_44100.wav
  • ./jplay_sndfile .5 2 samples/test_44100x3.wav
  • ./jplay_sndfile samples/sine_440_44100.wav
  • ./jplay_sndfile .5 1 samples/square_440_44100.wav
  • ./jplay_sndfile 1 2 samples/saw_440_44100.wav
  • ./jplay_sndfile .5 samples/waves.wav
  • ./jplay_sndfile 2 samples/waves.wav

jplay-sndfile-examples by joanillo

Una de les cosas más interesants es estudiar la función callback de la API de JACK, que ha quedado bastante escueta, y donde está el meollo del asunto. Básicamente la función callback() es llamada por el servidor de audio cada vez que la interfície de audio (la tarjeta de sonido hardware) necesita llenar su buffer con más datos.

static int process (jack_nframes_t nframes, void * arg)
{

\tjack_default_audio_sample_t buf ;
\tunsigned int i;
\touts = (jack_default_audio_sample_t *)jack_port_get_buffer (output_port, nframes) ;

\tinfo_t *info = (info_t *) arg;
\t
\tmemcpy (outs_original, buffer2 + frames_counter_original, sizeof (jack_default_audio_sample_t) * nframes * DOUBLE_SAMPLES * 2);

\tint k=0;
\tfloat k2;
\tk2 = nframes/info->shift_pitch;
\tfloat var, var2 = 0;
\tint part_entera = 0;
\tvar = 1/info->shift_pitch – 1;

\tfor (i = 0 ; i < nframes ; i++)
\t{\t

\t\tif (info->shift_pitch < 1) {
\t\t\tif (frames_counter + i >= info->numFrames / shift_pitch_equivalent) { // shift_pitch_equivalent = info.shift_pitch quan no faig un escombrat
\t\t\tinfo->play_done=1;
\t\t\treturn 0;
\t\t\t}
\t\t} else { // >= 1
\t\t\tif (frames_counter_original + i >= info->numFrames * DOUBLE_SAMPLES) {
\t\t\tinfo->play_done=1;
\t\t\treturn 0;
\t\t\t}
\t\t}
\t\t
\t\tif (info->shift_pitch > 1) {
\t\t\tk=(int)(i*DOUBLE_SAMPLES*info->shift_pitch + .5);
\t\t\touts[i] = outs_original[k];\t
\t\t} else if (info->shift_pitch <= 1) {
\t\t\touts[k] = outs_original[i*DOUBLE_SAMPLES];
\t\t\tif ((int)var2 != part_entera) {
\t\t\t\touts[k+1] = outs_original[i*DOUBLE_SAMPLES+1];
\t\tpart_entera = int(var2);
\t\tk++;
\t\t\t}
\t\t\tvar2 = var2 + var;
\t\t\tk++;\t\t\t
\t\t}

\t}
\tframes_counter += nframes;
\tframes_counter_original += nframes * DOUBLE_SAMPLES * info->shift_pitch ;
\t
\treturn 0 ;
} /* process */

¿Y para qué sirve todo esto? Como hemos dicho es una aplicación didáctica, sirve sobre todo para aprender:

  • para aprender: teoría del Procesamiento Digital del Señal
  • para aprender: API de libsndfile
  • para aprender API de JACK, ejemplo de cómo funciona la función de callback

pero a parte de aprender, se ha desarrollado con una idea en mente, que ha de ser el siguiente proyecto a realizar: utilizar una tableta gráfica Wacom, de las que utilizan los diseñadores gráficos, para producir sonidos realísticos, sensibles al movimiento y a la presión del lápiz, pero esto es otro proyecto: Reconocimiento real de gestos con la wacom y Síntesis de audio

Wacom Theremin

El Theremin es un instrumento inventado por Léon Theremin en 1918 que tiene la particularidad de que se toca con los gestos de las manos. Está considerado uno de los primeros instrumentos electrónicos, y su sonido sintético y característico se ha utilizado muchas veces para películas de ciencia ficción y efectos especiales.

En este proyecto se implementa la manera de tocar y el sonido de un theremin con un controlador poco convencional: una tableta gráfica Wacom de las que utilizan los diseñadores gráficos. Si sabes cómo se toca un theremin la implementación es evidente:  con el eje x cambias el tono (Pitch Bend en terminología MIDI; con el eje y cambias el volumen; y claro: apretar el lápiz produce el sonido de la nota (mensaje MIDI NoteOn) y levantar el lápiz apaga la nota (NoteOff). Además de la posición XY, la tecnología wacom proporciona otros sensores que dan información como es la presión y la inclinación. Aunque no se ha hecho en este proyecto, se podría haber asociado la presión y la inclinación a otros mensajes MIDI CC (Continuous Controller) com pueden ser la modulación (efecto de vibrato).

Se ha utilizado un sintetizador Roland JV-2080 para producir un sonido de Theremin, aunque no estoy muy contento con el resultado obtenido. Lo bueno del JV-2080 es que tiene un espacio de memoria para guardar los patch de usuari y muchos parámetros, osciladores y efectos para poder ir jugando si tienes suficiente tiempo. Y lo que es mejor del JV-2080 es que puedes configurar el pitch bend (variación del tono) con una amplitud muy grande, también configurable, cosa que normalmente no pasa en otros sintes (sobretodo los sintes software).

Una de las cosas que me ha gustado más del proyecto es la integración de la aplicación desarrollada en lenguaje C (hay un enlace para descargar el código más abajo) con Gimp (el editor de imágenes y fotos de referencia en el mundo Linux). Esto da pie a múltiples posibilidades y ideas para hacer proyectos que combinen Gimp con efectos sonoros y interactivos.

Evidentmente, la idea no es nueva, hay otra gente que ha hecho Theremins con wacom’s y otros controladores como la Wii, pero en el proyecto 50 Ways to Play Una Plata d’Enciam no podía faltar un Wacom Theremin hecho exclusivamente con herramientas de Código Libre.

smf_parser v1.01: SMF (Standard Midi File) Parser


jplayfine (http://wiki.joanillo.org/index.php/Jplayfine) es un proyecto musical que estoy desarrollando, que consiste en poder hacer un play-along sobre un fichero midi (fichero SMF), y que puedas obtener una nota relacionada con la similitud entre lo que has tocado y lo que se supone que has de tocar. Para hacerlo, el programa ha de saber en qué canal está la melodía en el fichero midi, y por qué canal
toca el controlador midi. jplayfine es un cliente JACK que convive bien dentro del ecosistema de las aplicaciones de audio y midi para Linux. Bien, hablaré de jplayfine en otra ocasión.

Aunque jplayfine utiliza un secuenciador externo per hacer sonar el fichero midi (las pruebas las estoy haciendo con jack-smf-player), el tema es que desarrollando el proyecto jplayfine me he encontrado con la necesidad de parsear el fichero midi que contiene la melodía y el acompañamiento. Podia utilizar la librería smf.h que utiliza jack-smf-player. La verdad es que, con los objetivos de buscar la simplicidad, tener el máximo control del código, y entender con
profundidad el formato MIDI, me he embarcado en hacer un parseador de SMF con C++. Aquí va la versión 1.01, por si alguien se lo quiere mirar. Por una parte hay una aplicación standalone; y por otra hay la librería y una aplicación de test que muestra como utilizar la librería. También hay una carpeta midi/ con los midifiles que se han utilizado para testear. Para utilizar la librería necesitas un ompilador C++ para Linux (g++).

Enlace del proyecto: http://wiki.joanillo.org/index.php/Fitxers_MIDI_(SMF)._Format#smf_parser
Información sobre el protocolo MIDI: http://www.sonicspot.com/guide/midifiles.html
Descargar smf_parser1.01

Canción de cuna muy personal

Estos días estoy cantando a Pere y a María una canción de cuna que tiene un significado muy especial. Es una canción de cuna que le cantaba mi abuela Montserrat a mi padre, y es realmente muy original, no es para nada conocida. Mi abuela nació en una masía en La Guàrdia, en la subcomarca del Lluçanès (Cataluña), una zona con entidad propia entre Puigreig y Vic. Precisamente, todo el folklore de la zona lo documentó Josep M. Vilarmau, allá por los años 40 del s. XX, que era precisamente primo de mi abuela, además de colega del folklorista Joan Amades. Hizo una obra de referencia para estudiar las canciones de la comarca <: Folklore del Lluçanès, y esta canción de cuna, sin título, precisamente no está.

Es una canción muy sencilla y dulce, como han de ser las canciones para hacer dormir a los niños. Mi padre la ha arreglado para piano, plasmando esta dulzura y simplicidad armónica. Yo sólo la he transcrito con lilypond y la he grabado con un buen sonido de piano. Así pues, mi reconocimiento para mi abuela (al cielo esté), a mi padre, y a todo el patrimonio inmaterial que representa el folklore de las tierras catalanas. La letra (traducción del catalán):

El ángel del sueño tiene las alas blancas,
tiene el cabello dorado y el vestido de plata.
El ángel del sueño que del cielo desciende.

El ángel del sueño al niño acompaña,
le mece en la cuna y los ojitos les cierra.
El ángel del sueño le besa y le canta.

Lilypond es un sistema de edición musical muy completo y que produce unas partituras de gran calidad. Eso sí, es un poco complicado de utilizar, aunque hay mucha información disponible. Yo sou un firme partidario. He transcrito la partitura manuscrita a lilypond, y aquí puedes ver el resultado:

Cançó de Bressol (descarga)

Lilypond, además de salida pdf, también produce la salida midi. Este fichero midi lo he hecho sonar con el sinte fluidsynth, que puede funcionar en línea de comandos, y que he cargado con un buen sonido de piano. Así de simple:

$ fluidsynth -l -a jack -m alsa_seq -g 1 /var/soundfonts/Musica_Theoria_v2_GM.sf2 /home/joan/lilypond/canco_bressol_v3.midi

El sonido que produce el fluidsynth se ha grabado en Ardour (el DAW de referencia en el mundo Linux), y sin más, sin añadir ningún efecto, lo he convertido a wav (y a mp3 con lame). Aquí puedes ver el resultado.
Cançó de bressol by joanillo

Espero que en un futuro esta canción se pueda ir transmitiendo de generación en generación y que quede com un bien preciado en mi familia.

El sintetizador más simple, controlado con un sensor lineal

simplest_synth
Después de bastante tiempo, una nueva entrega del proyecto 50 maneras de tocar Una Plata d’Enciam. Esta vez quiero enseñaros los principios más básicos de la síntesis de audio. Es un proyecto muy sencillo, básic y barato, con grandes posibilidades de éxito incluso para los novatos en electrónica.

Recuerdo de las épocas de la universidad cuando estudiaba los circuitos RC, las ecuaciones diferenciales asociadas, y cómo la curva de carga y descarga de un condensador es una función exponencial. En este circuito conseguimos cargar y descargar el condensador de forma cíclica, gracias a dos transistores que se abren cuando el condensador está cargado, y se cierran cuando el condensador se descarga. Escogiendo los valores de resistencia y condensador adecuados la frecuencia de resonancia está dentro del espectro audible, que podemos escuchar con un pequeño altavoz. Con una resistencia variable podemos conseguir variar la frecuencia, consiguiendo un pequeño theremin o tanerino.

I aquí va el video mostrando cómo se construye este pequeño sintetizador, y cómo se puede tocar una canción como Una Plata d’Enciam.

Más información en la wiki

Tannerin: slide theremin synth

tannerinThis is a tannerin, not a real theremin. It is played with a slide (similar to a ribbon sensor), and the most known performance with this synth is Good Vibrations by the Beach Boys (Pet Sound album, 1966). Brian Wilson plays the instrument adviced by Paul Tanner, who was at the time using the instrument, build by Tom Polk.

The Tannerin is an electronic instrument that produces a pure sine wave, variable over three or four octaves. It is played by sliding a knob along the length of the instrument, on some models starting and stopping the tone with a contact switch located on the pitch knob and operated by one’s forefinger. You can see the video how Brian Wilson plays the tannerin: