Arxiu de la categoria: Música Electrònica

Frozen. Gravació a casa de la Maria i les seves amigues


El dimarts passat van venir la Maria i tres de les seves amigues (la Laia, l’Adela i la Martina) a dinar al migdia, per tal de gravar un parell de temes de Frozen. Realment aquestes nenes estan posseïdes per Frozen, la Maria ja ha vist la peli 5 vegades. La qüestió és que amb dues hores i mitja havíem de fer molt feina, a més de dinar. El dinar ho vam solucionar ràpid, arròs a la cubana per 5 i rapidets que hi ha molta feina.

Mans a l’obra, una mica d’escalfament. Jo ja ho tenia tot preparat: dos micros per a les quatre que entraven en una pista de l’Ardour. En altres dues pistes havia gravat prèviament les cançons del Vol Volar (Let it Go) i Per primer cop en la Vida (For the First Time in Forever), que són les cançons que havíem planificat de gravar (bé, en principi el Vol Volar, la segona era de reserva).

Vam fer vàries tomes del Let it Go, però només dues tomes del Per Primer Cop… El resultat és prou satisfactori tenint en compte que són nenes de 9 anys. A millorar realment les entrades (que té solució si es practica), i l’afinació (més difícil de solucionar). A més, el fet de què estiguessin emocionades amb l’experiència no ajudava gens.

Al final vaig escollir una de les tomes. Per exportar el audio sense matar-m’hi massa he equilibrat la pista instrumental amb la pista de les veus, i he aplicat a les veus una mica de compressió, chorus i reverb, tot de forma moderada, i ja tinc el mp3. Tot això fet amb Ardour com a DAW multipista. (Linux, of course).

Pel tema del video vaig cometre un fallo. Em vaig acontentar amb gravar un sol video, pensant que l’ajuntaria amb la versió bona de l’àudio, i no. En els dos videos que es mostren es veu clarament una falta de sincronia entre el video i les veus. A part de la falta de sincronia en les entrades, es veu irreal. Per la propera vegada gravaré en video totes les tomes, i sempre seré a temps d’esborrar els videos descartats.

En aquestes gravacions allò ideal és utilitzar cascos per totes les participants. Necessitaria una cosa similar a això. Com que no en disposo d’amplificador d’auriculars, s’ha utilitzat un monitor de camp proper, intentant que el so no entri pels micròfons. Això s’aconsegueix controlant la distància, el volum i que el monitor quedi al darrera dels micros. La part de senyal que ha entrat als micros és mínima, tot i que no nul·la.

Així doncs, el material que s’ha utilitzat és:

  • Ordinador Linux Ubuntu 12.04 amb JACK i Ardour
  • Targeta de so externa, Edirol UA25EX
  • Mesclador de 4 entrades (de les quals només se n’han utilitzat dues)
  • 2 micròfons
  • Monitor de camp proper

El resultat: dos videos que s’han penjat al Youtube. Els ha encantat veure com el seu video es barrejava amb les animacions de les protagonistes de Frozen: l’Elsa i l’Anna.

diatonicbaixos v1.0: ajuda per als baixos de l’acordió diatònic

La Maria està estudiant l’acordió diatònic (i de passada jo també m’hi he enganxat). Una de les coses que sempre he trobat difícils és la coordinació de la mà dreta (amb la que toquem la melodia) i la mà esquerra (els baixos). Igual que passa amb el piano, que sempre m’ha semblat difícil tocar amb les dues mans alhora.

Aquí va un petit programa per ajudar a posar la mà esquerra en l’acordió diatònic. Mentre sona la melodia (es necessita el fitxer midi de la melodia), per pantalla es mostren les posicions dels baixos que s’han de tocar (en l’acordió diatònic hi ha 8 botons per als baixos/acords, que sonen diferent si obres o tanques la manxa). Quan es mostra un botó en color verd vol dir que s’ha de tancar la manxa; en color vermell s’ha d’obrir.

