Nightly build

Todo programador ha pasado alguna vez por la experiencia de depurar un programa a golpe de printf(), con los inconvenientes que ello supone, sobre todo recompilar cada vez que se quiere cambiar la información que se imprime en la traza.

Pues resulta que es posible hacer las cosas “bien” :)

Con gdb podemos imprimir los valores de variables de nuestro programa, eso es algo que todos sabemos PERO tambien podemos darle una serie de órdenes a ejecutar al pasar por un breakpoint.

Veamos un ejemplo. Sea el siguiente programa en C:

#include <stdio.h>

int main()
{
        int i;
        double x=2.0f;
        for (i=0; i<64; i++)
                x*=2;
        return 0;
}

Si compilamos con -g (para debug) y lo lanzamos en gdb podemos visualizar los valores de x así:


(gdb) break 8
Breakpoint 1 at 0x400463: file a.c, line 8.
(gdb) commands 1
Type commands for when breakpoint 1 is hit, one per line.
End with a line saying just "end".
>silent
>printf "x=%g\n",x
>cont
>end
(gdb) r
Starting program: /home/slack/a.out
x=2
x=4
x=8
x=16
x=32
x=64
[...]


El “silent” del principio es para que gdb no imprima la información que suele mostrar al pararse en un breakpoint (fichero, número de línea, contador de programa, etc) y la traza salga más limpia.

Por supuesto se pueden hacer mas cosas. gdb permite definir variables externas al programa y ejecución condicional, así que podemos contar las veces que pasamos por algun sitio y lanzar órdenes en momentos concretos y tonterías similares :D

Happy coding!

3) Más ondas básicas

No solo de senos vive el hombre (salvo que nos pongamos a hacer síntesis aditiva), así que vamos a ver unas cuantas ondas más que podemos utilizar como base para construir sonidos.

• Onda cuadrada:

  Get the Flash Player to see this player.

  Se obtiene alternando dos valores (en nuestro caso +1 y -1) con la frecuencia deseada. Expresado en código, podría ser algo como esto:

  // Generacion del i-esimo sample de una onda cuadrada
  // de frecuencia f
  float t = i/sampling_rate; // instante i en segundos
  float periodo = 1.0f / f; // periodo de la onda en segundos
  if (fmodf(t,periodo) < periodo/2.0f)
      y[i] = 1.0f;
  else
      y[i] = -1.0f;
  

  

  Otra posibilidad es hacer que las zonas a +1 y -1 no tengan la misma longitud (pulse width modulation)

• Onda de diente de sierra:

  Get the Flash Player to see this player.

  En cada periodo, aumenta linealmente desde -1 a 1, cayendo bruscamente a -1 en el comienzo del siguiente periodo. Dicho en C viene a ser:

  // Sample i-esimo, frecuencia f
  float t = i/sampling_rate;
  float periodo = 1.0f / f;
  y[i] = 2.0f*(fmodf(t, periodo)/periodo)-1.0f;
  

  

• Onda triangular:

  Get the Flash Player to see this player.

  Es parecida a la anterior, pero durante la mitad del periodo crece linealmente de -1 a 1, y durante la otra mitad decrece linealmente volviendo a -1, sin discontinuidad.

  // Sample i-esimo, frecuencia f
  float t = i/sampling_rate;
  float periodo = 1.0 / f;
  float semiperiodo = periodo/2.0f;
  if (fmodf(t,periodo) < periodo/2.0f)
      y[i] = 2.0f*(fmodf(t,semiperiodo)/semiperiodo)-1.0f;
  else
      y[i] = 1.0f-2.0f*fmod(t,semiperiodo)/semiperiodo;
  

  

En el programa de ejemplo de este capítulo (ahora con un 100% más de Makefile) está todo esto en forma compilable para poder probarlo fácilmente. Por cierto, ninguno de los ejemplos está optimizado porque pretenden ser lo más claros posible, si alguien tiene sugerencias sobre como implementar mejor cualquier cosa nos lo podemos pasar muy bien comentándolas :)

En fin, esto es todo por hoy. En el próximo post, cosillas sobre espectros de frecuencias y aliasing (supongo que la pereza me obligará a dejarme los filtros para dentro de dos posts :)

EDIT: A peticion de pplux, ahi van los enlaces a los posts anteriores:

• Parte II: Senos!!!
• Parte I: Haciendo ruido

2) Senos!!!

