Archivo por meses: febrero 2012

jcapture: grabar la señal del micro a un fichero wav

jcapture es un pequeño programa desarrollado en C++ que capta la señal del micrófono y escribe un fichero de audio en format wav. Básicament es un cliente de JACK que se conecta automáticamente a system:capture_1, que es el puerto físico que representa la entrada del micro de la tarjeta de sonido, y mediante la librería libsndfile va escribiendo los datos del micro en el buffer del fichero de audio.

Además, muestra el nivel del señal de entrada de forma gráfica en la consola (pues es un programa que funciona por la consola, no tiene interficie gráfica). Si te interesa la programación de la API de JACK puedes descargar jcapture:

Google no acierta en dibujar una onda senoidal

Hoy es el 155 aniversario del nacimiento de Heinrich Rudolf Hertz (155 no es un número para nada significativo, ¿no tenían nada mejor que contar la gente de Google). Para ilustrarlo han hecho una animación de una onda senoidal bastante desastrosa. Todo el mundo sabe que la derivada del seno es el coseno, y que por tanto la pendiente del seno en el origen vale 1,

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

Si los ejes x e y tienen la misma escala quiere decir que la pendiente cuando la función seno cruza el eje horizontal tiene que ser una recta de 45º. Como la función coseno toma valores entre -1 i 1, la pendiente en cualquiera de los puntos no puede ser una recta vertical!!

Vaya, que hay gente que para dibujar ondas senoidales se dedica a enlazar semicírculos… un poco de cultura matemática por favor…

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.