Per a la interfície gràfica s’ha utilitzat la llibreria ncurses, que és la primera vegada que programava en aquesta llibreria (i estic molt content del resultat obtingut). El programa és un client de JACK (el servidor d’audio per a Linux, www.jackaudio.org), i de fet és el time master, és a dir, controla el transport. Per utilitzar l’aplicatiu el millor és llençar el script bash que es proporciona, diatonicbaixos.sh, on es posa de manifest tota la cadena de programes que s’utilitzen.

Primer de tot canvio el tempo desitjat al fitxer midi mitjançant el script change_tempo_smf (es proporciona el codi font). Tot seguit s’arrenca el servidor JACK, i el sintetitzador fluidsynth, que és el que farà sonar la melodia. Després arrenquem la utilitat jack-smf-player, que s’encarregarà de fer sonar la melodia. També arrenco el klick, que és un metrònom client de JACK. Finalment ja puc llençar la meva aplicació, diatonicbaixos. El resultat, com es veu en el video, és que sona la melodia mentre es van mostrant les posicions dels baixos. Es pot canviar el tempo, es pot habilitar o no el metrònom, i hi ha un altre paràmetre amb el qual es mostra el següent baix que s’haurà de pitjar.

Per fer-se una idea del funcionament del programa el millor és veure el video:

Descarrega diatonicbaixos v1.0

50 ways… #6. Editors de partitures: Lilypond

En l’anterior post vam crear un soundfont per a acordió diatònic, castagnari.sf2, i amb els seus sons vam tocar la meva canço preferida: Una Plata d’Enciam, dins del projecte 50 ways to play Una Plata d’Enciam. Anem a veure ara com amb l’editor de partitures Lilypond podem crear una partitura molt correcta, que respongui als reptes que ens planteja la notació per a acordió. El que aquí farem en aquest post no és res de l’altre món. En el blog amic Scores of Beauty, http://lilypondblog.org/, porten a l’extrem les possibilitats de lilypond.

Bàsicament el que volem és visualitzar correctament la melodia, els acords, i com s’han de tocar els baixos/acords de la mà esquerra (és a dir, l’acompanyament). La idea és crear unes partitures didàctiques que ajudin a la meva filla a posar els dits de la mà esquerra.

El primer que farem és crear la melodia, posarem a sobre de les notes els acords de la forma habitual, i mostrarem quan s’ha de tocar un baix (b) i un acord (a) amb la mà esquerra. Això últim ho farem amb \\lyrics, com si fos la lletra d’una cançó.

\\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 { }
}

Ara anem a posar els baixos. Si ho fem de la forma habitual funciona, però queda una partitura que no és útil per a llegir. A més a més no és correcta, doncs com s’ha explicat en l’anterior post l’associació entre els acords CM, DM,… i les notes midi 24, 26,… va ser una decisió arbitrària. Quedaria de la següent 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í és important remarcar que s’ha utilitzat la notació relativa, i la notació absoluta per als baixos, que simplifica molt escriure l’alternança entre baixos i acords. Aquesta partitura no és correcta per a imprimir, però el fitxer midi que produeix sí que és correcte. Hi ha una manera de solucionar-ho? Sí. Es pot definir un \\score per a ser imprès, i un altre \\score per a generar el fitxer midi. El resultat queda de la següent manera: la partitura per a imprimir és correcta (no apareixen les notes dels baixos, només les posicions on hem de posar els dits de la mà esquerra); i el fitxer midi resultant també és correcte:

\\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 { }
}

Finalment podem escoltar la cançó Una Plata d’Enciam com quedaria amb acordió diatònic:

Una Plata d’Enciam by joanillo

Referències:

Solució portàtil per a un saxo electrònic: Raspberry PI + soft o hard sinte

EWI-USB and Raspberry Pi

EWI-USB and Raspberry Pi

