Arxiu mensual: febrer de 2012

jcapture: gravar el so del micro a un fitxer wav

jcapture és un petit programa desenvolupat amb C++ que capta el senyal del micròfon i escriu un fitxer d’audio amb format wav. Bàsicament és un client de JACK que es connecta automàticament a system:capture_1, que és el port físic que representa l’entrada del micro de la targeta de so, i mitjançant la llibreria libsndfile va escribint les dades del micro en el buffer del fitxer d’audio.

A més, mostra el nivell del senyal d’entrada de forma gràfica en la consola (doncs és un programa que funciona per la consola, no té interfície gràfica). Si t’interessa la programació de l’API de JACK pots descarregar jcapture:

Google no l’encerta a l’hora de dibuixar una funció sinus

Avui és el 155 aniversari del naixement de Heinrich Rudolf Hertz (155 no és un número gens significatiu, no tenien res millor que explicar la gent de Google?). Per il·lustrar-ho han fet una animació d’una ona sinuoidal bastant desastrosa. Tot el món sap que la derivada del sinus és el cosinus, i que per tant el pendent del sinus en l’origen val 1,

sin'(0) = cos(0) = 1

Si els eixos x i y tenen la mateixa escala vol dir que el pendent quan la funció sinus creua l’eix horitzontal ha de ser una recta de 45º. Com la funció cosinus agafa valors entre -1 i 1, el pendent en qualsevol dels punts no pot ser una recta vertical!!

Vaja, que hi ha gent que per dibuixar ones sinusoidals es dedica a enllaçar semicercles… una mica de cultura matemàtica si us plau…

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.