Después del ruido del capitulo anterior, vamos a pasar a algo ligeramente más interesante: la onda senoidal. Como podéis ver si seguís el enlace a la pagina sobre la onda senoidal en la wikipedia, junto con dibujitos y explicaciones interesantes, la formula es:

y = A·sin(w·t + fase)

donde A es la amplitud de la onda (la distancia entre una cresta y un valle), w es la frecuencia en radianes/segundo y t es el tiempo. Vamos a ignorar la fase porque no nos hace falta :)

Como nos gusta trabajar con frecuencias en hercios, multiplicamos por 2·pi. Además, tenemos que t = samples generados / frecuencia de muestreo. Por lo tanto en el código tendremos algo como:

y[i] = A*sin(2*pi*frecuencia*(i/sampling_rate))

para el sample i-ésimo desde el inicio del sonido. Vamos a ver el trozo de código correspondiente (lo que falta es, básicamente, la inicialización del capítulo anterior):

void play(void *userdata, Uint8 *stream, int len)
{
    int num_samples = len / 2;
    Sint16 *dst_buf = (Sint16*) stream;
    for (int i=0; i<num_samples ; ++i)
        buffer[i] = sin(2.0*M_PI*440.0f*(i+pos)/(float)SAMPLING_RATE);

    // Clipping y conversion a Sint16
    for (int i=0; i<num_samples; ++i)
    {
        float v = buffer[i];
        if (v > 1.0f)
            v = 1.0f;
        else if (v< -1.0f)
            v = -1.0f;

        dst_buf[i] = (Sint16)(32767.0f*v);
    }
    pos += num_samples;

}

Detalles destacables de esta función:

• se trabaja con un buffer de floats y se convierte a entero al final. No mola ir perdiendo precisión por el camino, sobre todo cuando hagamos cosas mas complejas
• hay clipping a [-1.0, 1.0]. Ahora mismo es completamente innecesario porque sin() devuelve valores en ese intervalo, pero cuando empecemos a mezclar varios sonidos vendrá bien :)
• en la llamada a sin(), el 440.0f es la frecuencia de la nota que suena (un La4), y pos es una variable global que guarda el índice del ultimo sample generado entre llamadas a play(). Es feo, pero para un ejemplo pequeño va bien.

En el próximo episodio (ahora es tarde y tengo sueño), veremos otros osciladores típicos y cosas interesantes que se pueden hacer con ellos.

EDIT: herotyc me ha enviado una versión stand-alone del ejemplo de este capítulo. ¡Muchas gracias! :)

Por petición popular (hola pplux) voy a hacer una pequeña introducción a la síntesis de audio desde el punto de vista de un coder sin experiencia previa en DSP que pretende hacer un sintetizador para intros de 4k (yo). Por supuesto, incluirá ejemplos de código. C99 y SDL for teh win.

0) Disclaimer
Esto no tiene por qué ser la forma correcta de hacer las cosas. Hasta donde yo sé funciona, pero seguro que hay muchos fallos en muchos sitios. Son bienvenidos los comentarios, tanto para corregirme los fallos como para comentar cualquier otra cosa al respecto :). Y como se suele decir en estos casos, si alguno de los ejemplos de código rompe algo o deja sordo a alguien yo no me hago responsable.

1) Haciendo ruido

En primer lugar, el clásico trozo de codigo de inicialización que todo el mundo copia y pega y nadie lee:

#include "SDL.h"

#define BUFFER_SIZE 1024    // Longitud del buffer, en samples

// Este comentario esta extraido de SDL_audio.h, porque me ha molado
/* This function is called when the audio device needs more data.
 * 'stream' is a pointer to the audio data buffer
 * 'len' is the length of that buffer in bytes.
 * Once the callback returns, the buffer will no longer be valid.
 * Stereo samples are stored in a LRLRLR ordering.
 */
void play(void *userdata, Uint8 *stream, int len)
{
    int num_samples = len / 2;
    Sint16 *buf = (Sint16*) stream;
    for (int i = 0; i<num_samples ; ++i)
        buf[i] = rand()%65535-32768;

}

int main(int argc, char **argv)
{
    SDL_AudioSpec desired;
    desired.freq     = 44100;        // Frecuencia de muestreo
    desired.format   = AUDIO_S16SYS; // Formato de las muestras
    desired.channels = 1;            // Numero de canales
    desired.samples  = BUFFER_SIZE;  // Tamaño del buffer en samples
                                     // (potencia de 2)
    desired.callback = play;         // Callback
    desired.userdata = NULL;         // Puntero a datos

    SDL_Init(SDL_INIT_AUDIO);
    SDL_OpenAudio(&desired, NULL);
    SDL_PauseAudio(0);
    getchar();
    SDL_PauseAudio(1);
    SDL_CloseAudio();
    SDL_Quit();
}

La parte importante esta en buf[i] = rand()%65535-32768; Como hemos elegido AUDIO_S16SYS significa que utilizamos muestras de 16 bits con signo [-32768, 32767], con endianismo dependiente del sistema (como accedemos al buffer con punteros a entero de 16 bits, el endianismo no será problema). Generamos numeros aleatorios en ese rango y ya tenemos ruido blanco saliendo de nuestros altavoces.

No se pierdan el proximo episodio.

EDIT: He cambiado el titulo, de “sintesis de audio” a “sintesis musical” porque lo primero era demasiado general :)

Una de las cosas más interesantes que conozco es oir a un hacker contar batallitas. Esta noche, entre uvas, comida y demás jolgorio, Gus me ha comentado que habia estado viendo un vídeo en el que un tal tmbinc contaba como saltarse las protecciones de la Wii, con momentos de grandes risas durante la explicación.

Dicho vídeo procede de una charla más larga, llamada “Console Hacking 2006” (ogm, 140Mb), que a su vez formaba parte del 23C3 (23ª edición del Chaos Communication Congress, organizado por el célebre Chaos Computer Club), que ha tenido lugar del 27 al 30 de diciembre. Pues bien, todo el congreso ha sido emitido por streaming de video y las grabaciones de las ponencias se pueden descargar desde los mirrors. Esto supone horas y horas de charla interesante sobre temas como seguridad informática, lingüística, sociedad, videojuegos, software libre, comunicaciones, hardware…

Por cierto, me molaria MUCHO, pero MUCHO MUCHO, asistir al proximo CCC. ¿Alguien se anima?

En otro orden de cosas, llevo un par de dias leyendo sobre las number stations, estaciones de radio (no comerciales) de onda corta que emiten mensajes cifrados, en forma de ristras de números leídos por voces monótonas e incansables, supuestamente controladas por los gobiernos de algunos países para enviar información a sus espías.

The Conet Project es una recopilación de grabaciones de diferentes estaciones de números. Algunos radioaficionados se dedican a hacer seguimientos a estas estaciones, les ponen nombre basándose en lo que suena en esas frecuencias antes o después de las retahílas de números (por ejemplo, existe una conocida como “Magnetic Fields” porque utilizan el tema de Jarre con ese nombre como preludio), y controlan los horarios y frecuencias de emisión. Mi buen amigo stage7, tras una conversación con él sobre el tema, consiguió grabar un fragmento de la emision de la estación conocida como “Lincolnshire Poacher“, supuestamente controlada por el MI5 británico y que emite desde Chipre. Resulta curioso que en pleno siglo 21 siga siendo efectivo un método de envio de mensajes tan rústico.
Todo esto da un poco de miedo ¿no? :)

¡Feliz año nuevo!

P.D.: ¿He dicho ya que me gustaría mucho asistir al próximo CCC? :D

Advertencia: Post para coders. Puede producir dolor de cabeza. También puede contener información horriblemente equivocada, en cuyo caso se ruegan correcciones en los comentarios.
Hoy me he pasado un buen rato preguntandome por qué no funcionaba esto (recemos para que el WordPress no me destroce demasiado el codigo :P) :

#include <cstdio>
int main()
{
    int i; float f=1.0f;
    i = *reinterpret_cast<float*>(&f);
    printf("i = 0x%0x\n", i);
    return 0;
}

Compilando sin optimización funcionaba como se esperaba, y con optimización daba un resultado distinto. Al principio pensé “un error del gcc, seguro”, pero me he puesto a buscar y resulta que no es un bug, sino una feature. ISO C tiene reglas en contra del aliasing de punteros que dicen que acceder a una variable mediante un puntero de un tipo incompatible es ilegal, asi que al activar las optimizaciones asume que esas cosas no pasan y genera un resultado incorrecto. Una solucion típica es el clasico hack en el que se define una union de un int y un float, se escribe en un miembro y se lee en el otro, pero creo que el estandar dice que en este caso el resultado está definido por la implementación. Mala cosa. Tambien he leido por ahi que una buena opcion es usar memcpy, hacer una copia de lo que sea a otra posicion de memoria y te olvidas del aliasing.

Mas cositas. Programando en la uni el otro dia pensamos en lo bonito que seria disponer de tipos de tamaño fijo, como los uint8, int32, que todos hemos usado alguna vez. Pues bien, en C existen y en C++ no. Ahora alguien se puede preguntar “¿pero cómo? si C es un subconjunto de C++!”, pero esto no solo no es cierto, sino que desde la aparición de C99 hay incluso más diferencias (el estandar de C++ es del 98). En este caso, C99 especifica una cabecera stdint.h que define tipos con nombres como int8_t.

Por ultimo, una curiosidad del FAQ de C++: esta permitido hacer un cast de “Blah *” a “const Blah *”, pero no un cast de “Blah **” a “const Blah **”.

Y eso es todo por hoy. Si teneis alguna historia similar que contar son bienvenidos los comentarios.

Este último fin de semana he estado en la BCNParty.

El jueves por la noche llegué con stage7 a Barcelona, donde shash nos recogió y nos llevó a su casa. stage7 había terminado durante el viaje su tema para la compo de streamed music, una versión de mi track jarresco para la syltia(coop 4k Bauknecht/Necrostudios) que me encanta como ha quedado :D. Como llovía nos quedamos en casa de shash haciendo cosillas de la intro y viendo grandes éxitos en YouTube.

El viernes nos levantamos tarde y llegamos a la party sobre las 16:00. Sesión de partycoding, partycomposing-con-el-vim, y por la noche descanso para degustar la super sangria of the death que yomizmo preparó. Fueron unas horas geniales en las que los miembros de TimeScratchers nos deleitaron con un montón de chistes, mientras otros traducian los chistes al inglés (como razonable éxito ;) para que los sceners extranjeros pudieran entender algo.

El sábado era el dia clave para terminar la intro, es decir, el último :D. Terminé el track como buenamente pude, a pesar de la completa falta de inspiración, y nos pusimos a sincronizarlo todo. No tuvimos demasiados problemas para conseguir el tamaño correcto, aunque hubo un momento de pánico cuando casi me cargo el sinte intentando sustituir la rutina de los ADSRs por un decay exponencial que iba mas o menos bien en mi maquina (40% de consumo aproximado de CPU, eso si :P) pero hacia sufrir demasiado al PC cuando lo pasé a windows. Todavía seguimos buscando el porqué. Resultado final: Red trip by Collapse and Necrostudios.
Entregamos la intro 15 minutos antes de las proyecciones, nos hicimos unos pintxos en el bar de enfrente del partyplace *muy* rápido y despues de ver las compos nos fuimos de fiesta toda la noche. Llegamos justo a tiempo para desayunar en la estación y despedir a stage7, que se iba a las 8:00. Después a dormir un rato, lo justo para llegar a la entrega de premios.

Al final quedamos segundos. Personalmente estoy bastante contento con la intro teniendo en cuenta la carencia de ideas en los dias previos. Ha quedado algo bastante potable y bien terminado. El nivel de las compos en general fue un poco menor de lo esperado, pero al menos ganó una demo española y escena.org vuelve a estar online ;)
En resumen, la party ha estado muy bien a pesar de la falta de prods (lástima) y me lo he pasado genial. Gracias a todos!

Estoy en Portalegre (Portugal) con PpluX pasando unos dias en la Inercia. Ayer pasamos todo el dia en las conferencias del Games2006, un congreso sobre videojuegos en el que está enmarcada este año la party. Muchas gracias a la organización de la party por invitarme :D

Ahora mismo estamos en el partyplace, y me dispongo a empezar una 4k. Supongo que haré un refrito de algo, voy a dedicar un par de horitas a experimentar a ver si encuentro algo chulo con lo que llenar la intro.

Si tengo tiempo y ganas seguiré contando cosas de la party en posts sucesivos.

Llevo toda la noche toqueteando el VSTi de ejemplo del SDK de Steinberg. La idea es empezar un nuevo sinte para intros de 64k que sea usable (y dejar congelado por el momento el de 4k, a falta de que un dia le haga una GUI). La documentación no es ninguna maravilla pero los fuentes de ejemplo están bastante bien.

El viaje comienza heredando de la clase AudioEffectX. Hay todo un mogollón de funciones virtuales que debo implementar para gestionar el paso de los parámetros desde el host y esas cosas. Todos los parámetros son floats en el intervalo [0.0, 1.0], y todos los datos de audio son floats (o doubles opcionalmente) en el intervalo [-1.0, 1.0].

De momento tampoco hay mucho más. Ah si, también he estado mirando cosas del menú de configuración del WordPress que acabo de instalar para poder escribir todo esto ;)