Per tocar el controlador de vent EWI-USB normalment em connecto al portàtil. Faig córrer el fluidsynth o qualsevol altre soft synth. Per tant, la solució per practicar és EWI-USB + portàtil + auriculars. Existeix una solució més portable i autònoma? Definitivament sí utilitzant la Raspberry Pi, buscant una solució purament consola i totalment desatesa: enxufar i tocar. En aquesta ocasió no utilitzo JACK, és una solució purament ALSA. Es tracta d’instal·lar el fluidsynth, algun soundfont que soni bé i que no pesi massa, configurar l’usuari pi amb prioritat realtime, i desinstal·lar qualsevol servei que no hagi de fer servir.

Amb un script a /etc/udev/rules.d/ewiusb.rules aconseguim que en el moment que connecto el EWI-USB pel port USB s’executin les comandes que em permetran tocar automàticament: executar fluidsynth i connectar la sortida midi del EWI-USB a l’entrada midi del fluidsynth. He tingut bastants problemes per tal de no tenir latència, però el script que es dóna més avall a mi em funciona bé sense latència.

A més, amb una mica d’electrònica senzilla i utilitzant els pins GPIO es podria canviar fàcilment el programa midi i poder triar entre diferents instruments: saxo, midi, flauta,…

Una altra possibilitat, com es veu a la fotografia, és utilitzar un sinte hardware com ara el Roland JV-1010. Com que l’entrada del JV-1010 és purament midi es necessita un cable conversor USB2MIDI (per ex, http://www.amazon.com/dp/B0017H4EBG), que mostra els seus ports a ALSA. Amb aquesta solució no has de témer per la latència, és una magnífica experiència d’usuari, i podem triar entre centenars de sons.

/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ó a la wiki

jplay-sndfile: una aplicació educativa per a Processament Digital del Senyal

jplay-sndfile és una aplicació que he estat programant la última setmana i que té un caràcter didàctic. Bàsicament és un reproductor de fitxers d’àudio, que a més pot aplicar un canvi de freqüència, i també pot fer un escombrat continu de freqüències sobre la mostra d’àudio. És un client de JACK (el servidor d’audio de Linux), i està basat com a punt de partida en sndfile-jackplay que es troba dins les utilitats de la llibreria libsndfile (http://www.mega-nerd.com/libsndfile/tools/#jackplay).

Per tothom és sabut que quan es reprodueix un fitxer d’àudio al doble de la freqüència dura la meitat de temps. Seria equivalent a agafar una mostra de cada dues, i reproduir-les a la mateixa freqüència de mostreig original.

Ara anem a fer el cas contrari, volem dividir la freqüència per dos, i el temps que durarà la reproducció hauria de ser el doble. Per fer-ho, el més fàcil és doblar cada mostra en dues, i reproduir-ho a la freqüència de mostreig original.

Aquests dos casos especials, multiplicar per dos i dividir per dos, són els casos fàcils i més evidents. Un anàlisi d’aquests casos i estudiar el codi proporcionat pot aclarir molts conceptes per als estudiants del Processament Digital del Senyal. Ara bé, més difícil és fer freqüències intermitges entre 0.5 i 2; i més difícil encara és fer un escombrat continu de freqüencies en un rang determinat. Tot això és el que es pot veure i es pot estudiar en aquesta aplicació que té un caràcter didàctic.

La sortida de l’ajuda del programa proporciona la següent informació:

$ 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 mostra d’audio que es presenta vol ser un compendi de què pot fer jplay-sndfile, i contempla els següents 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 coses més interessants és estudiar la funció callback de la API de JACK, que ha quedat bastant petita, i on està tot el moll de l’os de l’aplicació. Bàsicament la funció callback() la crida el servidor d’àudio cada vegada que la interfície d’àudio (la targeta de so hardware) necessita omplir el seu buffer amb dades.

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 */

I per a què serveix tot això? És una aplicació didàctica, serveix sobretot per aprendre:

  • per aprendre: teoria del Processamet del Senyal
  • per aprendre: API de libsndfile
  • per aprendre: API de JACK, exemple de com funciona la funció de callback

però a part d’aprendre, s’ha desenvolupat amb una idea en ment, que ha de ser el següent projecte: utilitzar una tauleta gràfica Wacom, les que fan servir els dissenyadors gràfics, per produir sons realístics, sensibles al moviment i a la pressió del llapis, però això serà el següent projecte: Reconeixement real de gestos amb la wacom i Síntesi d’àudio

Wacom Theremin

El Theremin és un instrument inventat per Léon Theremin el 1918 que té la particularitat de què es toca amb els gestos de les mans. Està considerat un dels primers instruments electrònics, i el seu so sintètic i característic s’ha utilitzat moltes vegades per a pel·lícules de ciència ficció i efectes especials.

En aquest projecte s’implementa la manera de tocar i el so d’un theremin amb un controlador poc convencional: una tauleta gràfica Wacom de les que fan servir els dissenyadors gràfics. Si saps com es toca un theremin la implementació és evident: amb l’eix x canvies el to (Pitch Bend amb terminologia MIDI; amb l’eix y canvies el volum; i clar: apretar el llapis produeix el so de la nota (missatge MIDI NoteOn) i aixecar el llapis apaga la nota (NoteOff). A més de la posició XY, la tecnologia wacom proporciona altres sensors que donen informació com és la pressió i la inclinació. Encara que no s’ha fet en aquest projecte, es podria haver associat la pressió i la inclinació a altres missatges MIDI CC (Continuous Controller) com ara la modulació (efecte de vibrato).

S’ha utilitzat un sintetitzador Roland JV-2080 per tal de produir un so de Theremin, tot i que no estic molt content amb el resultat obtingut. Allò bo del JV-2080 és que té un espai de memòria per guardar els patch d’usuari i motls paràmetres, oscil·ladors i efectes per poder anar jugant si tens suficient temps. I el que és millor del JV-2080 és que pots configurar el pitch bend (variació del to) amb una amplitud molt gran, també configurable, cosa que normalment no passa en altres sintes (sobretot els sintes software).

Una de les coses que m’ha agradat més del projecte és la integració de l’aplicació desenvolupada amb llenguatge C (hi ha l’enllaç per descarregar el codi més avall) amb Gimp (l’editor d’imatges i fotos de referència en el món Linux). Això dóna peu a múltiples possibilitats i idees per fer projectes que combinin Gimp amb efectes sonors i interactius.

Evidentment, la idea no és nova, hi ha altra gent que ha fet Theremins amb wacom’s i altres controladors com la Wii, però en el projecte 50 Ways to Play Una Plata d’Enciam no podia faltar un Wacom Theremin fet exclusivament amb eines de Codi Lliure.

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


jplayfine (http://wiki.joanillo.org/index.php/Jplayfine) és un projecte musical que estic desenvolupant, que consisteix en poder fer un play-along sobre un fitxer midi (fitxer SMF), i que puguis obtenir una nota relacionada amb la similitud entre el que has tocat i el que se suposa que has de tocar. Per fer-ho, el programa ha de saber en quin canal està la melodia en el teu fitxer midi, i per quin canal toca el teu controlador midi. jplayfine és un client JACK que conviu bé dins de l’ecosistema de les aplicacions d’àudio i midi per a Linux.
Bé, parlaré del jplayfine en una altra ocasió.

Tot i que jplayfine utilitza un seqüenciador extern per fer sonar el fitxer midi (les proves les estic fent amb jack-smf-player), el tema és que desenvolupant el projecte jplayfine m’he trobat amb la necessitat de parsejar el fitxer midi que conté la melodia i l’acompanyament. Podia utilitzar la llibreria smf.h que utilitza jack-smf-player. La veritat és que, amb els objectius de buscar la simplicitat, tenir el màxim control del codi, i entendre amb profunditat el format MIDI, m’he embarcat en fer un parsejador de SMF amb C++. Aquí va la versió 1.01, per si algú se la vol mirar. D’una
banda hi ha una aplicació standalone; i d’altra banda hi ha la llibreria i una aplicació de test que mostra com utilitzar la llibreria. També hi ha una carpeta midi/ amb els midifiles que s’han utilitzat per testejar. Per utiltizar la llibreria necessites un compilador C++ per a Linux (g++).

Enllaç del projecte: http://wiki.joanillo.org/index.php/Fitxers_MIDI_(SMF)._Format#smf_parser
Informació sobre el protocol MIDI: http://www.sonicspot.com/guide/midifiles.html
Descarregar smf_parser1.01

Cançó de bressol molt personal

Aquests dies estic cantant al Pere i a la Maria una cançó de bressol que té un significat molt especial. És una cançó de bressol que li cantava la meva àvia Montserrat al meu pare, i realment és molt original, no és gens coneguda. La meva àvia va néixer en una masia a La Guàrdia, al Lluçanès, en una zona amb entitat pròpia entre Puigreig i Vic. Precisament, tot el folklore de la zona el va documentar molt el Josep M. Vilarmau, allà pels anys 40 del s. XX, que era precisament cosí de la meva àvia, a més de colega del folklorista Joan Amades. Va fer una obra de referència per estudiar les cançons de la contrada: Folklore del Lluçanès, i aquesta cançó de bressol, sense títol, precisament no hi és.

És una cançó molt senzilla i dolça, com han de ser les cançons per fer dormir als infants. El meu pare l’ha arranjat per a piano, plasmant aquesta dolçor i simplicitat harmònica. Jo només l’he transcrit amb lilypond i l’he gravat amb un so de piano. Així doncs, el meu reconeixement per a la meva àvia al-cel-siga, al meu pare, i a tot el patrimoni immaterial que representa el folklore de les terres catalanes. La lletra:

L’àngel de la son té les ales blanques,
té el cabell daurat i el vestit de plata.
L’àngel de la son que del cel davalla.

L’àngel de la son l’infant acompanya,
li gronxa el bressol i els ullets li tanca.
L’àngel de la son el besa i li canta.

Lilypond és un sistema d’edició musical molt complet i que produeix unes partitures de gran qualitat. Això sí, és una mica complicat de fer servir, tot i que es troba bastanta informació. Jo en sóc un ferm partidari. He transcrit la partitura manuscrita a lilypond, i aquí en pots veure el resultat:

canco_bressol (descarrega)

Lilypond, a més de la sortida pdf, també produeix la sortida midi. Aquest fitxer midi l’he fet sonar amb el sinte fluidsynth, que pot funcionar amb línia de comandes, i que he carregat amb un bon so de piano. Així 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 so que produeix el fluidsynth s’ha gravat a l’Ardour (el DAW de referència en el món Linux), i sense fer res més, sense afegir cap efecte, l’he convertit a wav (i a mp3 amb lame). I aquí pots veure el resultat.
Cançó de bressol by joanillo

Espero que en un futur aquesta cançó es pugui anar transmetent de generació en generació i que quedi com un bé preuat en la meva família.

El sintetitzador més simple, controlat amb un sensor linial

simplest_synth
Després de bastant de temps, una nova entrega del projecte 50 maneres de tocar Una Plata d’Enciam. Aquest cop vull ensenyar-vos els principis més bàsics de la síntesi d’audio. És un projecte molt senzill, bàsic i barato, amb grans possibilitats d’èxit fins i tot per la gent sense experiència en electrònica.

Recordo de les èpoques de la universitat en què estudiava els circuits RC, les equacions diferencials associades, i com la corba de càrrega i descàrrega d’un condensador és una funció exponencial. En aquest circuit aconseguim carregar i descarregar el condensador de forma cíclica, gràcies a dos transistors que s’obren quan el condensador està carregat, i es tanquen quan el condensador es descarrega. Escollint els valors de resistència i condensador adequats la freqüencia de ressonància està dins l’espectre audible, que podem escoltar amb un petit altaveu. Amb una resistència variable podem aconseguir variar la freqüència, aconseguint un petit theremin o tannerin.

i aquí va el video mostrant com es construeix aquest petit sintetitzador, i com es pot tocar una cançó com Una Plata d’Enciam.
més informació a 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: