El Oggro

Programming Electronic Music in Pd

2009-03-18T12:01:00.002Z

Tutorial designed for self-study, principally for composers. It begins with explanations of basic programming and acoustic principles then gradually builds up to the most advanced electronic music processing techniques. The book’s teaching approach is focused primarily on hearing, which we consider a faster and more enjoyable way to absorb new concepts than through abstract formulas.

Por ahora sólo en inglés puedes leerlo online aquí.

LinuxAV

2008-11-02T18:19:00.006Z

Desde linuxAV, enlazo a tres entradas interesantes para el videoaudiolinuxeo y otros vicios:

Linux en punto

2008-09-19T20:06:00.004+01:00

Aprovechando el tener un reloj con memoria USB, me he animado a probar distros de linux. Su capacidad de 120Mb no da para mucho, aunque suficiente para la versión usb de Gparted

http://gparted.sourceforge.net/liveusb.php

Siguiendo las instrucciones dictadas en dicha página, he podido instalar esa minidistro en el reloj. El único paso delicado como bien indica la guía, es

cat /usr/lib/syslinux/mbr.bin > /dev/sdb

en el que se hace un volcado directo sobre una unidad montada (en mi caso fue sda). Ya sabes: there is no warranty for this free software. Como paso previo a dicha instalación, formateé la unidad (el reloj) a FAT32 y marqué la etiqueta de arranque (boot).

Mañana que me toca instalar gnu/linux en un equipo intentaré particionar el disco a la hora del té. A ver si la persona interesada capta la indirecta.

Pure:dyne miso

2008-06-15T22:01:00.006+01:00

Pure:dyne, distribución de GNU/Linux creada para artistas multimedia, publica nueva versión. En realidad es más que un cambio de versión, ya que se podría decir que es un nuevo pure:dyne. A partir de ahora se basará en debian, aunque sigue siendo un cd-live sin opción a instalación.

La nueva página del proyecto se encuentra aquí.

Edición 26 jul: Creada la página que explica cómo tunear una debian lenny instalada para convertirla en pure:dyne

Noticias de vuelta, processing y lily

2008-05-21T23:40:00.005+01:00

Hola de nuevo. Vuelvo para no volver...

Varias web en relación a noticias más o menos recientes.

Processing sin Java pero...

Para quien no lo conozca, processing es un lenguaje y un entorno de código abierto para programar gráficos interactivos. Está diseñado por y para artistas multimedia. Para más información visita:

http://processing.org/

Un vídeo vale más que una imágen:

learn2code - lesson 1 - getting started from Dan Chudnov on Vimeo.

http://onebiglibrary.net/learn2code/lesson-01-getting-started

Processing goza de buena salud. Si quisieras usarlo debes tener instalada la java-run-time en tu máquina, paquete sun-java6-jre en tu distro favorita.

Pues la noticia tiene que ver con esto justamente. John Resig, ha portado el grueso de rutinas java, a javascript, por lo que sería posible escribir y "hablar" processing desde el navegador (recomendado forzoso, Firefox 3). En su web:

http://ejohn.org/blog/processingjs/

encontrarás un montón de ejemplos. Javascript is for artist

También hay una buena introducción a processing, en esta web:

http://go.yuri.at/p5/tutorial/

Lily

Entre las jugosas posibilidades que trae Firefox 3, una sugerente es que hace posible correr este añadido, el cual implemente un lenguaje visual con cajitas, digamos modo-pd ( http://www.lilyapp.org/httpd.mov ), que permite crear aplicaciones complejas en el navegador. Entre las funcionalidades de dicho engendro, está la de usar el protocolo OSC para conectarse a programas que lo soporte, como pd.

Veamos un ejemplo, en el que unas pelotitas mandan su posición vía OSC al programa chuck que se encarga de darle sonido

SVG to OSC from Bill Orcutt on Vimeo.

En la página de lily hay unos cuantos ejemplos. La verdadera utilidad de lily, está en tu mente. Apaga este cacharro y lily no sirve para nada

Página del proyecto: http://blog.lilyapp.org/lily/demo/

Como curiosidad, lily interpretando la estructura de un archivo xml como gráficos.

Reconstruyendo Documentación sobre PureData

2008-01-31T14:22:00.000Z

Después del palo de lynksee estoy recreando la wiki de documentación sobre pure data en castellano en wikia:

http://es.puredata.wikia.com/

PureDataVideopedia

2007-12-14T11:37:00.001Z

Alguien ha tenido la idea de crear un canal sobre PureData en youtube, para recopilar clasificados los vídeos que hemos ido subiendo. Pasado mi tiempo de gran silencio, espero ir aportando más videos.

http://www.youtube.com/profile_play_list?user=PureDataVideopedia

La ventaja es la gran difusión que tiene youtube, pero como inconveniente está la mala calidad de vídeo que ofrece este portal...

Habemus PDT (Pure Data TV)

nota: no confundir con PDT: Pure Data para Teletubbies (ahora en peligro de extinción)
nota a la nota: PDT es un grito de guerra, intraducible a la mayor parte de otros idiomas, que viene a ser como a un imperativo a liberarse ;)

Problema serio

2007-11-21T16:21:00.000Z

A diferencia de la pdpedia.org que está a buen recaudo, los textos que salieron de este blog y luego se ampliaron formando la wiki de documentación en castellano de puredata corre un serio peligro. He recibido un correo de lynksee, diciendo que cierran el lugar por problemas de money. Estoy a la espera de respuesta sobre si podría tener copia de al menos, la base de datos de la wiki...y así evitar la copia apresurada y, a mano.

lo gratis a veces se paga caro...

Se admiten sugerencias

EDITADO: podría llevar la wiki a otra parte. Me siento netapátrida

kdenlive

2007-11-02T20:46:00.000Z

kdenlive es un editor no linear para vídeo muy sencillo,

Para instalarlo sigue las instrucciones en su wiki:
http://en.wikibooks.org/wiki/Kdenlive/Getting_and_installing

un ejemplo de la sencillez de uso (comparado con Cinelerra) lo verás aquí:

http://kdenlive.org/tutorials/videos/transitions.ogg

http://kdenlive.org/tutorials/videos/markers.ogg

Pdpedia en castellano da sus primeros pasos

2007-10-02T20:01:00.000+01:00

La pdpedia ( http://wiki.puredata.info/ ) ya tiene sección en castellano, así como en otros idiomas. Necesitamos colaboradores para ir documentando los cientos de clases/objetos que constituye el entorno pd. Si estás interesad@ avisa, o bien contacta con la lista de usuarios.

Por ahora se tomará de referencia la versión en inglés, por lo que la labor será principalmente de traducción.

La página de la sección en castellano es: http://wiki.puredata.info/es/Portada

Por otra parte, nuestra wiki, se limitará ahora a proyectos de traducción (si es que alguien se anima :) ) así como recopilar tutoriales, manuales, y en general domumentación en castellano sobre pd.

[polywavesynth]

2007-09-17T09:37:00.000+01:00

Together, these two objects make up a ready-to-use, CPU-cycle-stingy, OSC-addressable polyphonic "wave" synthesizer -- the tag "wave" is used for want of a better (short) descriptor for the somewhat unusual mix of synth technologies employed, which is table-driven subtractive synthesis with a dash of FM.

http://www.pkstonemusic.com/polyWaveSynth.html

Pdpedia

2007-09-12T10:24:00.000+01:00

Se esta comenzando con el proyecto pdpedia, un intento de unificar la documentación del incontable grupo de clases, externals y abstracciones que hay ya para pd.

http://pdpedia.at.or.at/test/index.php/Main_Page

Esperemos que siga adelante.

Pd: tutorial tablas de datos

2007-08-22T12:55:00.000+01:00

Se ha añadido a la wiki un tutorial de tablas de datos. Aun está en construcción:
http://puredata.lynksee.com/wiki/Documentaci%C3%B3n_sobre_Pure_Data

Como siempre, cualquier colaboración es bien recibida.

Soundsnap

2007-07-05T12:42:00.000+01:00

banco social de sonidos
http://www.soundsnap.com/

Probando reacTIVision en Ubuntu

2007-07-03T18:35:00.000+01:00

Para quien no lo conozca reacTIVisión es un software de visión artificial, que permite mediante unas figuras llamadas amebas (gráficos fiduciales) , captándolas con una cámara, controlar otros softwares vía OSC.

http://mtg.upf.edu/reactable/?software

Es el corazón del funcionamiento del famoso instrumento Reactable, desarrollado en la Pompeu Fabra. El autor se merece un premio!

La prueba realizada se ha hecho con una webcam conceptronic [30 fps (352x288) / 15 fps (640x480)], y ubuntu feisty. Reactivisión se comunicará con Puredata.

Preparación:

-Tener instalada la webcam y funcionando ;)
- Tener Pure Data instalado y funcionando
- La tabla de amebas con divertidos recortables

Bajamos el deb para ubuntu desde la web:

http://mtg.upf.edu/reactable/?software

Usamos la manera convencional de instalación.

a) En ubuntu haciendo doble-click sobre el paquete.
b) escribiendo en un terminal: sudo dpkg -i nombredelpaquete.deb

Bajamos el external para puredata desde la misma web:

http://prdownloads.sourceforge.net/reactivision/TUIO_PureData-1.3.zip?download

Descomprimimos (unzip nombredelarchivo.zip) , y dentro hay un archivo llamado source.zip. Lo descomprimimos, entramos en la carpeta source reciencreada, y make.

Se creará el archivo TuioCliente.pd_linux. Lo copiamos a la carpeta pd/extra. NOTA: esto depende si tienes pd desde los repositorios, entonces la carpeta será /usr/lib/pd/extra, o bien pd-extended, en tal caso deberá ser a /usr/local/lib/pd/extra.

Amebas

Baja el archivo pdf de amebas o figuras fiduciales, e imprime alguna hoja.

http://mtg.upf.edu/reactable/pdfs/fiducials.pdf

Ejecución

Desde un terminal lanzas reacTIVision y comenzará a capturar lo que aparezcan en la webcam. En la carpeta TUIO_puredata que bajamos y descomprimimos previamente, hay un ejemplo sencillo de uso:

reacTIVision se conecta con puredata via OSC, el protocolo TUIO son un conjunto de reglas de interpretación de los mensajes. El objeto [TuioClient] hace el trabajo sucio, generando mensajes como qué ameba se activa (en el pdf observa que cada una tiene un número), en qué posición de la pantalla está, y con qué ángulo. Como se puede ver en la figura anterior, se escalan los valores ancho y alto a 640x480, y se transforma el valor del ángulo a grados.

Recortando alguna ameba, puedes probar en la consola de pd, que se dectecta la presencia de cada una de ellas, y también cuando sale del campo de visión.

Para hacer una prueba rápida, conociendo un poco la dinámica de pd, es fácil asociar la variable de giro a la frecuencia de un oscilador sinusoidal. Mientras que el mensaje de presencia o ausencia, encenderá o apagará dicho oscilador. Para ello podemos tomar el ejemplo ya hecho y añadirle un par de cosas.

Al aparecer una ameba, el anterior patch no distingue de cuál se trata, si aparece una cualquiera se envía el mensaje 1 a "activo", si desaparece se envía 0. Ese valor encenderá o apagará la señal con [r activo]. El valor de grado es interpretado como frecuencia del oscilador. Es un test muy simple

(añadido y ampliado en: Documentación sobre Pure Data )

Pure Data para Teletubbies

2007-06-19T22:45:00.000+01:00

PDT (o Pure data para Teletubbies) es un tutorial pensado como toma de contacto con PD.

Sucesivamente iremos añadiendo más documentación, que podrás consultar aquí.

pure:dyne instalación docking

2007-06-17T23:21:00.001+01:00

(INFORMACIÓN DESACTUALIZADA. La nueva puredyne tiene diferentes modos de instalación--> http://code.goto10.org/projects/puredyne/wiki/PureInstall )

Instrucciones para instalar fácilmente pure:dyne en un partición linux que tengas. En mi caso la instalaré en la partición hda1 donde tengo debian etch.

Bajamos la versión de pure:dyne que prefieras de

http://puredyne.re-draw.org/

He probado con la testing, hoy a 17 de junio de 2007. Bajamos la imagen iso.

Creamos un directorio temporal para montar la imagen

mkdir /tmp/dyneiso

y montamos la imagen

mount -o loop /donde/esté/puredyne.iso /tmp/dyneiso

Copiamos la carpeta /dyne de la imagen de cd al directorio raiz de nuestra partición.

cp -rv /tmp/dyneiso/dyne /

Lo único que hay que hacer ahora es que grub sepa arrancar desde ahí, en la carpeta /dyne. editamos el menu de arranque de grub

su
gedit /boot/grub/menu.lst

En el lugar adecuado añadimos el nuevo arranque

title Pure:dyne!
root (hd0,0)
kernel /dyne/linux root=/dev/ram0 rw load_ramdisk=1 max_loop=128 vga=788 splash=verbose
initrd /dyne/initrd.gz

(son 4 lineas, title, root, kernel e initrd)

Sobre (hd0,0) debe apuntar a la partición donde copiaste el directorio dyne. (hd0,0) es hda1, (hd0,1) es hda2, ...

Ahora sólo habría que arrancar y seleccionar Pure:dyne!

En el escritorio te saldrá una ventana de configuración. Si vas a la pestaña 'Getting started' y luego el botón 'Config and nest' verás un panel de control. Importante para configurar idioma de mapa de teclado, tarjeta de sonido etc.

MODULOS

pure:dyne tiene un sistema especial de paquetes o módulos. En la dirección que dí más arriba puedes ver una carpeta llamada modules. Los módulos están instalados en la donde copiaste /dyne subdirectorio /modules. Puedes bajar desde la web los módulos que quieras y añadirlos a ese directorio. Al arrancar p:d lo tendrás instalado.

Por ejemplo, bajando los módulos csound.dyne y processing.dyne y colocándolos en esa carpeta, tendrás los dos programas instalados en el siguiente reinicio.

PureData-ES traducción de textos

2007-06-14T09:07:00.000+01:00

Desde puredata-es estamos llevando a cabo la traducción de algunos textos, por ahora introductorios a Pure Data. Se usa una wiki:

http://puredata.lynksee.com/wiki/Main_Page

Si estás interesad@ en colaborar, deja una mensaje aquí, o en el foro.

python--pd via OSC

2007-06-11T18:08:00.000+01:00

Para conectar pd con el lenguaje python vía OSC usaremos la librería

http://www.ixi-software.net/content/download/simpleosc0.2.zip

puedes hacer desde un terminal

wget http://www.ixi-software.net/content/download/simpleosc0.2.zip
unzip simpleosc0.2.zip
cd simpleosc

Ahí encontrarás un patch ejemplo, así como un ejemplo en lenguaje python.

Puedes copiar la librería (la carpeta osc) a:
/usr/local/lib/python(versión-que-tengas)/site-packages/

Enviar mensajes a pd desde python

En el intérprete escribe:

import osc
osc.init()

El envío de mensajes es algo así:

osc.sendMsg("/hola",[1,2,'jojo',45],"localhost",9000)

si tienes activo el patch ejemplo de pd, verás como imprime: /hola 1 2 jojo 45

Si quieres enviar un paquete o fajo (bundle) de mensajes, creamos uno:

mipaquete = osc.createBundle()

y ahora podemos ir añadiendo mensajes a mipaquete

osc.appendToBundle(mipaquete, "/test", [1, 2, 3])
osc.appendToBundle(mipaquete, "/test", [4, 5, 6])

cuando tengas el fajo lleno puedes enviarlo de un golpe con

osc.sendBundle(mipaquete,"localhost",9000)

Recibir mensajes desde pd

(en construcción)

csound <--> pd vía OSC

2007-06-07T22:53:00.000+01:00

Vamos a ver cómo conectar csound y pure data vía osc

1) Enviar datos desde csound a pd

Podemos construir un sencillo patch de ejemplo como este:

usa los objetos del external oscx. En csound, suponiendo que funciona bien sólo necesitas un archivo csd como este:

<CsoundSynthesizer>
;<CsOptions>
;</CsOptions>
; ==============================================
<CsInstruments>

sr = 44100
kr = 44100
ksmps = 1
;nchnls = 2

instr 1
OSCsend 1, "localhost",9999, "/foo", "ff", p4,p5
endin

</CsInstruments>
; ==============================================
<CsScore>
f0 300
i1 2 -1 60 100
i1 + -1 67 100
i1 + -1 63 40
e

</CsScore>
</CsoundSynthesizer>

La clave es la línea:

OSCsend 1, "localhost",9999, "/foo", "ff", p4,p5

que lleva estos parámetros de entrada

1 --- el mensaje se enviará cada vez que se active el instrumento
"localhost" --- la dirección es la red local, podría ser otra
9999 --- puerto que se usará
"/foo" --- punto de acceso
"ff" --- en este caso se enviarán 2 datos float (*)
p4 y p5 --- datos enviados, en este caso leídos de la partitura

(*) El tipo de mensajes se indican con una cadena cuyos caracteres son algunos de entre "bcdfilmst", que son las iniciales de: Boolean, character, double, float, 32-bit integer, 64-bit integer, MIDI, string y timestamp. Por ejemplo "sif" significa que se enviarán una cadena, un entero y un número float.

Ejecutando este csd veremos cómo puredata imprime los valores que hemos almacenado en la partitura de csound

2) Recibir datos en csound desde pd

Este caso es un poco más complicado, porque requiere más conocimientos sobre el lenguaje. Un sencillo patch que envía datos podría ser este

Usa la dirección localhost:9999/frec donde enviaremos valores de frecuencia. "/frec" es arbitrario, puedes elegir el nombre que quieras.

El código de csound que recibe datos podría ser algo como este:

<CsoundSynthesizer>
;<CsOptions>
;</CsOptions>
; ==============================================
<CsInstruments>

sr = 44100
;kr = 44100
ksmps = 100
nchnls = 1

gihandle OSCinit 9999

turnon 100

instr 100
kf1 init 0

nxtmsg:
kk OSClisten gihandle, "/frec", "f", kf1
if (kk == 0) goto ex

event "i",1,0,-1,kf1

printk 0,kf1
kgoto nxtmsg
ex:

endin

instr 1

k2 linseg 1,1,0
a1 oscil 8000*k2,p4,1
out a1
endin

</CsInstruments>
; ==============================================
<CsScore>
f1 0 1024 10 1
f0 360

</CsScore>
</CsoundSynthesizer>

Hay dos instrumentos, el que lee y el que toca, ya que he añadido un instrumento (1) que interpreta el valor que recibe por /frec como una frecuencia de un oscilador.

La línea clave es:
kk OSClisten gihandle, "/frec", "f", kf1

kk es cero excepto cuando se recibe un mensaje, por lo cual se ejecuta el código que está despues de if, que es justamente:

event "i",1,0,-1,kf1

Línea que genera un evento de partitura, que lanza el instrumento 1

El efecto será que tocaremos en pd y oiremos csound, no es más que eso :)

Pd: OSC con oscx

2007-06-07T22:08:00.000+01:00

Para usar el protocolo OSC, se usará el external oscx que viene con puredata extended. Usar OSC en pd es muy sencillo. Igual que hacíamos con el streaming vía icecast, la base para entender qué ocurre al enviar y recibir datos vía OSC, es saber de donde y a donde enviamos. Generalmente abriremos una dirección en la red, vista por nosotros por la expresión

maquina:puerto/puntodemontaje

por ejemplo

mimaquina.org:1000/aua

Representa la dirección de la máquina mimaquina.org puerto 1000 y dirección de montaje - o puedes verlo como una carpeta- aua. Usando el protocolo OSC es posible enviar simultaneamente datos a distintos puntos /aua1 /otra /yotra. Veremos cómo. Podría haber una máquina remota a la que le enviamos datos, a un determinado puerto.

En el siguiente patch se usa el objeto [sendOSC], el cual recibe el mensaje "connect localhost 9999". Lo que hace es conectarse al puerto 9999 de la redlocal, para que otros programas lean en ese mismo puerto, los datos que enviemos. "disconnect" es lo que parece.

La forma de los mensajes siempre es "send" seguido del punto al que enviaremos datos. Siempre se escribe "/" seguido de un nombre. "/aua aaa 8 3" enviará los mensajes aaa 8 y 3. Atención a que pueden enviarse de una vez mensajes a varios puntos con el tercer mensaje que aparece.

Para verlo funcionar, un caso trivial es que pd envie, y en nuestra propia máquina pd escucha. Abre entonces otro patch (control+n) y crea

[dumpOSC 9999] escucha o lee lo que pase en el puerto indicado y lo envía por su salida. Si pulsamos sucesivamente los tres mensajes "send" del patch anterior, veremos en la consola de pd escrito:

print: /aua aaa 8 3
print: /frec 880
print: /aua 5
print: /frec 256

Es así de simple, lo cual da una idea de que viene a ser un MIDI extendido adaptado al lenguaje de redes, y sobre todo más flexible permitiendo conectar de muchas maneras máquinas localmente o remotamente, y enviar datos
en la estructura que decidamos.

Exite un objeto del mismo external llamado [OSCroute] que es justamente similar a route pero para mensajes OSC. Si transformas el segundo patch creado por este, lo verás en funcionamiento

KeyJnote. Presentaciones en PDF mejoradas

2007-06-07T13:03:00.000+01:00

Instrucciones castellano
http://ronroneos.com/keyjnote.html

latex en castellano

2007-06-04T18:13:00.000+01:00

El siguiente texto está tomado de este enlace

Me he instalado Ubuntu en el portátil y, al ir a compilar un documento nuevo en LaTeX, me he encontrado con que cascaba nada más encontrarse con el primer acento o eñe. El motivo es que Ubuntu usa por defecto la codificación UTF-8 en el sistema y en todas las aplicaciones que lo soportan, incluido Vim, que es el editor que uso, por tanto hay que decirle a LaTeX que nuestros nuevos documentos están ahora codificados en UTF-8, y no en latin1 (con los viejos documentos que tuviésemos ya hechos en latin1 no hay problema alguno, no hay que hacer nada). ¿Cómo lo hacemos? Es sencillo, solo se requieren dos pasos:

1. Instalamos los paquetes debian latex-ucs y latex-ucs-uninames.
2. Con esto ya tenemos instalado el paquete ucs.sty, que nos da el soporte para Unicode en LaTeX.

Ahora ya solo nos queda declarar su uso en la cabecera de nuestros nuevos documentos LaTeX. Así:

3. \usepackage{ucs}
\usepackage[utf8]{inputenc}

Incluso, según la documentación, puede suprimirse la primera línea en muchos casos.

Por supuesto, estas líneas sustituyen a:

\usepackage[latin1]{inputenc}

Podemos seguir usando sin problema el paquete "babel" de nuestra lengua si queremos disponer de soporte para nuestra lengua distinta del inglés:

\usepackage[spanish]{babel}

Espero que le sea útil a alguien, a mí me ha llevado un buen rato darme cuenta de lo que estaba pasando. ;-)

Pd: until

2007-05-31T17:42:00.000+01:00

until (hasta) representa el bucle de puredata. Genera tantos bang como le digas, en secuencia. En el siguiente patch:

si pulsas sobre el mensaje 10, se imprimirán 10 bangs, igual con otro número. Es fácil de entender si lo pruebas. Este aparente inofensivo objeto es un arma de doble filo. Imagina que realizas el siguiente patch

Nada impide al until detenerse por lo que probablemente tendrás que matar el programa pd, o incluso reiniciar el ordenador, que se bloqueará. El segundo inlet de ultil puede recibir un bang que lo detiene, pero si ya has iniciado el patch anterior, es demasiado tarde...

Un ejemplo menos agresivo con until es hacer un contador como el siguiente:

El bang activa un trigger que dispara dos bang, primero el de la derecha y luego el de la izquierda. El de la derecha pondrá a 0 el contador de más abajo, mientras que el de la izquierda envia 20 a until, por lo que generará 20 bangs. El resultado es que el contador cuenta de 0 a 19. En este caso no hay que tener miedo de until porque recibe un número de exacto de bangs. El problema ocurre cuando un [until] perdido de la mano de dios, no recibe orden de detenerse.

Una aplicación directa del patch anterior, es escribir de un golpe todos los valores en una tabla.

Casi todo es como el caso anterior, sólo que esta vez hay una tabla de datos con 10 datos. En concreto he configurado la tabla con x de 0 a 9, e y de 0 a 100. Cada valor del contador, se pasa por un trigger que genera el valor, y luego un bang. El valor selecciona en [tabwrite array1] que posición de la tabla queremos escribir, y el bang activa [random 100] generando un número aleatorio entre 0 y 99. El resultado es que rellena la tabla con números aleatorios cada vez que pulsas en bang superior.

El mensaje ;array1 const 0 pone todos los valores de la tabla a 0.

Un último ejemplo de cómo usar util para dibujar funciones en una tabla. Ya que until emite tantos bangs como queramos, puede hacerse que cada bang calcule un punto de una función y lo dibuje en la tabla (dicha tabla tiene 199 puntos, con el valor y entre 0 y 1):

Libro Miller Puckette

2007-05-30T08:55:00.000+01:00

The theory and Technique of Electronic Music

Conversiones Audio/Video <---> Audio/Video

2007-05-23T12:12:00.000+01:00

Conversión de audio

Conversión de vídeo

Play ogg

2007-05-23T09:52:00.000+01:00

Campaña de la FSF para alentar al uso del formato contenedor de audio/video ogg.

http://www.fsf.org/resources/formats/playogg

Pd: Samplers (paso 6.8)

2007-05-20T19:00:00.000+01:00

La estructura de un sampler es simplemente un sonido digital almacenado en la memoria, y algún mecanismo que lea esa secuencia de datos (muestras) desde un punto a otro, a distintas velocidades.

EJEMPLO DE UN SAMPLER SENCILLO CON tabplay~

Para empezar una fórmula sencilla. Sabiendo la frecuencia de muestro de un sonido digital (el número de muestras guardadas por segundo), y lo que dura exactamente, puedes saber cuántas muestras o bytes de usará en memoria. La fórmula es Muestras=FrecmuestreoxDuración. En el patch anterior, sabía de antemano la duración exacta del sonido en segundos, y por supuesto la frecuencia de muestreo, por tanto es fácil conocer el número de muestras. Ese número lo usé para crear un array.

Por otro lado, el objeto [soundfiler] es capar de cargar en una tabla un sonido almacenado en un archivo. El mensaje 'read' hace eso precisamente. [soundfiler] devuelve el número de muestras leidas.

[tabplay~] cuando recibe un bang, lee lo almacenado en una matriz que le digamos. En este caso 'drum'. Por tanto, el bang dispara el sonido almacenado en la tabla.

Añadiendo lo siguiente al patch:

Se puede leer una y otra vez el contenido de la tabla. El truco está en que [tabplay~] envía un bang por la salida de la derecha cuando termina. Este bang podríamos reenviarlo a la entrada de nuevo, haciendo un bucle. He interpuesto [spigot] simplemente para que el bucle pueda detenerse.

SAMPLER USANDO phasor~

Este caso es un poco más elaborado. El fucionamiento de [soundfiler] es similar. Sin embargo la columna de la izquierda requiere pararse más. Vamos por partes:

- [/ 44100] Divide el número de muestras entre la frecuencia de muestreo, que por la fórmula vista más arriba, eso es la duración del sonido.

-[pow -1] eleva un número a -1, o lo que es lo mismo, uno partido por ese número. Si considero que la duración del sonido es el periodo de una onda (lo que se repite), ¿cómo calculo la frecuencia de ese sonido?, justamente haciendo el inverso del periodo. Ejemplo: un sonido que tiene un periodo de 0.5, tendrá de frecuencia 1/0.5=2 Hz.

-[sig~] transforma un número en una señar digital.

-[phasor~] va de 0 a 1 linealmente tantas veces por segundo como indique la precuencia que indiquemos. Por tanto, si multiplicamos la salida de phasor~ por un número n. obtendremos una señal que va de 0 a n, tantas veces por segundo como indique la frecuencia. Eso es justo lo que hemos hecho, multiplicar phasor~ por el número de muestras. phasor~ en este caso es un puntero que leerá la tabla, desde 0 hasta el número de muestras.

-Finalmente [tabread4~] lee la tabla según la señal que entre por su inlet principal. Se podría usar [line~] para indicar qué valores leer.

Prueba a variar la caja de números debajo de pow y escucharás la tabla leída a distintas velocidades. A velocidades negativas, lee alrevés.

Se puede variar ligeramente el patch para que empiece a leer en la muestra que quieras, y termine donde quieras, simplemente escalando phasor~. Tambien se puede añadir el flag -resize a la mensaje read de soundfiler, redimensionando la tabla para que se ajuste a la muestra cargada.

Pd: Ondas famosas con phasor (paso 3.7)

2007-05-15T19:10:00.000+01:00

Phasor genera una función rampa lineal de 0 a 1. Es suficiente con esta señal, para producir las ondas típicas de la síntesis sustractiva clásica. Representada, siendo el eje x el tiempo, podría quedar así:

El siguiente patch , será la base para ver la construcción de las ondas. Dos array de 208 puntos (esto es arbitrario), dos [tabwrite~] cada uno apuntando a su array, y un [phasor~] del que podremos cambiar su frecuencia. También podríamos cambiar la fase con el inlet frio de [phasor~]. Como siempre, pulsa sobre las imágenes para ampliarlas un poco.

En el panel (canvas) verde se transformará phasor~ en otra onda.

ONDA CUADRADA

ONDA RAMPA

ONDA SENOIDAL

ONDA DIENTE DE SIERRA

ONDA TRIANGULAR

TetrisPD

2007-05-04T19:42:00.000+01:00

Mateo Sistisette asombrosamente ha realizado un juego de tetris enteramente con puredata. Lo puede bajar aquí:

http://puredata.org/Members/matteosistisette/tetrispatch

El patch inicial es tetris.pd

GNU/Linux: fuentes ttf

2007-04-26T19:21:00.000+01:00

A continuación detallamos tres formas para instalar tus fuentes en linux:

1ª forma:

La manera mas sencilla de instalar las fuentes, si dispones del navegador Konqueror, es abrirlo y poner la siguiente URL en la línea de dirección:

fonts:/

y copiar directamente las fuentes dentro de la carpeta Personal. De esta manera ya estarán a disposición de los programas que quieran usarlas.

2ª forma:

Sirve para la mayoría de las distribuciones, sólo tienes que copiar las fuentes a /usr/share/fonts.

// Creamos el directorio donde vamos a instalar las fuentes
#mkdir /usr/share/fonts/misfuentes

//Copiamos las fuentes descargadas (y descomprimidas), al directorio que hemos creado anteriormente
#cp mis_primeras_fuentes/* .ttf /usr/share/fonts/misfuentes

//Para actualizar todos los ficheros de caché de fuentes
#fc-cache -f

3ª forma:

Si tienes una versión reciente de RedHat, Suse o Debian, éstas tienen soporte para fuentes TrueType, para comprobarlo abre una ventana de terminal y escribe el comando ttmkfdir. Este comando simplemente debe desplegar el número " 0 ", o sino una larga lista de nombres de fuentes. Si nos dice "comando no encontrado", entonces estas instrucciones que detallamos a continuación no pueden ser usadas, tendras que buscar cómo hacerlo para tu distribución en concreto.

El siguiente paso es que crees un nuevo directorio para tus fuentes, por ejemplo /usr/local/fonts/ttf ( si eliges otro, deberas adaptar las instrucciones). Este directorio debe ser accesible por todos los usuarios. No olvidar que algunas de las instrucciones deben ser realizadas como usuario root.

Copia todas las fuentes truetype(*.ttf) dentro del directorio /usr/local/fonts/ttf (en mi caso).

En una ventana de terminal, escribe lo siguiente:

cd /usr/local/fonts/ttf ttmkfdir > fonts.scale mkfontdir

En el directorio se deberán haber generado dos nuevos archivos ("fonts.scale" y "fonts.dir"), que simplemente contienen una lista con el nombre completo de las fuentes para cada fuente truetype.

Por último, debes agregar el nuevo directorio a la lista de rutas en que XWindows buscará fuentes. Si eres usuario de Red Hat puedes hacerlo con el siguiente comando:

chkfontpath -a /usr/local/fonts/ttf

y si no lo eres, edita directamente el archivo /etc/X11/fs/config (o /etc/X11/xfs/config), busca la linea que empieza con "catalogue", y agrega el directorio de las fuentes al final de la lista, separado por una coma.

fuente

Muchas fuentes "free", aquí: http://www.webpagepublicity.com/free-fonts-c.html#FreeFonts

escoitar.org

2007-04-23T19:01:00.000+01:00

Unha aproximación ao son dun lugar é unha aproximación ao seu patrimonio. Percibir, comprender e concibir a nosa identidade sonora, a dos nosos lugares e as nosas xentes, a súa coherencia e idiosincrasia, é un exercicio necesario e saudable. Escoitar.org é un proxecto de dinamización social aberto e libre cuxo obxectivo principal é a difusión e promoción do fenómeno sonoro e a súa exploración con fins sociais e documentais. Escoitar.org é tamén unha actividade do PROXECTO-EDICIÓN (CGAC, MARCO e Fundación Seoane). Podes participar engadindo as tuas gravacións. Benvido a Escoitar.org.

http://www.escoitar.org/

Pd: Grabar un wav (paso 3.6)

2007-04-20T15:32:00.000+01:00

[dac~] envia la señal digital a la salida que tengas configurada: la tarjeta de sonido, u otro programa vía jack. En algún caso puede ser útil salvar la sesión de pd en un archivo wav, pera eso está el objeto [writesf~]. El siguiente es un ejemplo sencillod de grabador.

"open" abrirá el archivo que quieras y lo dejará listo para grabar. "-wave" indica que se usará el formato wav . El número que acompaña a writesf~ es justo el número de canales. Entonces, no hay más que pulsar start y comienza la grabación.

En el caso de querer grabar archivos con nombres distintos, es muy útil el objeto [makefilename]. En el siguiente patch hay tres ejemplos de uso.

pulsa sobre la imagen para agrandar

A) Al cambiar la caja de números, [makefilename] toma el número como entero (%i) y lo coloca en medio de un nombre, creando un símbolo que envía a la caja de símbolos. Es útil para crear una secuencia de archivos numerados.

B) Podemos elegir entre dos o varios símbolos que serán insertados en un nombre (%s).

C) En este ejemplo, hay un contador que irá generando una secuencia 0,1,2,3,... Ese valor se inserta con [makefilename] en un símbolo que representa una dirección de archivo. 'open -wave $1' lee dicho símbolo, como sabrás $1 significa tomar el primer valor del mensaje de entrada. Por tanto irá abriendo archivo-0.wav, archivo-1.wav, archivo-2.wav, etc

Ea! estupidez artificial

2007-04-15T15:01:00.000+01:00

"Galería" , Escher

Apenas un homenaje al siguiente texto de Borges, que siempre me hizo reir, a la vez que sentía una global vergüenza ajena hacia los grandes hitos de la humanidad. "Ajena" dicho en ese sentido en el que me incluye: "no soy cualquiera, soy un hombre, alto, gordo de espíritu, colchonero, mequetrefe, avaricioso, equizotípico..."

"Esas ambigüedades, redundancias y deficiencias recuerdan a las que el Dr. Franz Kuhn atribuye a cierta enciclopedia china que se titula Emporio celestial de conocimientos benévolos. En sus remotas páginas está escrito que los animales se dividen en:

(a) pertenecientes al Emperador,
(b) embalsamados,
(c) amaestrados,
(d) lechones,
(e) sirenas,
(f) fabulosos,
(g) perros sueltos,
(h) incluídos en esta clasificación,
(i) que se agitan como locos,
(j) innumerables,
(k) dibujados con un pincel finísimo de pelo de camello,
(l) etcétera,
(m) que acaban de romper el jarrón,
(n) que de lejos parecen moscas. "

Jorge Luis Borges, El idioma analítico de John Wilkins, en "Otras inquisiciones", 1925

Pd: polifonía con poly (Paso 2.4)

2007-04-10T19:57:00.000+01:00

[Poly] funciona como una puerta para datos MIDI, que permite un número de notas pulsadas. Dicho de otra manera pone límite en número de voces a la polifonía. Mira el siguiente ejemplo:

Recibe mensajes con los valores (nota volumen) típicos del formato MIDI.

[poly 3] pone a tres el número máximo de notas pulsadas. Si pulsas una tras otras, los mensajes de la izquierda, ocuparás las notas posibles. Al pulsar los de la derecha (al despulsarlas), dejas hueco a que se pulsen nuevas. En la salida de pd, verás algo como esto:

print: 1 60 100
print: 2 67 100
print: 3 70 100
print: 3 70 0
print: 2 67 0
print: 1 60 0

Si cambias el patch añadiendo una nota más, o bien pulsas alguna de las de la izquierda 2 veces, verás que [poly], una vez ocupadas las 3 notas pulsadas, no permite el paso de ninguna más.

Si tienes un teclado MIDI, o controlador externo a pd (con jack y vkeybd por ejemplo), realiza el siguiente montaje:

[poly 4] permitirá que pulses hasta 4 notas simultáneas. Por el primer outlet, obtienes la voz que activas o desactivas, por tanto podrías usar [select] para enviar cada voz a una tarea distinta.

Capturar stream con mplayer

2007-04-09T16:44:00.000+01:00

CAPTURAR AUDIO

Necesitas tener instalado mplayer :)

El comando es:

mplayer urldelaradio-online -dumpstream

Eso creará el archivo stream.dump, si quisieras darle otra nombre, puedes utilizar la opción -dumpfile archivoquequieras.mpg

Lo convertimos a wav, suponiendo que el nombre del archivo creado es stream.dump, con:

mplayer stream.dump -ao pcm:file=archivodesalida.wav

Ya puedes borrar el archivo stream.dump

rm stream.dump

Entonces puedes hacer una conversión a ogg

oggenc -o archivoquequieras.ogg archivodesalida.wav

Ya está ;)

CAPTURAR VIDEO

En este caso usaremos mencoder, el codificador de medios de mplayer. Si conoces la dirección stream de video, por ejemplo esta:

rtsp://streaming.multicasttech.com/AmericaFreeTVComedy.sdp

Puedes capturarla en avi con el comando:

mencoder rtsp://streaming.multicasttech.com/AmericaFreeTVComedy.sdp -o prueba.avi -ovc lavc -lavcopts vcodec=mpeg4:vbitrate=800:keyint=250:vqmin=2 -oac mp3lame -lameopts vbr=0:br=64:mode=3 -vf pp=tn/lb,scale=384:288 -sws 1 -endpos 60

Crea un avi escalado a 348x288, codificado en mpeg4, con sonido mp3 de calidad 64 en mono. Realiza una captura de 60 segundos ( -endpos 60)

Pd: separator (paso 4.8)

2007-04-06T15:14:00.000+01:00

Como ya sabes, en la línea que une gemhead con un objeto de dibujo, es posible añadir transformaciones. Digamos que [gemhead] actua como un objeto metro para el renderizado, al que además vamos añadiendo indicaciones sobre posición, rotación color etc. Por otra parte, como hemos visto, en la misma línea se pueden añadir varios objentos de dibujo, de manera que van heredando las transformaciones que le hicimos a los anteriores.

En algún caso, puede ser interesante poder bifurcar la línea de transformaciones en dos, de manera que dos objetos distintos, hereden por separado las transformaciones de otro. Para eso está el objeto [separator]. El siguiente ejemplo lo usa

Dibuja un rectángulo, parecido a como hacíamos en el paso 4.7. Pero aparece enseguida separator. La línea que viene de gemhead se bifurcará en dos (podrían ser más claro). De manera que se dibujarán dos rectángulos que heredan las transformaciones del primero. El efecto de este patch, una vez pones lo valores a punto, es este:

Una especie de Y , o pinza. Si rotas o transladas el primero rectángulo (las primeras transformaciones que aparecen tras gemhead, y antes de separator), moverás el conjunto. Pero una vez en cada una de las bifurcaciones, puede controlar por ejemplo, la rotación de cada brazo de la Y por separado. En el patch anterior, marqué con gris, azul o rosa, el control de rotación de los rectángulos blanco, azul o rojo, respectivamente.

Si observas tu propia mano, de la palma ves salir 5 dedos, los cuales pueden ser movidos independientemente, sin embargo, la posición de la mano, determina la de los dedos. En ese caso, haría falta un objeto [separator] por cada dedo.

La espero

2007-04-04T09:15:00.000+01:00

El orden criminal del mundo

Pd: Articulaciones con gemlists (paso 4.7)

2007-04-03T16:55:00.000+01:00

En el paso 4.6 vistes cómo efecta el orden de las transformaciones en una línea [gemhead]-->[objeto]. Avanzando más en la cuestión, crearemos un rectánculo de anchura 0.1 y altura 0.5. El centro de coordenadas es también el centro del rectángulo.

Si primero rotamos, y luego desplazamos, conseguiremos que el rectángulo gire en torno al eje de rotación, en este caso el Z. El efecto será similar al de estar mirando la aguja de un reloj, la cual gira en torno a un eje fijado en su extremo. Si cambias el valor de "ROTA" verás que efectivamente ocurre.

Vamos a crear varios objetos dependientes, como los eslabones de una cadena, o como un brazo articulado. Para ello, en la misma línea de gemhead, crearemos otro rectángulo:

Presta atención a que hay dos objetos [translate] transformando el segundo rectángulo, pero por ahora el segundo no hace nada, así que no lo tengas en cuenta. Al contrario que antes, ahora trasladamos y luego rotamos, eso es así porque queremos que el segundo objeto rote sobre sí mismo, pero trasladado una cantidad. Con los valores que hay (no olvides pulsar el mensaje 0.5), se produce un dibujo como este:

El círculo azul no está realmente, pero ejemplifica el movimiento que puede seguir la ficha azul. El rojo, gira como la aguja de un reloj, mientras que el azul gira sobre sí mismo, colocado en el extremo del rojo. Si giro el objeto rojo, también muevo el azul, pero el azul es independiente en su giro.

Añadiendo una traslación al objeto azul,

Haremos que este gire sobre uno de sus extremos, colocado justamente al final del objeto rojo. Aunque en un plano, podemos decir que es la misma relación entre brazo y mano por ejemplo.

Añadiendo otro rectángulo más, ya tendremos una cadena de tres piezas articuladas:

Pulsando el mensaje 0.5, se coloca cada pieza en su sitio. Sirve este valor, 0.5, para colocar todas, porque las tres miden 0.5, entonces todas se desplazan 0.5 unidades de la anterior.

Para simplificar a la vista el patch, podemos hacer uso de subpatch, uno para cada eslabón, de manera que desde el patch principal, sólo controlemos los ángulos de cada nivel

He añadido un "nivel más" constituido por un círculo blanco, que ejemplifica que la cadena puede seguir más aún

Un ejemplo de lo que hay en uno de los subpatch es esto:

[loadbang] hará que al cargar el patch se actualicen los valores 0.5 de traslación.

Así obtenemos una figura articulada, cuya rotación por pieza puede controlarse en tiempo real. Más complejo pero posible es crear un organismo animado con cierto grado de articulación. Ya veremos [separator] para estructuras algo más complicadas. De todas formas el external pmpd permite manejar estructuras de objetos con propiedades físicas, como fuerzas de atracción /repulsión, movimientos en partículas, etc.

Pd: orden en las transformaciones (paso 4.6)

2007-04-03T11:21:00.000+01:00

En la línea que une [gemhead] con el objeto a dibujar, se van añadiendo transformaciones, es lo que se conoce como gemlist. Dichas transformaciones se ejecutan según van apareciendo, por tanto el orden es importante, porque el resultado final puede ser distinto. El caso más claro es el de la rotación y la traslación.

Puedes pensar que cada línea gemhead genera un sistema de ejes locales x, y, z. Estos ejes se irán rotándo o trasladando para dibujar en cierta posición del espacio un objeto. Por ejemplo, en el caso de rotación o traslación, intenta imaginar estas dos situaciones.

Primero roto, y luego desplazo-> El sistema de ejes local que va a dibujar rota cierto ángulo, después se desplazará una cantidad en una dirección.

Primero desplazo y luego rozo--> El sistema de ejes local se desplaza en una dirección, y luego rota

Con el siguiente montaje usando GEM puedes comprobar que el efecto resultante cambiar el orden de rotación y traslación, es distinto:

pulsa en la imagen para ampliar

En el caso de "Primero roto y luego desplazo" el efecto será que el objeto gira alrededor del eje del que me he desplazado. Es el caso del círculo rojo.

Por otra parte, en el caso "Primero desplazo y luego roto", el efecto será que el objeto desplazado gira sobre sí mismo. Es la situación del círculo verde.

Hacerte una imagen de lo que ocurre al rotar y desplazar, es la única manera de predecir que va a pasar con cierto orden de transformaciones. Además es importante saberlo para organizar estructuras de objetos dependientes unos de otros.

En relación a esto último, fíjate que en los objetos dibujados hay un outlet. Eso indica que se puede continuar la línea de transformaciones, y dibujar otros objentos ¡en la misma gemlist!. Este es un ejemplo de eso mismo

Primero se dibuja un círculo rojo y luego uno verde. Pero las primeras transformaciones afectarán a todo lo que venga debajo, en este caso, a los dos círculos. Mientras que las transformaciones que hay tras el primer [circle], no pueden afectar hacia atrás, entonces sólo afectan al círculo verde.

Si imaginas el movimiento de tu brazo, te puede ayudar. Antebrazo, brazo, mano y dedos, en ese orden son una línea gemhead. El antebrazo mueve a todo lo demás, incluso la posición de los dedos en el espacio, sin embargo podemos mover los dedos, sin alterar la posición del brazo por ejemplo.

pd: emitir con oggcast~

2007-03-24T16:51:00.000Z

Si ya has configurado tu servidor icecast, o bién tienes la posibilidad de usar alguno remoto, puedes emitir con puredata sonido ogg vorbis. Es decir usando puredata como fuente (source). Encontrarás el objeto oggcast~ en el external pdogg, cuyo desarrollo se ha detenido.

El siguiente patch te permitirá emitir a un servidor icecast:

El objeto oggcast~ recibe desde la parte izquierda dos canales de un sonido muy simple. Pero podría ser, cómo no, cualquier cosa, incluso un archivo ogg. También recibe mensajes colocados ahí de arriba a abajo para sencillez visual.

-server 1, indica que usará la 'nueva' versión de icecast2, por defecto es icecast.
-passwd es donde introduces tu contraseña como fuente, que debes haber configurado en tu servidor icecast, o bien te la darán si no eres administrador.
-connect localhost puredata.ogg 8000. Indica respectivamente, el nombre del servidor (localhost), el punto de montaje (puredata.ogg), y el puerto por el que emitirás (8000). Este último depende del puerto que tengas abierto en tu máquina para emisiones.
-vbr 44100 2 0.9, indican la frecuencia de muestreo , el número de canales, y un número entre 0 y 1 indicador de la calidad del audio (1 máxima- 0 mínima).
-disconnect, como su nombre indica corta la emisión.
-TITLE, son las etiquetas que recibe el oyente para información. Puedes añadir otras como ARTIST, PERFORMER, DESCRIPTION, GENRE, LOCATION, COPYRIGHT, CONTACT, DATE

(para más opciones mira la ayuda de oggcast~)

Atención a la salida caliente de oggcast~, devuelve 1 si está activo o 0 si está apagado. Por defecto oggcast~ usa 2 canales y un buffer de 512, como ves puedes configurarlo con dos parámetros, al definir el objeto oggcast~

Pd: interruptores moses y spigot(paso 1.14)

2007-03-13T10:13:00.000Z

En el manejo de secuencias de datos, es necesario contar con interruptores o algún sistema que interrumpa el flujo, a modo de grifo de un chorro de agua. En puredata, con unos cuantos objetos y con ingenio, ya pueden construirse muchos sistemas - en teoría con los operadores lógicos y los números binarios se ha contruido todo el resto del tinglado llamado 'computación'. Sin embargo, siempre es una alegría saber que hay un objeto que hace exáctamente lo que quieres ;)

[moses] tiene dos salidas, y un parámetro de control, que se varía con la entrada fría. El funcionamiento es sencillo. Si los datos que vienen por la entrada principal, no superan el valor que indica la entrada fría, [moses] dejará pasar los datos. Pero pasado el valor umbral, el flujo de datos saldra por la segunda salida.

En el montaje de la izquierda el valor de referencia es 0, por tanto por debajo de 0 los datos saldrán por la izquierda, y por debajo de 0, por el outlet derecho. Es un forma de separar números positivos de negativos. Por otra parte, en el montaje de la derecha, el valor umbral es 100, y el funcionamiento el mismo. Se podría hacer un sistema que mantiene un flujo de números alrededor de un valor de referencia, haciendo que según se pasen lo valores, por arriba o por abajo del valor umbral, pasen cosas distintas.

Otro ejemplo de uso de moses:

Al hacer bang sobre random, generará un número entre 0 y 99. Si es menor que la cantidad indicada en la segunda entrada de moses , pasará al primer bang, si supera dicho número se genera al segundo bang. Estamos eligiendo entre dos caminos con la probabilidad que asignemos. Ejemplo, si colocamos el valor de moses a 50, ocurrirán los dos bang inferiores con igual probabilidad, o dicho de otra manera, al 50 %

[spigot] es un interruptor en el sentido convencional. Permite el paso de datos siempre que el valor de su inlet frio, no sea cero. Si es cero, se cierra el grifo, si es otro valor [spigot] no existe. Mira este ejemplo:

En este caso uso mensajes 1 o 0 para que sea como un interruptor, aunque como ves le va que ni pintado un toggle (control+alt+T). Es un objeto muy básico y útil.

[En el external unauthorized existe el objeto [spigot~] que funciona igual para señales de audio.]

pimm....ploommmm

2007-03-07T17:31:00.000Z

http://geekproject.com/william.aspx

El contenido del video anterior, es a este TEXTO

lo que la sinceridad al embuste.

Pd: Espiral de ruido

2007-03-04T12:59:00.000Z

Veremos cómo hacer un loop de textura de vídeo sencillo, usando pdp. Sin más, escribe:

Generará un cuadro de ruido, o dicho de otra forma, una foto estática con ruido, cuando pulsas bang. El ruido visual en este caso no es más que pixeles coloreados al azar.

Se puede convertir la foto de ruido a un vídeo, añadiendo:

Ahorq aparece [metro] generando bangs cada 40 milisegundos. En un segundo (1000 milisegundos) habrán ocurrido 1000/40=25 bangs, que es el standard para el formato de video PAL. Pulsando 1 obtienes entonces una animación de ruido.

Complicando ligeramente el patch anterior:

Aparecen nuevos objetos de pdp. Ahora hay dos secuencias de bang, dos [metro], independientes. Cada cual genera una animación de ruido distinta. Una se actualiza cada 40 milisegundos y otra cada segundo. A la de la derecha, le aplicamos un pdp_zoom, para acercar las manchas de colores; puedes jugar con este parámetro. Pero lo importante aquí es cómo conjuntar las dos animaciones en una sola, y aquí es donde entra en juego el mezclador [pdp_mix]. Este objeto, mezclará en cierta proporción dos entradas de secuencias de fotogramas. La cantidad de una secuencia u otra depende del parámetro de control, en este caso 0.7, que puede controlarse por la entrada más a la derecha de [pdp_mix].

Ahora, haciendo un truco de magia, añade esta extrañeza al montaje:

Lo pripero es ver qué significa [pdp_del]. Básicamente es un delay para cuadros de vídeo. En este caso sin la indicación de nada más, produce un retraso de un fotograma o cuadro, de manera que produce una línea retrasada en el tiempo (de bangs). Prueba a mezclar un vídeo, con él mismo retrasado con pdp_del. Si usas retrasos muy grandes, le estarás pidiendo mucho proceso a tu equipo, ya que debe guardar los fotogramas de diferencia

En la figura anterior, aparece una cosa curiosa. Se mezcla una línea de cuadros con ella misma retrasada un solo cuadro (pdp_del sin parámetros). El efecto conseguido es simplemente más suavidad en el movimiento, produciendo una textura más suave. Sin embargo fíjate que ahora la salida de pdp_mix, recoge el efecto y vuelve a ser reintroducido a pdp_del.

También aparece [pdp_glx], la elección de este o xv dependerá de tu hardware. Si xv es genérico glx se usa para sistemas con aceleración gráfica.

Ahora bien, al fotograma retardado podemos aplicarle transformaciones, por ejemplo, si cada cuadro retardado y reintroducido lleva también un pequeño giro, se puede dar el efecto de imagen giratoria en espiral, que es uno de los 'trucos' que buscamos. Altera el montaje a este:

El bucle que creamos con pdp_mix y pdp_del ahora lleva las transformaciones de rotación y zoom. Juega con estos parámetros, añdiendo nuevos efectos.

Un toque final, da el efecto deseado.

la mezcla final, vuelve ser añadida al video controlado con [metro 1000], mediante [pdp_add] que siemplemente suma dos cuadros. También hay un efecto del punto sobre el que se hay zoom enviando centerx a [pdp_zoom] (0 es a la izquierda y 1 a la derecha). Ajustando los parámetros, podrás obtener una espiral fractal giratoria:

fuente: http://www.yourmachines.org/tutorials/pdvideolan.html#step_3

Emitir desde webcam con icecast y oggfwd

2007-03-02T12:58:00.000Z

Suponiendo que ya has configurado tu servidor icecast2 o bien dispones un servidor donde emitir, necesitarás los paquetes:

ffmpeg2theora
oggfwd

El primero es capaz de convertir video strimeado :) a ogg theora. El segundo te permite emitir ogg, video (theora) o audio (vorbis) a un servidor icecast.

Voy a suponer que tu webcam funciona en el dispositivo /dev/video0

La manera de capturar en video ogg lo que ve tu webcam es esta:

ffmpeg2theora --v4l /dev/video0 --inputfps 25 --nosound -v 10 -x 160 -y 120 -o salida.ogg

Vamos por partes:

--v4l /dev/video0 indica el dispositivo que leerá. Sería posible usando dvgrab grabar desde una cámara digital, si tenemos capturadora en dv de vídeo.

--inputfps 25 es el número de cuadros por segundo, y esto depende de las características de tu webcam y de la calidad que quieras dar.

--nosound es evidente....

-v 10 es un indicador de la calidad del video, por defecto es 5, prueba con varios valores.

-x 160 -y 120 indican el tamaño de cada cuadro, valor que depende también de las posibilidades de tu webcam así como de la calidad que quieras dar.

-o salida.ogg guardará el resultado en un archivo ogg llamado salida.ogg Como veremos puedes indicar /dev/stdout o sólo "-" (sin comillas) para enviar la salida a la salida standar y así poder recoger el resultado con otro programa. Cosa que haremos para el streaming.

Las opciones para oggfwd son sencillas

oggfwd ipdelservidor puerto contraseña puntodemontaje

por ejemplo para emitir en la red local

oggfwd localhost 8000 tupassword puntodemontaje.ogg

Si tu puerto para emitir es el 8000. Para enganchar la salida de ffmpeg2theora a la entrada de oggfwd y que emita, sólo tenemos que conectar las dos líneas así:

ffmpeg2theora --v4l /dev/video0 --inputfps 25 --nosound -v 10 -x 160 -y 120 -o salida.ogg | oggfwd localhost 8000 tupassword puntodemontaje.ogg

Emitir por icecast

2007-02-27T22:25:00.000Z

Para instalar icecast, necesitas el paquete icecast2. También usaremos ices2 para emitir audio vorbis ogg, al servidor, instalado en nuestro equipo.

Supongo que tienes un router adsl, y al menos un equipo al que tienes acceso como administrador ;)

(como superusuario)

apt-get install icecast2 ices2

icecast2

icecast2 se configura con archivo xml colocado en

/etc/icecast2/icecast.xml

si lo editas verás que tiene muchas opciones, sin embargo sólo se necesita colocar algunos datos clave. Si el editor que usas tiene sintaxis coloreada, será más cómodo a la vista (en vim escribe :syntax on).

Atiende a estas opciones:

<code>

</code>

clients hace referencia a el número de personas que podrán conectarse a tu servidor para escuchar. sources es el número de emisiones simultaneas. Esto dependerá que la capacidad del tu linea de internet, de la red y equipo que uses. Generalmente tendrás que usar números pequeños ;)

Seguimos

<code>

<source-password>contraseña</source-password>

<relay-password>hackme</relay-password>

<admin-user>admin</admin-user>

<admin-password>contraseña</admin-password>

</authentication>

</code>

Debes definir una contraseña source-password, los programas que emitan. También admin-user y admin-password para el control del servidor. Las tres contraseñas no tienen que ser la misma, de hecho si el administrador del servidor icecast y el que emite, no es misma persona, deberían ser distintas.

<code>

<hostname>localhost</hostname>

</code>

Por ahora colocaremos 'localhost' en hostname. localhost es un nombre genérico para la red local.

La configuración puede afinarse mucho, pero dejaremos las otras opciones por defecto. Guarda el archivo. Edita el archivo /etc/default/icecast2 y coloca la propiedad ENABLE en true.

Puedes lanzar el servidor con

/etc/init.d/icecast2 start

o pararlo con

/etc/init.d/icecast2 stop

Por último, abre el navegador y ve a la dirección

http://localhost:8000

lo cual te mostrará la página del servidor que has instalado. Si intentas entrar en Administración, te pedirá el nombre y contraseña de administrador que configurastes en el archivo icecast.xml

ices2

El servidor está corriendo, lo que necesitamos ahora es emitir datos desde una fuente (source). Para eso usaremos ices2 que nos permitirá emitir audio codificado en ogg a un servidor icecast. La fuente y el servidor no tienen que estar en la misma máquina, sin embargo en este ejemplo sí es así.

ices2 es muy configurable según el tipo de emisión que queramos: lista de archivos, captura de sonido en tiempo real, etc. El siguiente es un ejemplo de configuración para emitir una lista de archivos ogg que tenemos colocados en alguna parte del sistema. El siguiente ejemplo, yo lo pongo en /etc/icecast2/ices2.xml, pero no tiene que ser así. Puedes tener una lista de archivos de configuración en una carpeta especial. En cualquier caso este es un ejemplo, con el que puedes probar:

<code>

<ices>

<logpath>/var/log/icecast2</logpath>

<name>Nombre de la raio</name>

<genre>género</genre>

<description>descripción</description>

</metadata>

<input>

<module>playlist</module>

<param name="type">basic</param>

<param name="file">/home/rodrigo/icemision.txt</param>

</input>

<hostname>localhost</hostname>

<password>contraseña</password>

<mount>/puntomontaje.ogg</mount>

<nominal-bitrate>64000</nominal-bitrate>

</encode>

</instance>

</stream>

</ices>

</code>

Lo que debes personalizar es lo siguiente:

<code>

<name>Nombre de la radio</name>

<genre>género</genre>

<description>descripción</description>

</metadata>

</code>

Muy importante

<code>

<param name="file">/donde/quieras/listadeoggs.txt</param>

</code>

path de un archivo de texto que contiene una lista de los archivos ogg que se van a emitir.

<code>

<hostname>localhost</hostname>

<password>contraseña</password>

<mount>/puntodemontaje.ogg</mount>

</code>

Tanto hostname como password, deben ser las mismas que configurastes para el servidor, respectivamente hostname y source-password. El punto de montaje puedes ponerle cualquier nombre terminado, y es el punto de acceso a la emisión. Por ejemplo, ya que vamos a emitir en la red local, por el puerto 8000, la dirección va a ser

http://localhost:8000/puntodemontaje.ogg

También hay datos sobre la calidad del audio a emitir, cosa que debes tener en cuenta para emisiones masivas, las cuales deberían estar en mono y un grado de compresión considerable.

Necesitas crear un archivo de texto en alguna parte que contiene las direcciones de archivos ogg. Una ayuda para eso puede ser:

find /home/tusuario/ -iname '*.ogg' > misogg.txt

La cual busca archivos terminados en .ogg en la carpeta que le digas, y mete los resultados en el archivo misogg.txt No olvides decir dónde está dicho archivo en la configuración de ices2

Guardando el nuevo ices2.xml, y suponiendo que lo has puesto en /etc/icecast2/ices2.xml lanzamos ices2 así:

ices2 /etc/icecast2/ices2.xml

Si todo va bien, estarás emitiendo desde ices2 (source) hasta el servidor icecast, que está en la misma máquina. Para escuchar la emisión, desde algún usuario, escribe en el navegador:

http://localhost:8000/canciones.ogg

suponiendo que el punto de montaje es /canciones.ogg

Deberías escuchar tu música

Emitir a internet, o fuera de tu red local

Para ello, debes asegurarte de que el puerto 8000 está abierto para tu máquina. Para ello denesitas saber:

1- La ip del router (generalmente 192.168.1.1 )

2- El nombre y contraseña de administración del router, que te dan al instalarlo.

3- La ip de tu máquina. Podría ser que varias máquinas estuvieran conectadas al mismo router. En este caso, la ip de la máquina que tenga el servidor icecast (como supongo que usas gnuLinux, escribe como root , ifconfig eth0, y en inet addr tendrás la ip de tu máquina en la red local)

Debes entrar en la configuración del router, poniendo en el navegador:

http://192.168.1.1 (busca en la documentación de tu router)

En las opciones de nat, hay que abrir el puerto 8000. En mi caso, me pide los datos:

Ip Adresses

global: 0.0.0.0

internal: (coloca la ip de tu máquina, punto 3)

type: tcp

External port range

start:8000

end:8000

Internal port range

start:8000

end:8000

Guarda la configuración y reinicia router.

Ahora podrás emitir a internet, si conoces tu ip pública. Para conocerla puedes visitar:

http://www.adslayuda.com/ip.html

(si tu provedor usa un proxi, la dirección ip que de dan en dicha dirección, será "falsa", deberías preguntar entonces)

La dirección para otros ;) será

http://tuippublica:8000/puntodemontaje.ogg.m3u

Pd: operaciones con expr (paso 1.13)

2007-02-27T20:04:00.000Z

PureData tiene una forma de escribir operaciones matemáticas en forma de cadenas de texto, tal y como lo escribiríamos en una fórmula. Esto se separa un poco de la filosofía conexionista, pero en realidad permite escribir objetos con formulas complejas, y todo metido en un recuadrito. Veamos la una de las más simples quizas:

El objecto expr, realiza la suma. De igual manera podríamos usar otras operaciones. En el siguiente ejemplo se multiplican los valores que se reciben por las entradas, representadas por $f1 y$f2

la f1 se refiere a la entrada de la izquierda y la f2 a la derecha. Prueba a añadir más entradas, simplemente introduciendo más $fn en las operaciones.

Un ejemplo más que calcula el valor seno de un número en grados

La f de $f1 significa float (número 'con decimales') sin embargo puedes cambiarlo por i, entero, o s símbolo. En la ayuda de pd encontrarás más ejemplos.

Una opción interesante es añadir a las expresiones condicionales para la elección. El viejo if...then... tambien puedes incluirlo en las expresiones.

En concreto en este caso, si el número $f1 es mayor que 0, se devuelve el mismo número, pero en caso contrario, se devuelve 0. La sintáxis viene a ser así:

if (condición, lo que pasa si se da la condición, lo que pasa si no se da la condición)

Como vés, esto añade la posibilidad de incluir ecuaciones y cálculos detallados en una caja de objeto, lo cual da mucha más potencia a nuestros patchs. También existe no obstante, expr~ para operaciones con las muestras de sonido en tiempo real, así como fexpr~ para manejar vectorialmente conjuntos de muestras, pero no lo veremos en este capítulo.

pd: video tutoriales

2007-02-23T10:46:00.000Z

0 PD testing video
Si haces eso y suena, ya puedes empezar a trabajar ;)
1 PureData- envolvente sencilla
Introducción al uso de [line]. Line recibe mensajes con dos argumentos, que respectivamente son 'hasta qué valor llegarás' y 'cuánto tiempo en milisegundos tardarás en alcanzarlo'
2 PureData- batidos
Montaje sencillo con dos osciladores. De paso, como sus frecuencias son muy cercanas, se muestra el efecto de batidos.
3 PureData- Oscilador de Tabla de ondas
tabosc4~ lee una tabla tantas veces por segundo como indiquemos, eso permite dibujar la onda. Sig~ convierte a audio un valor numérico, esencial para controlar tabosc4~. Fijate como se pueden enviar dibujos de onda directamente a la tabla
4 PureData- Dibujar una onda diente de sierra
phasor~ genera una onda con dibujo 'diente de sierra'. Puesto que genera valores entre 0 y 1, le restamos [-~ 0.5] para centrarla. tabwrite~ dibuja la onda cuando recibe un bang
5 PureData- objecto METRO
Ejemplo sencillo de sincronización con [metro]. Metro tiene un parámetro expresado en milisegundos, que indica cada cuanto tiempo generará un bang. En el vídeo en tiempo real con pd, este objeto es esencial. El significado de select se ve por si mismo
6 PureData- Minisecuencia MIDI
Aunque no es muy representativo de lo que puede hacerse con MIDI, ejemplo de generación de 10 notas midi, mientras las almacena en una tabla.
7 PureData- player de ogg
Se muestra un sencillo player de ogg vorbis. oggread~ pertenece al external pdogg, por tanto debes tenerlo instalado para que funcione (en la versión 0.39-2 de puredata-extended está). seek selecciona el punto desde donde el quieres escuchar, en segundos.
8 PureData- Sampler Simple
Usando [soundfiler] puedes leer un archivo de sonido externo en una tabla. posteriormente con [tabplay~] es posible reproducirlo. En este ejemplo spigot funciona como un interruptor para activar un bucle en la reproducción. ";pd dsp $1", muestra otra manera de activar/desactivar el sonido.
9 PureData- Ondas desde phasor~
Aplicando transformaciones directamente a la señar que produce phasor~, se pueden obtener las ondas típicas usadas en síntesis sustractiva. Senoidal, Cuadrada, Diente de sierra, Triangular, y por supuesto muchas más.
10. PureData- Sampler con phasor~
[phasor~] puede utilizarse como lector de una grabación, ya que va periodicamente desde 0 hasta 1. Multiplicando la salida de [phasor~] por el número de muestra, ira desde 0 hasta el número de muestras.

"yo soy" es pasado

2007-02-18T18:25:00.000Z

"cuadrado negro sobre fondo blanco" (1913)
Kasimir Severinovitc Malévitch

Lo más claro, contundente, radical, intrépido, valiente, preciso, real, científico, objetivo, considerado, compasivo, abierto, profundo, misterioso, oscuro, e íntimo que puedes decir es simplemente: 'yo soy' es pasado.

¿Te atreves a realizarlo?

yourmachines

2007-02-18T12:45:00.000Z

Algunos tutoriales (en inglés) sobre audio y video usando softwarel libre:
http://www.yourmachines.org/tutorials.html

Objetos pd

2007-02-12T19:09:00.000Z

Clases para pd, incluyendo algunos paquetes externos usuales.
http://ptechnic.org/puredata/pdcommands.txt
(en traducción)

Libro sobre técnicas de síntesis analógica

2007-01-28T20:54:00.000Z

Jacob Joaquin ha escrito (en realidad revisado una versión anterior) este libro titulado "Explorando técnicas de síntesis analógica", que puede ser leído on-line aquí:

http://www.thumbuki.com/csound/articles/east/

Banco de imágenes y Sonidos del MEC

2007-01-12T12:27:00.000Z

Banco de sonidos libres en formato ogg y mp3, también imágenes y animaciones, listos para descarga, en la web del Ministerio de Educación y Ciencia:

http://recursos.cnice.mec.es/bancoimagenes4/

puedes acceder directamente a los sonidos aquí:

http://recursos.cnice.mec.es/bancoimagenes/sonidos/directorio.php

Effectv

2006-11-30T22:12:00.000Z

Effectv es un procesador de efectos en tiempo real. Tiene una serie de efectos de vídeo que aplicas sobre una fuente. La instalación en Ubuntu/debian es sencilla si no vas buscando la última versión:

sudo apt-get install effectv

Suponiendo que tienes la webcam, cámara o capturadora etc en /dev/video, puedes lanzar effectv así

effectv -device /dev/video

Con las teclas de las flechas arriba o abajo vas cambiando de efecto. Puedes encontrar no obstante más información en:

http://effectv.sourceforge.net/

*Grabar con vloopback

effectv soporta vloopback, por lo que puedes instalarlo (mirar aquí) y lanzar effectv con una línea como esta:

effectv -vloopback /dev/video1 -channel 1

Usando ffmpeg como codificador:

ffmpeg -vd /dev/video2 -s 320x240 effect.mpg

Lo cual guarda lo que procesa effectv en el archivo effect.mpg

*Añadir efectos en tiempo real a una video conferencia

Por ejemplo usaremos amsn. La misma línea de antes

effectv -vloopback /dev/video1 -channel 1

Lanzamos amsn, y en la configuración de la cámara (preferencias-->otras-->cámara) , selecciona effectv como controlador.

Blue

2006-11-28T19:01:00.000Z

requiere Csound

Blue es un entorno gráfico para Csound, aunque habría que decir que en muchos aspectos lo completa, incluso supera. La web de Blue es esta:

http://www.csounds.com/stevenyi/blue/

está escrito en java así que necesitaremos el java run-time para ejecutarlo:

sudo apt-get install sun-java5-jre

Recomiendo bajar la última versión de blue, el paquete "installer". Y lo ejecutamos con un línea como esta:

java -jar blue_0.109.0_installer.jar

En el proceso de instalación eligirás dónde los vas a instalar. Yo lo pondré en mi carpeta de usuario, en la carpeta blue.

Para ejecutarlo, sólo tienes que entrar en la carpeta blue, y en bin, para luego ejecutar

./blue.sh

O si quieres, crea un archivo de texto

vim blue

Escribe esto en él (pulsa i para escribir en vim)

#!/bin/bash

$HOME/blue/bin/blue.sh

Guarda el archivo pulsando :wq

Da permisos de ejecución al archivo

sudo chmod +x blue

Guarda el archivo en /usr/local/bin

Ahora podrás lanzar blue desde cualquier parte escribiendo

blue

Avelino Herrera

2006-11-27T11:46:00.000Z

Un sitio recomendable a los interesados en Audio, por la calidad de sus contenidos: tutoriales y ejemplos de síntesis sonora

http://avelino.gabiot.com/blog/

Pd: patch, subpatch y abstracciones (1.12)

2006-11-27T11:08:00.000Z

Cuando abres pd y creas una ventana nueva (pulsando control+n o en el menú file) estás creando un Patch. La manera de organizar el entorno de programación es entonces en patchs. Un patch puede contener subpatch, o subventanas para nosotros, que se abren o guardan cuando guardamos el patch principal. En el siguiente ejemplo se han creado tres subpatch, escribiendo dentro de un objeto, "pd" seguido del nombre que queramos darle al subpatch.

Nada más crearlos se abrirán otras subventas, que puedes cerrarlas, y volverlas a abrir pulsando en los objetos correspondientes. Aunque fíjate que el tercero tiene tres inlets o entradas, y un outlet o salida. Eso es algo interesante de los subpatch, que pueden añadirse inlets u outlets para interactuar con ellos como si fueran objetos. Este es el contenido del tercer subpatch del ejemplo anterior

Los inlets se definen escribiendo precísamente "inlet", y se colocarán de izquierda a derecha; ese orden será el mismo que tendrán los inlets en la ventana general. Es un subpatch trivial, pues hace la suma de tres números. Igual que ocurre con los inlets, pasa con los outlets.

De esta manera, puedes crear submontajes dentro de otros, manteniendo la interacción entre ellos, lo cual permite ordenar el programa en capas, para que sea mucho más tratable. Prueba a construir los subpatch anteriores, e interactuar con el subpatch que hace la suma de tres números.

Abstracciones

Algo que se deriva de lo anterior y es si cabe más interesante, es que lo que has aprendido sobre colocar objetos [inlet] y [outlet] , puedes hacerlo sobre un patch general. Pero entonces ¿desde dónde? y ¿a dónde? enviará los datos. Puedes guardar el patch, y decirle a PureData dónde está mediante File-->Path.... Imagina que creas un patch nuevo, e introducimos lo que hay en la segunda figura (la triple suma). Guardamos el patch, por ejemplo con el nombre trisuma.pd . Indicamos dónde lo puede encontrar a Pd, entonces ahora siempre que uses pd, puedes añadir tu nuevo objeto (abstracción)

[trisuma]

que tendrá tres inlet y un outlet. Así de simple. Es habitual, crearte una carpeta para tus abstracciones, de manera que si cambias de máquina o reinstalas pd, siempre puedes volver a indicar la localización de tus propios objetos, y usarlos.

Webcam, o intentarlo

2006-11-18T20:26:00.000Z

Peripecias para instalar una webcam en ubuntu linux.

Enchufo la webcam usb, abro un terminal y escribo

lsusb

Lo cual listará los dispositivos usb enchufados. A mí me sale

Bus 001 Device 002: ID 046d:092f Logitech, Inc.

Eso indica que tengo un dispositivo Logitech en el usb nº 2. Después de id viene el código de fabricante y número identificador del producto. ID 046d:092f

Ve a esta lista, y comprueba que tu cámara (mirando la columna Vendor ID, y product ID) está soportada.

http://mxhaard.free.fr/spca5xx.html

Si está podrás instalar el modulo spca5xx

Aquí podrás bajar dos versiones del módulo según sea la versión de tu kernel

http://mxhaard.free.fr/download.html

Averiguas la versión de tu kernel, escribiendo en un terminal

uname -r

Baja entonces la opción que te convenga, según sea tu kernel más moderno o más antiguo.

Para facilitar las herremietas necesarias para compilar, instalo el paquete module-assistant

sudo apt-get install module-assistant

Lanzo el programa como administrador

sudo module-assistant

Eligo la opción PREPARE, que me bajará los paquetes necesarios para compilar módulos, si no los tienes ya.

Ve a donde lo hayas bajado, y descomprime

tar zxvf gspcav(...).tar.gz

entra y escribe

make

y luego

sudo make install

Cargas el módulo nuevo

sudo insmod spca5xx

(puedes reiniciar la máquina ahora si quieres, no se si el dispositivo de video se crea en este punto, o hay que reiniciar)

Se han creado nuevos dispositivos de video

ls /dev/video*

Ahora puedes instalar un programa para testear la webcam como camorama

sudo apt-get install camorama

Con el comando camorama, verás un programa sencillo para trapichear con la webcam. Si tienes varios dispositivos de vídeo, puedes ajustar el lanzamiento con -d

camorama -d /dev/video0

huérfanos de sentido

2006-11-18T11:38:00.000Z

..[quien] no presta con usura ni cobra intereses..., un hombre así es justo.”

(Ezequiel 18 8-9)

Me pregunto, si sería posible crear lugares exentos de especulación económica, como (supongo) que es el polo sur. Ante la mirada de la persona moderna y a la última -dicho con toda la ironía de la que soy capaz- esos lugares serían improductivos, altares a la inutilidad. "Algo es útil si es rentable en cuanto al capital que produce".

Esa máxima que a muchos nos ronda la cabeza, como ronda la cabeza el número ganador 3 veces seguidas en una ruleta, no es que sea verdad o mentira, es que es una exageración, una distorsión en la conciencia. Desde mi punto de vista, fruto de la adolescencia de la ciencia económica, que ha pasado y pasa, por una etapa narcisista, buscando sus propios límites. Como apuntó Amartya Sen, la economía debería volverse a las facultades de ética, y subyugarse como una disciplina brazo de esta. Pero amigos, la ética está en crisis como edificio único y global, por tanto la usura calculada campa a sus anchas, coja y sin bastón.

Por añadir otra imagen a lo que quiero sugerir, me gustaría imaginar un gran bosque vedado a los humanos, para que me entendáis nada rentable e inútil; vacío de altruismo o avaricias. Que fuera virgen, aunque sólo sea de forma gestual -gestos verdaderos que hacen ritos falsos- como reconocimiento de que hay cosas, la mayoría, que no nos pertenecen; más bien pertenecemos a ellas.

¿Existe un lugar así?

Pd: transformaciones básicas (paso 5.2)

2006-11-17T13:05:00.000Z

Añadamos al ejemplo anterior, otras transformaciones sencillas para vídeo (ver paso anterior)

Se añade

[pdp_agc] para controlar el brillo
[pdp_contrast] para el contraste
[pdp_saturation] controla la cantidad de blanco o saturación

Son tres transformaciones básicas tanto en la fotografía como en la imagen en general. Las tres se controlan mendiante un único inlet.

En este otro ejemplo:

que no mezclo con el anterior para que sea más sencilla la comprensión, se usan dos trasnformaciones también muy simples. Esta vez un sólo objeto nos permite cambiar dos parámetros [pdp_zrot]. Los dos inlet empezando por la derecha controlan:

1º rotación. Puedes rotar la imagen de video una cantidad en grados
2ª zoom. Haces zoom sobre ella, siendo 1 el aspecto original. Fíjate que puedes hacer un mosaico de imágenes alejando el zoom.

Pd: Puredyne

2006-11-10T13:17:00.000Z

Pulsa para ampliar

Pure:dyne es una distribución de gnulinux, basada en dyne:coreII
Su objetivo es proporcionar un sistema operativo libre, en forma de un CD-live (arrancable desde una unidad lectora de cd-rom), a artistas gráficos, de audio y video. Con utilidades para la creacción y el streaming. A diferencia de dyne:core, Pure:dyne incorpora PURE DATA, preinstalado con muchos importantes externals y abstracciones. También incorpora csound, supercollider, fluxus y otros programas muy potentes para audio.

La web principal es:

http://puredyne.goto10.org/wiki/

lo puedes bajar desde aquí, eligiendo la versión estable o la última y "de pruebas"

http://puredyne.re-draw.org/

Pd: modulación mediante tablas (paso 3.5)

2006-11-09T18:05:00.000Z

Este es el ejemplo que viene en la instalación básica de pure data, llamado dos-tablas.

pulsa sobre la imagen para ampliar

Lo que se hace es crear dos tablas (arrays). La de abajo será la forma de onda del sonido que generaremos. Se ha creado con 259 puntos (256 que es una potencia de 2, más 3, ya que usamos taboscil4~). La superior, llamada en este caso pitch11, la usaremos para controlar la frecuencia de lectura de la segunda.

En primer lugar [sig~ 0.5] genera una señar digital con el valor constante 0.5. Ese valor se le pasa al primer [tabosc4~]. Esto indica que se leerá la tabla pitch 0.5 veces por segundo, o lo que es lo mismo, tardará 2 segundos en leer la tabla entera. El valor que se va obteniendo es el valor frecuencia para le segunda tabla [tabosc4~ waveform11].

Prueba a realizar el montaje por tu cuenta, y dibuja con el ratón sobre la primera tabla. Para producir una onda suave en la segunda tabla, envía mensajes tipo sinesum a la segunda.

Pd: minisecuenciador (paso 2.3)

2006-11-08T21:33:00.000Z

Este es un ejemplo muy sencillo de minisecuenciador de notas midi, nos servirá para conocer un poco mejor las tablas de datos (array)

La tabla array1 tiene 10 valores (puntos), y toman como rango (eje y) un número entre 0 y 12. Lo que ves a la derecha abajo, es un simple contador que va de 0 a 9 y empieza otra vez desde 0. Envía su valor a "contador". Este valor nos servirá para ir leyendo las distintas posiciones de la tabla array1. Aparece [int] ya que nos interesa valores entereros que son las notas midi. [int] genera un número entero truncando valores con decimales. Luego sumamos 60, para obtener un valor entre 60 y 72, es decir la octava de notas que está a partir de un "do central" de un piano.

Con [makenote] generamos el evento midi, que en este caso tiene un parámetro velocity 100 y dura 100 milisegundos. Si tienes conectado, por ejemplo, mediante jack, el programa pure data a un sintetizador externo, oiremos las notas.

Por último resaltar, que si sobre la tabla array1 pulsas con el botón derecho y eliges propiedades, en la ventana "array" verás un botón de que dice "view list", ahí podrás introducir a mano los datos de la tabla, cosa muy útil en este caso.

Añadir que también pueden crearse o alterarse los datos de un array, enviando un mensaje directamente. Por ejemplo, si hemos inicializado array1, un mensaje que contenga

array1 5 1 2 3 4 5 6

aun sin conectar a nada, enviará a la tabla "array1" los datos "1 2 3 4 5 6", empezando en la posición 5. Entonces recuerda, primero se indica desde qué posición en la tabla vas a introducir los números y después los datos. Pruébalo.

Pd: Ver video en tiempo real (paso 5.1)

2006-11-08T11:24:00.000Z

Una vez instalado el external pdp, lo cargas desde la línea de comandos:

pd -lib pdp

O bien añadiendo -lib pdp al archivo .pdrc que está tu carpeta de usuario. Si has instalado pidip también, se añadirá a la carga al instalar pdp. El montaje quizás más simple que puedes escribir es como este

Metro controla al objeto v4l (video for linux). El mensaje open indica que se leerá del dispositivo /dev/video. Por ejemplo si tuvieras una tarjeta capturadora de video, y una webcam, las podrás llamar desde algún dispositivo video0, video1, video2, etc. En mi caso /dev/video es un enlace simbólico a /dev/video0 que es donde tengo instalada una webcam.

Metro hace que pdp reciba una imagen cada 40 milisegundos. Prueba a poner 1000, y verás la imagen actualizarse cada segundo.

El siguiente objeto, que incluso podríamos haberlo omitido, sirve para ver en pantalla del computador lo que estás capturando. Ahí puedes colocar [pdp_glx] que usa el sistema gráfico con aceleración (opengl), propio de los nuevas distribuciones de linux, o bien [pdp_xv] que es más genérico.

El mensaje dim, configura las dimensiones de la ventana donde verás el video (si recuerdas es similar a dim en Gem). Al pulsar sobre el objeto [pdp_xv] y elegir help, verás muchas opciones de configuración.

Entre [pdp_v4l] y [pdp_xv] (o pdp_glx) se colocarán los efectos y transformaciones. Por ejemplo, en el siguiente ejemplo

Se captura en una foto, un "fotograma" del video que ves en pantalla, cuando haces click sobre el bang rojo. Es una aplicación sencilla, pero útil para utilizar la webcam como máquina de fotos.

Csound: instalación

2006-11-07T23:36:00.001Z

ATENCIÓN: Este post necesita de edición. A fecha actual (mayo del 2008), el paquete de csound5 ya se encuentra en debian sid, y en ubuntu hardy. Un apt-get csound es suficiente para instalarlo... (continuará)

La vía rápida es instalar la versión 4 que está en los repositorios standard de debian/ubuntu. Para hacerlo:

sudo apt-get install csound

Para instalar la versión 5 que tiene muchas mejoras y posibilidades en el entorno gnulinux, hay que batallar más por ahora. Al menos hasta hoy, a mí me da problemas de dependencias que hay que resolver. Esto es una guía para conseguir que funcione.

bajo el deb de la última versión aquí:

http://csound.sourceforge.net/#Downloads

instalo el deb:

sudo dpkg -i csound(version).deb

adapta esta línea a la versión que te hayas bajado.

Puesto que instalamos de esta forma, al actualizar los paquetes, te sugerirá cambiarla por la oficial, la versión 4. Si actualizas automáticamente, te desinstalará el csound 5. Para fijar el paquete recien instalado, y que no lo actualice (no lo hace si compilas desde las fuentes), tenemos que escribir:

sudo su
(introduce tu contraseña)
echo csound hold | dpkg --set-selections
exit

Al ejecutar csound, hay problemas en las librerías:

$csound
Localisation of messages is disabled, using default language.
PortMIDI real time MIDI plugin for Csound
ALSA real-time audio and MIDI module for Csound by Istvan Varga
WARNING: could not open library '/usr/local/lib/csound/plugins/librtjack.so' (-1)
WARNING: could not open library '/usr/local/lib/csound/plugins/librtpa.so' (-1)
[...]

Dice que con puede abrir librtjack.so ni librtpa.so. Vamos con la primera.

Reviso dependencias de la librería librtjack.so con ldd.

ldd /usr/local/lib/csound/plugins/librtjack.so
linux-gate.so.1 => (0xffffe000)
libsndfile.so.1 => /usr/lib/libsndfile.so.1 (0xb7f64000)
* libjack-0.80.0.so.0 => not found
libasound.so.2 => /usr/lib/libasound.so.2 (0xb7eaf000)
libpthread.so.0 => /lib/tls/i686/cmov/libpthread.so.0 (0xb7e9d000)
libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0xb7d6d000)
libFLAC.so.7 => /usr/lib/libFLAC.so.7 (0xb7d2f000)
libm.so.6 => /lib/tls/i686/cmov/libm.so.6 (0xb7d0d000)
libdl.so.2 => /lib/tls/i686/cmov/libdl.so.2 (0xb7d0a000)
/lib/ld-linux.so.2 (0x80000000)

Dice que no encuentra libjack-0.80.0.so.0

busco:

ls /usr/lib/libjack*

y encuetro una versión posterior, la 0.100.0.so.0, hago un elance simbólico:

ln -s /usr/lib/libjack-0.100.0.so.0 /usr/lib/libjack-0.80.0.so.0

vamos con la otra dependencia incumplida, era la librería librtpa.so:

ldd /usr/local/lib/csound/plugins/librtpa.so
linux-gate.so.1 => (0xffffe000)
libsndfile.so.1 => /usr/lib/libsndfile.so.1 (0xb7efa000)
libportaudio.so.2 => not found
libjack-0.80.0.so.0 => /usr/lib/libjack-0.80.0.so.0 (0xb7ee3000)
libasound.so.2 => /usr/lib/libasound.so.2 (0xb7e2e000)
libpthread.so.0 => /lib/tls/i686/cmov/libpthread.so.0 (0xb7e1b000)
libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0xb7cec000)
libFLAC.so.7 => /usr/lib/libFLAC.so.7 (0xb7cae000)
libm.so.6 => /lib/tls/i686/cmov/libm.so.6 (0xb7c8c000)
libdl.so.2 => /lib/tls/i686/cmov/libdl.so.2 (0xb7c89000)
/lib/ld-linux.so.2 (0x80000000)

Dice que no encuentra libportaudio.so.2. En este caso la versión de libportaudio que tengo es inferior, así que tengo que instalar una posterior.

http://www.portaudio.com/

Bajo la última versión estable, descomprimo, y
se instala con

./configure
make
sudo install

Busco la librería recien instalada con
sudo updatedb && locate libportaudio

y la encuentro la en /usr/local/lib, hago un enlace simbólico, para que esté en /usr/lib:

sudo ln -s /usr/local/lib/libportaudio.so.2.0.0 /usr/lib/libportaudio.so.2

y listo...ahora no da errores de dependencias.

VIM

Puedes añadir el coloreado de sintaxis csound, para vim.

en mi equipo estoy usando vim7.0, haciendo ls /usr/share/vim verás la o las versiones de vim que tienes instaladas. En lo siguiente tendrías que cambiar el directorio vim70 por el que tu tengas.

sudo su

cd /usr/share/vim/vim70/

mkdir templates

wget http://www.eumus.edu.uy/docentes/jure/csound/vim/csound.vim.tgz

tar zxvf csound.vim.tgz

exit

Ahora crea en tu carpeta de usuario un archivo llamado .vimrc, y copia en su interior esto:

au BufNewFile,BufRead *.orc,*.sco,*.csd so $VIMRUNTIME/syntax/csound.vim
au BufNewFile,BufRead *.csd so $VIMRUNTIME/macros/csound_macros.vim
au BufNewFile *.csd 0r $VIMRUNTIME/templates/template.csd
au BufNewFile *.orc 0r $VIMRUNTIME/templates/template.orc

syntax on

Ahora puedes crear y editar archivos csound fácilmente. Por ejemplo, si escribes vim prueba.csd, ya obtendrás el formato csd preparado para escribir, con las marcas colocadas. Además si pulsas F9, se compila lo que estés haciendo y escucharás el resultado.

Csound y jack

Como suelo trabajar sobre jack, creo el archivo .csoundrc en mi carpeta de usuario, de esa forma también me evito escribir siempre las mismas opciones para cargar csound mediante jack. En concreto añado esto:

-+rtaudio=jack --expression-opt -b 512 -B 2048 -odac:alsa_pcm:playback_ -d -m0

Pd: repositorios extra

2006-11-07T22:13:00.000Z

Una manera fácil de instalar algunos externals para pd es añadir a tu Debian/ubuntu, los repositorios de caedes.

sudo gedit /etc/apt/sources.list

(donde pone gedit, pon tu editor favorito). Añade esta línea.

#extrenals para pd
deb http://sindominio.net/~caedes/debian/ unstable main

Guarda y:

sudo apt-get update

Puedes ahora instalar:

pd-pdp 0.12.4 (compilado con soporte mmx)
pd-pidip 0.12.20
pd-gem2pdp 0.5
pd-osc ?
pd-3dp-caedes (una versión con un objeto rectangle)
pd-unauthorized 22-11-2003 (el resto de los externals de degoyon)
pd-pdp-freeframe
freeframe-petesvfx

Pd: Secuenciar eventos con tabla (paso 1.11)

2006-11-07T16:38:00.000Z

Una utilidad con una tabla es utilizarla como un disparador de eventos en secuencia, o un secuenciador. Mira el siguiente montaje:

Al definir el array, he indicado 10 puntos, y la forma de dibujar también en puntos. Ajusta los valores del eje y (vertical) como quieras. Lo que ves en el ejemplo anterior, es un sistema que lee los valores que hay almacenados en la tabla, secuencialmente. Y cuando llega al final, comienza de nuevo.

El objeto que lee es [tabread], pero lo que tiene enchufado arriba es un contador, que ya debes reconocer, y la operación módulo 10. El por qué funciona generando números de 0 a 9 y vuelta a empezar, está en esa propiedad de la operación módulo [%].

Pulsa bang repetidamente para ver cómo lee los datos. Prueba a alterar los datos con el ratón. Finalmente prueba a colocar un [metro] que sustituya al bang, para que la lectura se haga ordenada en el tiempo.

Pd: Tabla de ondas (paso 3.4)

2006-11-03T16:26:00.000Z

Muy relacionado con el paso anterior está el uso de una tabla para dibujar una onda o suma de ellas. Esta tabla o dibujo sirve para producir un sonido, leyendo un número de veces por segundo lo que hay en ella. Por ejemplo, si en una tabla dibujamos el periódo de una onda seno, al utilizar esta técnica podríamos desarrollar una onda senoidal leyendo repetídamente ese periodo un número de veces por segundo.

En pure data existe el objento [tabosc4~], que a diferencia de [osc~] toma la forma de onda que tiene que reproducir, de una tabla (array). En el siguiente ejemplo se usa [tabosc4~] para generar una onda constituida por una suma de senos.

pulsa el mensaje sinesum antes de nada

Se escribe [tabosc4~ array1], ya que indicamos que se va a usar array1 como fuente de datos. Una distintión de tabosc4~ respecto a osc~ es que aquel, necesita un valor en forma de señal sonora para indicar la frecuencia a la que leerá la tabla, y no un número como el caso de [osc]. Para eso sirve [sig~] convierte un valor númerico en un flujo "sonoro" o para decirlo con propiedad en una señal digital.

Para generar la onda que ves dibujada, le puedes enviar un mensaje a array1, como ves en la parte de abajo "array1 sinesum 512 .." (512 indica el número de puntos que se usarán para dibujar la onda). Debes entonces enviar este mensaje antes de nada, si quieres escuchar algo.

MUY IMPORTANTE: por la forma en la que se usa la tabla en la memoria para generar sonido, el número de puntos debe ser una potencia de 2. Cuanto mayor sea el nivel de detalle del dibujo, y por tanto mayor precisión para altas frecuencias, debes usar un número de puntos mayor. Sin embargo, al usar tabosc4~, introduce puntos que no están en la tabla (interpola) para suavizarla, en este caso es más eficiente usar una tabla de una potencia de 2 más 3 (interpola 4 puntos entre cada 2). 515 sería el número que deberíamos usar para mayor eficiencia, en el ejemplo anterior.

En este ejemplo, se usa la abstracción output~ que venimos utilizando en estas notas, en la parte de audio.

Podemos ahora retocar el ejemplo anterior, para que sea más instructivo. Veremos cómo cambia el dibujo según damos amplitud a los distintos parciales.

Simplemente se ha añadido $1, $2, $3, $4 a los valores de la amplitud de cada seno (mira abajo). Eso significa que tomará el valor, de los valores primero, segundo, tercero y cuarto respectivamente de un mensaje que le llege por el inlet. Para construir ese mensaje cambiante en tiempo real aplicamos un [pack f f f f] a cuatro números. De esta forma, alteras las cajas de números, entre 0 y 1, y verás inmediatamente lo que ocurre en el dibujo. Para que sea cómodo, cambié las propiedades de las cajas de números para que sólo se muevan en el rango 0-1, además interactúo con ellas pulsando "mayúsculas".

El bang que hay encima de [pack] simplemente permite que cuando cambio alguna entrada "fría", le llegue un bang también al inlet caliente, haciendo que [pack] envíe su valor.

Enseguida las ondas sobrepasan el recuadro de dibujo, que por defecto dibuja valores entre -1 y 1. Esto no tiene porqué saturar la señas porque puedes ajustar el nivel de decibelios en la salida. De cualquier forma si quieres ver el dibujo encajonado siempre entre -1 y 1, puedes aplicarle normalización. Enviándole al objento array, "normalize 1" ocurre eso justamente. Este es un ejemplo de envío de dos mensajes, añadiendo la normalización:

aunque podrías escribir también dos mensajes independientes.

El proceso de variar la tabla almacenada en memoria directamente, en tiempo real mientras se ejecuta el sonido, es instructivo, pero no práctico, pues como oirás se producen pops que ensucian el sonido.

Por último, prueba a pintar con el ratón directamente sobre la tabla de ondas...

conferencias arte/net

2006-11-02T23:09:00.000Z

Interesantes conferencias:

http://openserver.cccb.org/opserver/archivos/12opradio.php

OPEN CONTENT / FREE SOFTWARE
Florian Cramer
Contra la propietización de los ceros y los unos. El contenido digital sigue el mismo camino que el software, que pasó de ser gratuito en los años 70 a convertirse en un producto de propiedad desde 1980. El sistema operativo Linux es tal vez el ejemplo más poderoso que ha desarrollado el movimiento de software gratuito, aunque recientemente el concepto de "open content" se ha extendido y ha sido aplicado a otra clase de información digital. En esta conferencia se hará un repaso de la historia, filosofía y práctica del "open content" y el software gratuito o código abierto y se presentarán proyectos y modelos de licencias, apuntando los riesgos y problemas que conllevan.

LITERATURA & CÓDIGO (CODE POETRY)
Florian Cramer
En los últimos años, y no accidentalmente, el más estimulante net art ha tenido un foco especial en el código informático y de alguna manera ha revelado similitudes estéticas con la poesía concreta y otras literaturas experimentales. Florian Cramer intenta encontrar las relaciones entre literatura y código con la voluntad de esclarecer los puntos en común entre el texto con vocación poética y el texto con vocación informática.

ELECTRONIC MUSIC RE-SOURCES
Ekkehard Ehlers
Ekkehard Ehlers, uno de los artistas alemanes más prolíficos y polifacéticos del ámbito de la música electrónica, es profesor de música y arte digitales en la Escuela Superior de Arte de Saarbrücken y de la Merz Akademie de Stuttgart. Ehlers habla de las más recientes evoluciones en el ámbito de la música electrónica. El objetivo de esta actividad es discutir, a través de numerosos ejemplos sonoros y versiones musicales, las posibilidades y perspectivas de la producción digital.

etc...

De umbral en umbral

2006-11-02T22:48:00.000Z

Grabado de Escher

Habla
pero no separes el no de sí.
Y da a tu decir sentido:
dale sombra
(Paul Celán)

¿Hay un lugar más allá del sí o no?

Pd: Creación de una tabla (paso 1.10)

2006-11-02T18:49:00.000Z

En el menú put--> array, puedes acceder a un objeto muy interesante. Es una tabla o matriz de datos. Crea el siguiente montaje:

La tabla, el rectángulo de la derecha, se crea donde hemos dicho put--> array. Tiene parámetros de configuración que debes conocer (ya sabes botón derecho y propiedades). Al hacer esto último aparecen dos ventanas: canvas y array. En canvas por ejemplo puedes configurar los valores que puede tomar la tabla de izquierda a derecha (x range), y de arriba a abajo (y range). También, en el panel array configuramos el nombre (name) de la tabla, que por defecto será array1. También el número de puntos que tendrá la tabla. Estos datos debes conocerlos para usarla bien. Desde el panel array eliges también si la visualización de la talba será por puntos, polígonos o líneas continuas.

En el ejemplo aterior, se usa una tabla llamada array1, y con 100 puntos. El rango x va de 0 a 99 por tanto, y el rango y de -1 hasta 1. Con el objeto [tabread nonmbredetabla] puedes leer los valores almacenados en la tabla. El número que recible [tabread] por su único intlet es la posición x que queremos leer; este objeto nos devuelve el y correspondiente. Podemos así almacenar una colección de datos que luego usaremos para enviarlo a algún objeto.

Si en modo interactivo (control+e desde el modo edición) pasas el ratón por la línea dibujada en la tabla, verás que este cambia. Justo entonces puedes clicar y dibujar directamente datos.

Ves abajo un mensaje que indica "array1 sinesum ...". Este mensaje se envía directamente a la tabla, y dibuja en ella una suma de senos. Aunque ahora no lo veremos es muy útil para la síntesis sonora. Lo pongo como ejemplo de mensaje enviado directamente a la tabla.

Prueba con este otro montaje:

Es parecido al anterior, de hecho el mismo, pero he añadido dos posibilidades muy interesantes. La parte de abajo, a la izquierda, permite guardar los datos de la tabla en un archivo. Al hacer bang sobre [savepanel] se habre una ventana para elegir directorio y archivo, donde serán guardados los datos. El mensaje de abajo a la derecha, guarda los datos de la tabla en un archivo de texto, cuya dirección indicamos.

Si pulsas botón derecho sobre tabread y luego help, obtendrás algunos datos de interés. Además en 2.control.examples/array.pd hay más datos sobre este tema. De cualquier manera, es más útil y aprendiendo posibilidades según vayas analizando los montajes que veas.

Fluidsynth/Qsynth

2006-10-31T15:17:00.000Z

Fluidsynth es un sintetizador de sonido para soundfonts. Permite cargar en memoria una fuente de sonidos soundfont y usarla en tiempo real. Para instalar:

sudo apt-get install fluidsynth

Puedes conseguir muchos soundfonts aquí:

http://www.saunalahti.fi/kru99/links-to-SF-sites.htm

Una vez tienes los soundfonts, el rendimiento de uno muy grande depende del equipo que tengas. En los siguientes ejemplos voy a suponer que el soundfont que usas se llama gmsfull.sf2

fluidsynth tienes muchas opciones de carga. Esta sería un lanzamiento sencillo:

fluidsynth -a alsa -R no -C no gmsfull.sf2 unmidi.mid

Oirás el fichero unmidi.mid tocado con la fuente gmsfull.sf2. "-R no" indica sin reverb y "-C no" sin chorus que los activa por defecto. -a elige la arquitectura de sonido a usar, que en este caso será alsa.

Cuando ejecutas la línea anterior, entras en un entorno en modo texto que tiene ciertas opciones (escribe help). Para salir de ese entorno escribe quit, y pulsa intro.

Podemos usar fluidsynth como un servidor midi, al que conectamos otros programas y/o clientes. Desde el terminal puedes hacerlo usando aconnect (ver ejemplo de aconnect). De esta forma es sencillo conectar por ejemplo un teclado externo para tocar con fluidsynth, o conectar rosegarden con este sintetizador. O muy interesante para conectarlo a pure data.

Tambien podemos lanzar fluidsynth mediante jack con la opción -j en el comando de carga. De esta forma, y usando qjackctl por ejemplo es fácil hacer conexiones, visualmente, entre este y otros programas.

QSYNTH

qsynth es una interfaz gráfica para fluidsynth. Para instalarlo

sudo apt-get install qsynth

Puedes lanzarlo como

qsynth -a alsa

En el botón "Setup..." hay opciones de configuración, como por ejemplo, pulsando en la pestaña soundfonts, puedes cargar uno o varios soundfonts.

qsynth -j

lo carga mediante jack

Midi con alsa (acconect)

2006-10-30T18:37:00.000Z

Empieza abriendo un terminal y escribiendo:

aconnect -io

Te dará una lista de los dispositivos (clientes) de entrada y salida MIDI disponibles. Este podría ser un ejemplo:

cliente 0: 'System' [tipo=kernel]
0 'Timer '
1 'Announce '
cliente 14: 'Midi Through' [tipo=kernel]
0 'Midi Through Port-0'
cliente 16: 'SBLive! Platinum [CT4760P]' [tipo=kernel]
0 'EMU10K1 MPU-401 (UART)'
cliente 17: 'Emu10k1 WaveTable' [tipo=kernel]
0 'Emu10k1 Port 0 '
1 'Emu10k1 Port 1 '
2 'Emu10k1 Port 2 '
3 'Emu10k1 Port 3 '

Puedes usar como parámetro de aconnect -i, o también -o para ver por separado entradas y salidas. Cada cliente tiene un número, y uno o varios puertos. Por ejemplo el cliente 16, que es "SBLive! Platinum [CT4760P]", tiene un sólo puerto 0 'EMU10K1 MPU-401 (UART)', esto es un teclado o controlador externo externo. Se usa el formato cliente:puerto como verás más abajo, entonces el controlador externo es 16:0

Ejemplo 1

Conectar el teclado virtual vkeybd y zynaddsubfx

Como primer ejercicio, voy a necesitar por ejemplo los paquetes vkeybd (virtual keyboard) y zynaddsubfx (un sintetizador muy completo). Si aun no los tienes instalados:

sudo apt-get install vkeybd zynaddsubfx

Lo que vamos a hacer es conectar el teclado virtual al sintetizador zynaddsubfx. En realidad este último ya tiene su propio teclado visual, pero imagina que no lo tuviera.

Lanzo los dos programas:

zynaddsubfx & vkeybd &

Ahora si ejecuto aconnect -io obtengo:

cliente 0: 'System' [tipo=kernel]
0 'Timer '
1 'Announce '
cliente 14: 'Midi Through' [tipo=kernel]
0 'Midi Through Port-0'
cliente 16: 'SBLive! Platinum [CT4760P]' [tipo=kernel]
0 'EMU10K1 MPU-401 (UART)'
cliente 17: 'Emu10k1 WaveTable' [tipo=kernel]
0 'Emu10k1 Port 0 '
1 'Emu10k1 Port 1 '
2 'Emu10k1 Port 2 '
3 'Emu10k1 Port 3 '
cliente 128: 'ZynAddSubFX' [tipo=usuario]
0 'ZynAddSubFX '
cliente 129: 'Virtual Keyboard' [tipo=usuario]
0 'Virtual Keyboard'

Tengo en la lista los nuevos programas como clientes para hacer conexiones entre ellos. Mira los números que aparecen en cada cliente. Para conectar el teclado al sintetizador escribo:

aconnect 129:0 128:0

Ahora están conectados, puedes comprobarlo tocando den el virtual keyboard y viendo como suena el zynaddsubfx. Si quieres ver las conexiones puedes usar el siguiente comando

aconnect -lio

'l' lista las conexiones, en este caso dice:

cliente 128: 'ZynAddSubFX' [tipo=usuario]
0 'ZynAddSubFX '
Conectado desde: 129:0
cliente 129: 'Virtual Keyboard' [tipo=usuario]
0 'Virtual Keyboard'
Conectando con: 128:0

Para desconectar lo que has hecho con

aconnect -d 129:0 128:0

o desconectarlo todo

aconnect -x

Ejemplo 2

Instala el paquete pmidi

sudo apt-get install pmidi

Es un player de midi para alsa. Lanzamos por ejemplo el mismo sintetizador zynaddsubfx con

zynaddsubfx &

Puedes usar el comando

pmidi -p cliente:puerto archivitomidi.mid

donde cliente:puerto lo sustituyes por los números que te da el listado acconect -lio como hacíamos en el ejemplo anterior.

pmidi -p 128:0 mozart.mid

tocará el archivo mozart.mid mediante el zynaddsubfx.

Ejemplo 3

En este ejemplo conectaremos rosegarden a un sintetizador de soundfonts usando aconnect. Dicho sintetizador será fluidsynth (mira aquí para saber lanzarlo).

Lanzo ambos programas:

rosegarden & fluidsynth -a alsa -R no -G no Chorium.SF2

Miro la lista de conexiones abriendo otro terminal:

aconnect -lio
cliente 0: 'System' [tipo=kernel]
0 'Timer '
1 'Announce '
Conectando con: 15:0, 129:0
cliente 14: 'Midi Through' [tipo=kernel]
0 'Midi Through Port-0'
cliente 16: 'SBLive! Platinum [CT4760P]' [tipo=kernel]
0 'EMU10K1 MPU-401 (UART)'
Conectado desde: 129:8
cliente 17: 'Emu10k1 WaveTable' [tipo=kernel]
0 'Emu10k1 Port 0 '
Conectado desde: 129:4
1 'Emu10k1 Port 1 '
Conectado desde: 129:5
2 'Emu10k1 Port 2 '
Conectado desde: 129:6
3 'Emu10k1 Port 3 '
Conectado desde: 129:7
cliente 128: 'FLUID Synth (7414)' [tipo=usuario]
0 'Synth input port (7414:0)'
Conectado desde: 129:3
cliente 129: 'rosegarden' [tipo=usuario]
0 'record in '
Conectado desde: 0:1
1 'sync out '
2 'external controller'
3 'out 1 - General MIDI Device'
Conectando con: 128:0
4 'out 2 - MIDI soundcard synth'
Conectando con: 17:0
5 'out 3 - MIDI soundcard synth 2'
Conectando con: 17:1
6 'out 4 - MIDI soundcard synth 3'
Conectando con: 17:2
7 'out 5 - MIDI soundcard synth 4'
Conectando con: 17:3
8 'out 6 - MIDI external device'
Conectando con: 16:0
9 'out 7 - MIDI output system device'

Conectaré el puerto 3 de rosegarden (out 1 -General MIDI Device), con el único puerto de entrada que aparece en fluidsynth.

aconnect 129:3 128:0

Entonces oiremos los eventos MIDI generados por rosegarden mediante el soundfont que cargamos en fluidsynth.

aconnectgui

Una vez entiendes cómo va aconnect, puedes usar también aconnectgui, que es lo mismo pero con una sencilla interfaz gráfica. Se instala con

sudo apt-get install aconnectgui

Al lanzarlo verás una lista con los dispositivos midi disponibles. Pulsando en el botón de los conectores midi, y cliqueando en un dispositivo y arrastrando hasta otro, se creará la conexión:

naconnect

http://nedko.arnaudov.name/soft/naconnect/

Esta utilidad utiliza la consola, pero es muy intuitiva. Baja el archivo tar.bz2. Descomprímelo con
tar xvfj nombredearchivo
entra en la carpeta recien creada y escribe

make

No tendrás que hacer nada más, excepto poner el ejecutable aconnect en algún lugar cómodo para tí. Un buen sítio puede ser /usr/local/bin, así podrás acceder siempre que quieras lanzándolo con

naconnect

La forma de funcionamiento se parece a acconectgui, pero esta vez se usan teclas. Para salir, pulsa q

Pd: Adición de osciladores (paso 3.3)

2006-10-30T11:01:00.000Z

Inspirada en el resultado matemático conocido como teorema de Fourier, la síntesis aditiva trata de generar sonidos complejos apartiendo de la adición de ondas sencillas y con efectos predecibles. En Pure data es sencillo sumar una serie de ondas simples generadas con [osc~].

En el ejemplo siguiente

Un oscilador simple tiene control de la frecuencia y de la amplitud. Para controlar la amplitud el deslizador vertical envía su valor a l1 (esto se configura pulsando botón derecho sobre el deslizador, luego propiedades, y escribiendo l1 en la casilla send-symbol). Además sólo toma valores entre 0 y 1. De esta forma podemos controlar la amplitud del oscilador desde el deslizador. Podíamos haberlo conectado simplemente con un cable, como ya sabrás.

La salida, usa la abstracción output~. Mira el paso anterior para ver cómo se activa.

Partiendo de este modelo, es fácil hacerlo crecer, para crear una serie de osciladores sumados antes de enviarlos a la salida. En el ejemplo siguiente se hace eso. Pero todas las frecuencias dependen de la fundamental, a la que vamos multiplicando por 2, 3, 4 y 5. En otras palabras, generamos una onda fundamental y sus cinco primeros armónicos. La amplitud de cada armónico, se controla con los deslizadores, que envía respectivamente l1, l2, l3, l4 y l5, además toman valores entre 0 y 1.

En los cálculos internos de pure data, la amplitud puede tener "cualquier valor", pero como sabes la salida debe ser una señal digital con valores entre -1 y 1, entonces es probable que al sumar varias ondas se produzca saturación (lo valores mayores que 1 se dejan como 1). Ten cuidado al ir subiendo los decibélios. Llegará un punto en que ya no percibas el sonido correctamente sino distorsionado, en ese punto empieza la saturación.

Pd: Conectar sin cables (paso 1.9)

2006-10-29T18:26:00.000Z

Cuando más compliquemos los montajes más conexiones habrá, y más cables. Pero esto puede solucionarse, además de que necesitamos alguna forma de enviar datos entre objetos que quizás no están ni en la misma ventana. Hay dos básicos muy útiles:

[send ]
[receive ]

Por ejemplo:

La caja de números envía su valor a "aaa", un símbolo abstracto, que puede ser captado desde otro lugar. [receive aaa] lee el valor que se envió a aaa. Puedes verlo también como crear un cable virtual llamado aaa, que no se ve. Observa cómo al cambiar la primera caja de números se cambia la otra, como si efectívamente estuvieran conectadas. Send y receive, pueden abreviarse como s y r respectivamente.

Observa también los dos mensajes que pueden enviar directamente datos a "aaa". Esta forma de enviar mensajes directamente a un objeto, aun si conexión visible, la encontrarás muchas veces. Es posible incluso enviar datos al propio programa pure data.

También hay objetos, como los sliders o los number, number2, etc, que envían y reciben datos mediante un símbolo. Por ejemplo, en las propiedades de un slider, puedes configurar que envíe su valor al símbolo que hemos llamado "aaa", o el que tu eligieras:

Pd: Trigger (paso 1.8)

2006-10-29T18:08:00.000Z

A veces, es conveniente saber en el orden en que se procesan una serie de operaciones, o bien quiere sincronizarse estas con un bang que ponga en marcha otro artefacto. Para eso existe [trigger], que toma la única entrada que tiene y la convierte al tipo de salida múltiple que deseemos. Por ejemplo [trigger float float] tomará una entrada numérica y la sacará por dos salidas numéricas (primero procesa la de la derecha y luego la de la izquierda). Para que lo veas en un ejemplo concreto:

En este caso se ha usado [trigger bang float float] La entrada numérica se convierte en un bang (b) y en dos salidas numéricas (f). El orden en que las procesa es de derecha a izquierda, entonces lo último en procesar es el bang.

En este otro ejemplo

se empaqueta en un mensaje las dos salidas del trigger, pero el concepto es similar al anterior. Más información sobre trigger puedes encontrarla pulsando sobre el objento y con el botón derecho del ratón elegir : help. Obtendrás una figura como esta:

Observa cómo distintas entradas producen salidas de muchos tipos, pero siempre procesadas de derecha a izquierda, es decir, se deja la salida caliente para el final. También fíjate en las siglas:

[t f b l s a]

que es una forma abreviada de escribir:

[trigger float bang list symbol anything]

o, número, bang, lista, símbolo, cualquier cosa.

Mira aquí, para ver una más aplicación concreta.

Pd: amplitud (paso 3.2)

2006-10-27T11:49:00.000+01:00

Pure data incorpora algunos objetos y trucos para manejar la amplitud del un oscilador. Veremos algunas de ellas.

Crea este montaje

Se inicializa un oscilador (coseno) con el valor 440 Hz. Para controlar la amplitud multiplicamos la señal con un valor entre 0 y 1, con [*~]. Sin embargo sería útil poder introducir ese valor en decibélios. Para eso se usa el objeto [dbtorms]. Un acrónimo de "decibélio a rms", aunque debería llamarse "decibélio a amplitud lineal", pues es lo que hace. Convierte un valor en decibelios en su correspondiente de amplitud de la onda sinusoidal. De manera que 0 corresponde con 0, y 100 db sería 1.

También puede usarse un flujo de datos para controlar la amplitud, pudiendo variar progresívamente la amplitud entre un valor y otro. Sabes que el objeto que hace eso en pd es [line], aunque aquí usamos su versión de flujo sonoro [line~].

Se lanzan mensajes sobre [line~] que contienen el valor a alcanzar y el tiempo en milisegundos para conseguirlo. Esta es una manera sencilla de crear envolventes lineales.

Es posible también, usar una abstracción que incluyen muchos ejemplos que obtienes cuando instalas pd. Para poder acceder a ella, debes indicarle a pure data, que busque abstracciones y objetos en un sitio determinado. Para ello ve a File-->Path... de la ventana general de Pd. Añade en una de las casillas:

/usr/lib/pd/doc/3.audio.examples/

que es donde estará la abstracción que buscamos (output~). Luego pulsa en "save all settings", aplicas y sales. Cuando abras un proyecto nuevo, si creas un objeto nuevo con el nombre [output~], debería aparece un pequeño panel, como el de la figura de más abajo. Si no aparece, tal vez no esté, o esté mal la dirección. Compruébalo escribiendo en un terminal:

sudo updatedb && locate output~

Y te dirá dónde está output~.pd .El siguiente ejemplo usa dicha abstracción que hemos instalado.

Como ves puedes controlar los decibelios de la salida, así como silenciarla repentinamente con "mute".

Pd: Un oscilador (paso 3.1)

2006-10-26T19:02:00.000+01:00

En pure data, se trata el sonido como un flujo de datos también, pero puesto que es un flujo con muchos requerimientos (a 44100Hz, son ese mismo número de datos por segundo). Entonces pd interactúa diréctamente con el hardware de la máquina, aunque el lenguaje sigue siendo el de objentos y cables. Para distinguir los objetos que producen sonido, se utiliza el símbolo ~, en el nombre. Por ejemplo [+ 1] sumará una unidad a todo lo que llegue por el inlet caliente. Sin embargo [+~ 1] funciona con sonido.

Crea el siguiente montaje:

Lo primero, fíjate en los dos mensajes de la derecha. Son mensajes enviados directamente al programa pd. Activan y desactivan respectivamente el sistema de sonido. El mismo efecto podrías conseguirlo desde el menú "Media", y luego audio on o aundio off.

El objento [osc~] es en realidad un generador de la función coseno para sonido. Por tanto, producirá un "tono puro", cuya frecuencia se indica como primer parámetro de inicialización, aunque también puedes cambiarla desde el inlet caliente como en este caso. La salida del coseno varía entre -1 y 1, y es enviada al objeto [dac~], que expresa el "conversor digital-analógico". En otras palabras, a tu tarjeta de sonido. [dac~] admite también valores entre -1 y 1. Por tanto todo valor que supere 1, será truncado. En este caso multiplicamos la señal por 0.5 (atención a *~, no es simplemente *).

Fíjate que los cables por los que circula sonido, son ligeramente más gruesos.

En este segundo ejemplo, encontramos casi lo mismo:

Sólo cambia la manera de alterar los parámetros. Los deslizadores envían su valor a la "variable" frec y amp, que son recogidas y canalizadas a los sitios correspondientes. En concreto, por ejemplo, se ha configurado el deslizador que controla la frecuencia (botón derecho sobre él y propiedades):

output-range: botton-> 100 top-> 1000 (pon lo que quieras)
send-symbol: frec
name: frec (pon lo que quieras)
cambia los colores, etc..

Pd: Ejemplo resumen (paso 4.5)

2006-10-26T12:02:00.000+01:00

pulsa para agrandar

En este ejemplo, se introduce una animación en tiempo real, en el que una esfera rota alrededor de otra. Las texturas están sacadas de aquí:
http://maps.jpl.nasa.gov/

Más que interés científico, que este ejemplo no tiene, se muestra lo sencillo que es crear una animación interactiva 3D, una vez conoces los rudimentos del lenguaje.

En este otro ejemplo:

pulsa para agrandar

Se aplica una fórmula sencilla para simular un oscilador, visualmente (una esfera). El número que obtenemos del contador, lo podemos considerar grados. Entonces pasamos a radianes, dividiendo entre 360 y multiplicando por 2pi. Finalmente se hace el seno. La salida enviada a "distancia", controlará el parámetro de la distancia al origen de una pequeña esfera.

El deslizador vertial recibe también en valor de "distancia" (botón derecho->propiedades->receive-symbol), por tanto no tienes siquiera que activar gemwin para ver el efecto.

Pd: Luz (paso 4.4)

2006-10-26T11:16:00.000+01:00

Crea este montaje:

Verás dos nuevos mensajes sobre [gemwin], lighting 0 o 1, desactiva o activa la luz 3D en la escena. En concreto ves un nuevo objento [world-light] que es precísamente un punto de luz (no visible) en el infinito, es decir que todos los rayos son paralelos. Es una luz distinta a un foco.

Sobre la esfela [sphere] se aplican varias transformaciónes. Una es [color], que a diferencia de [colorRGB] funciona enviando un mensaje con un vector que contiene los valores de rojo (R), verde (G), y azul (B). Otra transformación interactiva es [rotate], en cuyas entradas conectas el valor del ángulo de rotación, y un vector que indica el eje que gira, en este caso es eje y.

Por último sphere, con un valor variable del número de líneas guía que la forman. Cámbialo para ver el efecto.

Pd: Acordes y trigger (paso 2.2)

2006-10-25T16:56:00.000+01:00

Una manera sencilla de crear un acorde con eventos midi es así:

El primer outlet de [notein] produce el valor de "nota MIDI". Le sumamos la cantidad necesaria del un intervalo de 3ª mayor (4 semitonos), otro de 5 justa (7 semitonos), y oiremos un acorde mayor con funamental, la nota que toquemos en el teclado.

El mismo montaje se puede elaborar de la siguiente manera, pudiento elegir entre el tipo de acorde que queremos oir:

Atención al uso de unpack, que "desempaqueta" los mensajes que definen cada acorde en dos valores independientes, que luego simplemente se suman al de la nota que tocamos. Gracias a los objentos [send] (s) y [receive] (r) podemos organizar en bloques el programa general.

Sin embargo, aunque oigamos un acorde, las notas se producen secuencialmente, ya que en pure data los distintos hilos o cables que salen de un objento se suelen procesar por orden de creación. Si queremos un acorde formados por tres notas realmente sincronizadas, podemos echar mano de [trigger]. En el siguiente ejemplo se usa trigger para sincronizar las tres notas.

Además un deslizador, que tiene cambiado su recorrido de 0 a 1 (en propiedades), servirá para cambiar el volumen de las notas generadas.

Pd: Textura sencilla (paso 4.3)

2006-10-25T11:53:00.000+01:00

A los objetos de dibujo (sphere, cube, square, circle,...) que vamos viendo, le puedes enviar mensajes según quieras que sean dibujados:

draw line
draw point
draw fill

según quieras respectivamente, que se dibujen linealmente, con puntos o con relleno de un color.

También se pueden aplicar texturas sobre los objetos de dibujo. En el siguiente ejemplo se aplica como textura de un cubo, una foto jpg.

Se envía el mensaje "open dirección" sobre el objeto [pix_image]. El siguiente objeto [pix_texture] toma la imagen y la mapea sobre el objeto dibujado, un cubo, en este caso.

La textura aplicada también podría ser un video grabado, o recibiéndose en tiempo real desde una cámara.

Pd: transformaciones gráficas (paso 4.2)

2006-10-24T10:22:00.000+01:00

En la línea que une [gemhead] con un objeto gráfico, añadimos las transformaciones necesarias para conseguir el efecto que queramos. En el siguiente ejemplo, se ponen algunas transformaciones básicas.

Empezando desde arriba, inmediatamente después de [gemhead] viene la transformación del color [colorRGB] en cuyos cuatro últimos inlets (entradas) se controla el valor de rojo, el verde, el azul, y el valor alpha o transparencia.

Para que la transparencia tenga efecto, añadimos el objento [alpha].

Luego viene una rotación, mediante el objeto [rotateXYZ]. Lo que se rotan son los ejes x,y o z, sobre los que se dibuja el objento. Observa el efecto sobre la marcha.

Finalmente una translación, usando [translateXYZ]. De nuevo, se translada el objento a lo largo de los ejes. Los límites de la pantalla, están determinados, por su tamaño y por la posición de la cámara que recoge la escena. Estos parámetros pueden cambiarse en forma de mensajes sobre [gemwin]. En este caso, te podrás mover alrededor de 3 unidades sobre x o y, antes de perder el objeto.

La transformación que falta en el ejemplo anterior, y que por supuesto es posible realizar en pd, es [scaleXYZ] que como imaginarás escala los valores de los distintos ejes, o dicho de otra manera, los estira o encoge.

En esta ocasión los mensajes 1 y 0 sobre [gemwin] los he sustituido por un interruptor:toggle.

Pd: empaquetar, desempaquetar (paso 1.7)

2006-10-23T21:22:00.000+01:00

Un mensaje puedes estar compuesto de varios símbolos, o de varios números, o una combinación de estos con aquellos. Hay una manera de definir qué tipo de mensaje estamos usando. Por ejemplo sin en un mensaje escribimos "float 43.45", estamos creando una mensaje con un valor en coma flotante, a saber, 43.35. Podríamos sin embargo referirnos a "43.45" como símbolo, como lo sería "casa" o "tumismo". En ese caso podríamos indicar dentro del mensaje "symbol 43.45". También podemos abreviar "float" con "f", y "symbol" con "s". Esto es algo así como la declaración de mensajes, parecida a la declaración de variables en otros lenguajes.

Existe un objento que empaquete mensajes sencillos en uno en forma de lista. De igual manera existe otro objento que permite desempaquetar mensajes complejos en sencillos. Mira el siguiente montaje:

Pack se encarga de empaquetar en un sólo mensaje esos tres mensajes independientes. Fíjate que después de pack indicamos de qué tipo son los componentes. "f f s" significa "float float symbol", de forma abreviada. A la derecha vemos el trabajo de [unpack], que como ya imaginarás desempaqueta. El uso es muy sencillo como ves, prueba a jugar con la sección de paquetería.

Por poner un ejemplo de uso sencillo de pack, vamos a presentar una tabla de datos, que indica el tiempo, lo que recorre y cuerpo y su velocidad. Estas tres magnitudes están relacionadas en física con la expresión:

espacio= velocidad*tiempo

para el movimiento uniforme. Una posible expresión en pure data, podría ser esta:

Un contador, que hará la función de cronómetro, va haciendo incrementarse el valor del tiempo de 0.1 en 0.1 unidades. A esa secuencia la multiplicamos por el valor velocidad, y obtenemos el espacio recorrido. Presentamos los datos en un sólo mensaje compuesto, usando pack.

Ejemplo de suma de vectores

Una operación típica en matemática es la suma de dos vectores, o más fácil aun, dada dos tríadas de números como (a,b,c) y (x,y,z) -suponiendo que a,b,c,x,y,z son números- se define la suma de las tríadas o vectores como una nueva tríada, en la que hemos sumado el primer componente con el primer componente, el segundo, con el segundo, etc. Así la suma vectorial de las dos tríadas anteriores es

(a+x, b+y, c+z)

¿Cómo expresamos eso en pure data?, con pack y unpack es fácil. Esta es una solución.

he usado los vectores (1, 0, 1) y (0, 1 , 0) , para que sea muy previsible lo que debe salir, es decir (1, 1, 1). Prueba a colocar otros vectores de entrada.

Corazón ártico

2006-10-22T00:43:00.000+01:00

"Pero debes aprender una cosa, imprimirla en tu mente todavía maleable: el hombre tiene horror a la soledad. Y de todas las espécies de soledad, la soledad moral es la más terrible. Los primeros ermitaños vivían con Dios. Habitaban en el más poblado de los mundos: el mundo de los espíritus. El primer pensamiento del hombre, sea un leproso o un prisionero, un pecador o un inválido, es este: tener un compañero en su desgracia" (Los sufrimientos del inventor, Balzac)

Poco que decir, allá donde vayamos, habrá dioses y diablos, habrá vacío, perdición y nirvana. ¿Acaso puedes ir a algún sitio donde no estés, estando vivo?

Pd: Un círculo (paso 4.1)

2006-10-21T22:58:00.000+01:00

Una vez has entrado en pd, y se ha cargado correctamente Gem, verás que en la ventana principal de pd, aparece:

GEM: Graphics Environment for Multimedia
GEM: ver: 0.90
GEM: compiled: Jul 5 2006
GEM: maintained by IOhannes m zmoelnig
GEM: Authors : Mark Danks (original version on irix/windows)
GEM: Chris Clepper (macOS-X)
GEM: Daniel Heckenberg (windows)
GEM: James Tittle (macOS-X)
GEM: IOhannes m zmoelnig (linux/windows)

Ese es el signo que indica que puedes usar GEM. Abre un proyecto en blanco y añadiremos un objeto llamado [gemwin]. Este objeto se encarga de configurar y crear una ventana en la que se desarrollarán los gráficos, así como el proceso de renderizado en tiempo real. El control de [gemwin], se hace enviándole mensajes. Esta podría ser una situación sencilla:

Para crear o destruir una ventana usamos respectivamente los mensajes "create" y "destroy". Puedes comprobarlo pulsando uno u otro. El proceso de renderizado se activa con 1 o 0. Esto es muy importante, pues si no lo activas no verás nada. También tienes que tener en cuenta que si no paras el proceso de renderizado, aunque cierres un proyectos (sin cerrar pd), sigue funcionando entonces podrías ver cómo se te mezclan dos proyectos distintos que abriste sucesivamente.

En este caso, el mensaje dimen determina qué tamaño tendrá la pantalla de gráficos, entonces es un mensaje para enviar antes de que se cree la ventana. Si miras en la ayuda, verás que hay muchos mensajes de configuración para [gemwim].

Ya sabes crear la ventana gráfica, ahora hace falta dibujar algo. Al lado de lo anterior, añade esto:

El objeto [gemhead] (cabecera de objeto) crea las configuración básica para renderizar un objeto, además envía la señar de renderizado al objeto que se conecte en su salida. La situación más simple, es conectar la salida de [gemhead] directamente a un objeto, como en este caso es [circle] (un círculo), sin embargo, a menudo se interpondrán otros objetos, que lo que harán serán tranformar la información básica que envía [gemhead]. En este caso, damos color.

En cuanto al color dado, puesto que [color] recibe mensajes por su inlet frío en forma de triadas, estamos enviando el color 1 0 0. Que en el lenguaje RGB -Red-Gren-Blue-, significa valor 1 al rojo y 0 al verde y azul. Prueba a hacer combinaciones entre los tres colores básicos, eligiendo un valor entre 0 y 1 para cada color.

El círculo es inicializado con el valor de radio 1, aunque podríamos conectar un mensaje o caja de números en su segundo inlet, para variarlo en tiempo real.

El proyecto completo quedó así:

Intenta cambiar el color y hacer variable el radio del círculo

Pd: GEM (paso 4)

2006-10-21T22:33:00.000+01:00

El GEM, o "Entorno gráfico multimedia", permite añadir a Pure Data trabajo con gráficos, video y renderizado de objetos 3d con opengl. Se integra en el lenguaje de objentos y mensajes interconectados.

Para cargar la librería GEM, hay que indicarlo en la línea de comandos que lanza pure data. Algo así:

pd -lib Gem

Cuidado con la G mayúscula. Cuando instalas Gem, incorpora documentación y ejemplos muy útiles para aprender. De cualquier forma, se presupone que conoces ya algo del manejos de Pure Data en general, para poder entrar en faena con los gráficos.

Pd: notein, noteout (paso 2.1)

2006-10-20T21:54:00.000+01:00

Para instalar lo referente a la instalación de qjackctl mira aquí. Para empezar con linux voy a lanzar qjackctl, zynaddsubfx y vkeybd.

-qjackctl hará de panel de conexiones
-zynaddsubfx de módulo MIDI para escuchar las notas
-vkeybd de teclado MIDI. Si tienes un teclado midi externo será parecido.

Lanzo los tres programas (primero qjackctl), y final mente pd. En el panel de conexiones, hago esto:

En la pestaña MIDI encontramos lo anterior. Conecto la salida de MIDI de pure data con Zynaddsubfx, y la salida de vkeybd (virtual keyboard) con la puredata. Si tuviera un teclado MIDI externo conectaría este a Pure Data.

En el menú media de Pure Data, hay que indicar jack, y alsa-midi.

Abro un trabajo nuevo. Escribimos esto:

Al pulsar sobre el teclado, deberías oir a zynaddsubfx sonando. El objento [notein] lee los mensajes de nota que entren por donde hayamos indicado, en este caso vienen de vkeybd. Los tres outlet de [notein] son, de izquierda a derecha:

-Nota, en formato MIDI, un número entero, de manera que el 60 es el do central de un piano, 61, el siguiente semitono, etc...
-"Volumen", o parámetro velocity MIDI, es un entero de 0 a 127. El valor 0 es silencio, o nota apagada.
- Canal, un número de 1 a 16 que indica el canal MIDI.

Estos tres datos son idénticos en [noteout], sólo que esta vez se envían a la salida que hayamos indicado; en este caso el sintetizador zynaddsubfx.

Crea ahora esto:

Es posible crear notas midi desde dentro del programa pure data. [makenote] hace ese trabajo. Los dos parámetros que en este caso lo acompañan, son respectivamente, el parámetro velócity, y la duración de la nota en milisegundos. Entonces, la nota anterior durará 200 milisegundos.

Por último construye este montaje:

En este caso se generan números aleatorios entre 0 y 11, uno cada medio segundo. El valor se suma a 60, entonces en valores de notas MIDI, estamos generando notas entre do4 y do5. Finalmente se crea la nota con velocity 100 y 200 milisegundos de duración.

Pd: Índice

2006-10-20T13:45:00.001+01:00

Notas sobre Pure Data:

ÍNDICE

PASO 0

PASO 1

PASO 2 - MIDI

PASO 3 - Audio

PASO 4 - Gem

PASO 5 - PDP

MÁS EXTERNALS

Pd: Flujos (paso 1.6)

2006-10-18T11:56:00.000+01:00

Cuando se interactúa con una caja de números, arrastrando el ratón, se producen una secuencia de datos, podríamos decir un chorro de cambios, que afectarán al objeto al que esté conectada la caja. De igual manera al crear un objento [metro] creamos una secuencia de bangs ordenada en el tiempo. Hay otros objentos para generar datos en secuencias, uno de ellos es [line]

En el anterior montaje, vemos cómo al pulsar el mensaje de la izquierda, obtendremos una secuencia de números que van de 0 a 1000 en un segundo (1000 milisegundos). Pulsando el mensaje de la derecha volvemos a 0 en medio segundo (500 milisegundos). Añade lo siguiente:

[pipe 1000], actua como un delay o retraso respecto a los datos que recibe, de manera que espera 1 segundo en este caso, para permitir "pasar" lo que venga por la entrada. El poder manejar flujos de datos, es lo que hace de pure data, bueno para generara, grabar, editar en tiempo real streams (flujos). Añadiendo los conocidos deslizadores es más visual lo que estamos diciendo (cambia el ouput-range de los deslizadores para que sea entre 0 y 1000):

Prueba ahora con este montaje

El deslizador de la izquierda se mueve a la vista, continuamente, mientras que el de la derecha va a saltos. Por defecto [line] envía valor distinto cada 25 milisegundos, sin embargo ese número puede alterarse cuando creas el objento line. Añadiendo dos parámetros, hacemos tal cosa: el primero indica el valor inicial de line (por defecto 0), el segundo cada cuánto tiempo enviará un valor (lo denominado "grain rate"). En el anterior ejemplo la tasa (rate) es 500 milisegundos o medio segundo.

Por último montaremos esto:

intenta averiguar lo que hace [pack float float]

Pd: metrónomo y más (paso 1.5)

2006-10-15T18:53:00.000+01:00

Nota: para entender este post correctamente se sugiere conocer la operación matemática "módulo", es decir, el resto de dividir un número entre otro. "2 módulo 2", es 0, mientras que "3 módulo 2" es 1. De manera que n módulo 2, donde n es cualquier número natural es siempre 0 o 1. Esta operación es útil para hacer ritmos y ciclos.

Una vez conoces un montaje en pure data puedes usarlo para completarlo, adaptarlo, o conectarlo con otros, esto es similar a otros lenguajes. Recordando el contador

Se le podrían añadir un par de cosas como esta:

Ahora es un contador pero con algunas opciones extra, como contar en sentido creciente o decreciente, o elegir el número de partida. Se trata de aprender a adaptarlo a tus necesidades de la manera más efectiva. Otra aplicación sencilla de un contador es por ejemplo construir un metrónomo (por ahora) visual. Para eso, antes voy a presentar un par de cosas nuevas.

Una es [select]. Permite seleccionar entre distintas salidas según sea la entrada, por ejemplo:

Si la entrada es 0, imprimirá "sí", si es 1, imprimirá "no", si es trés imprime "no sé", y si no es ninguna de esta, devuelve el número de entrada por la última salida. No es el único objeto para seleccionar o routear flujos de datos, pero este es sencillo de aprender.

Otra cosa que aprenderemos no es extrictamente necesaria de ver ahora, pero ayuda a ordenar la ideas. Sabes construir un contador, y por qué no aislarlo como cicuito independiente, y usarlo como un objeto llamado [contador] ?. Eso siempre puede hacerse: las abstracciones. Es como lo que en otros lenguajes de programación se hace con las funciones. Podemos crear un objeto nuevo con sus entradas y salidas. Para ello, crea un objento, y escribe en el: pd contador. Elegimos contador como nombre. Si haces click sobre él, se abrirá otra ventana. Pues es en esa ventana donde crearás el montaje para ese objento. ¿Y cómo crear las entradas y salidas para manejarlo?. Muy fácil, colocarás cajas con el nombre inlet colocadas de izquierda a derecha, esas, serán las entradas, y para las salidas es igual pero escribiendo outlet. En la ventana que se abrió al escribir pd contador, podrías escribir esto:

Por tanto ya puedes usar el nuevo objento creado por tí, con su entrada y salida, por ejemplo así:

Ya estás en condiciones de entender este montaje (suponiendo que comprendas módulo, que en pd se escribe %)

Al encender el interruptor, comienza a funcionar el contador, a la vez que se envía 4 a la operación módulo. Se hace el "n módulo 4" con los números que salen de contador, es decir que irán tomando valores 0, 1, 2, 3, 0, 1, 2, 3,...Es justo el resto de dividir ese número entre 4. Finalmente se usa un select para hacer funcionar distintos bangs.

Añadiendo el siguiente montaje, además se puede seleccionar el número de pulsos por minutos, tal y como hacen los metrónomos musicales.

Un paso más y adornaríamos más el engendro, añadiendo tempos clásicos: allegretto, resto, etc, con mensajes. Esto te lo dejo a tí, contingente lector.

Pd: Metro (paso 1.4)

2006-10-15T00:48:00.000+01:00

Sin más crea el siguiente montaje

Cuando pulsas en el bang de la izquierda, se produce en la salida standard (en la ventana principal de pd) el símbolo: bang. Cuando pulsas en el bang de la derecha, verás una secuencia de bang. El número que acompaña a [metro] es el número de milisegundos entre un bang y otro, por tanto, 1000 ms, son 1 segundo. Como imaginarás, puedes ajustar este número en la segunda entrada.

Por poner un ejemplo con metro, el siguiente programa genera números aleatorios random, uno cada medio segundo, con rango entre 0 y 9. Además podemos ajustar la velocidad de producción de números:

Metro es un objeto muy importante, porque sirve para sincronizar la computación de algo con una pulsación constante. Por ejemplo, podría producirse la captura de una imágen de la cámara cada pocos milisegundos, o enviar un mensaje de control midi cada cierto intervalo de tiempo, o marcar el ritmo a la que se realiza un proceso de computación. [metro] es un metrónomo. Por otra parte[random] genera un número (pseudo)aleatorio entre 0 y n-1. Es decir que [random 100] generará números "al azar" entre 0 y 99.

Un objeto básico muy útil para usar con procesos como metro, es el interruptor toggle (lo encuentras en el menú 'Put'). Este es el mismo ejemplo anterior, pero con un interruptor, prueba el efecto.

El interruptor toggle, envía un 1 cuando está activo, y un 0 cuando se despulsa.

El siguiente ejemplo, envía una carta de amor cada 2 segundos, si toggle está pulsado claro:

Cada 2000 milisegundos se imprime el mensaje. Como curiosidad, mira cómo set se puede "interceptar" y cambiar el contenido de un mensaje.

Pero esto no está ligado a metro, metro es un simple generador de eventos sincronizados. Podríamos asociarlo en el contador del tema anterior, para crear una secuencia temporal ordenada.

Avanza un número cada segundo. Intenta hacer que avance 2 unidades cada medio segundo.

Pd: Deslizar y Contar (paso 1.3)

2006-10-14T20:48:00.000+01:00

Pure data tiene un número básico de objetos que hay que conocer, luego, al instalar más librerías, aumenta el número de cosas interconectables, aunque siempre en el lenguaje de cajas con entradas y salidas, entrada caliente y frías, etc. El siguiente objeto es bastante gráfico, en realidad dos, el deslizador horizontal y vertical: hslider y vslider. Los encuentras en el menú 'Put'.

Coloca un deslizador vertical, y a su alrededor, un bang, tres mensajes, con los valores respectivamente 1000, 4 y 60, y un objeto número, o como le hemos llamado, una caja de números. Todo esto lo conectas a la entrada (la parte superior), mientras que a la salida puedes conectar otra caja de números para visualizar, y un print -investiga siempre otras posibilidades. La cosa queda así:

Al pulsar los mensajes, verás que cambian el deslizador, aunque al enviarle 1000, este toma el valor máximo que por defecto es 127. Mira cómo, al arrastrar el ratón desde la caja de números el deslizador se mueve continuamente. Efectivamente, también puedes operar directamente en el deslizador. Es un entorno muy expresivo como ves.

Observa que si envías un bang al deslizador, este devuelve el valor que tiene. Además, como cosa general para las cajas de números, si quieres un movimiento más fino, es decir que en vez de unidad a unidad, avance mediante decimales, pulsa MAYÚSCULA y mantenlo pulsado mientra interactuas. Si en vez esto, pulsas CONTROL el deslizador volverá a su valor 0.

Pulsando el botón derecho, y en propierties (y esto vale para varios objetos básicos) puedes cambiar tanto el valor máximo y mínimo de los deslizadores (en output-range), como el color y tamaño. El comportamiento del deslizador horizontal es el mismo.

Hablando de configuración visual, el objeto básico Number2, que puedes encontrar en el menú 'Put' es igual que Number pero más evolucionado, ya que puedes cambiar el color, la fuente, añadir una etiqueta etc. Eso será importante para desarrollar interfaces amigables y/o claras.

*Un contador

Más cosas. Vamos a introducir un objeto nuevo. Crea uno, y escribe en su interior float. El objeto [float], guarda el número que reciba por una de sus entradas, y cuando recibe un bang por la entrada caliente, lo devuelve. Pruebalo en este montaje

Float, que también puedes resumir escribiendo una f, tiene varios usos. Vamos a ver uno útil. La idea es hacer un artefacto que cuente: un contador. Realiza la siguiente disposición:

Añade estas conexiones:

La idea es que al hacer bang la salida de [float], es enviada a la suma, añadiendo su valor en 1, y este incremento es guardado en float. La próxima vez que se hace bang, se devuelve dicho valor, reenviándolo también a la suma...así sucesivamente. El resultado es un contador, un artefacto que cuenta de 1 en 1.

Una versión ligeramente más completa, añade la posibilidad de resetear el contador, e incluso, determinar en qué número se incrementará el contador en cada paso. Algo así:

Como salida estoy usando un Number2, para que quede más bonito, aunque obviamente esto no influye en el resultado numérico. Añádiendo un deslizador, para observar el progreso visualmente, la cosa queda así:

Pd: Mates básicas (paso 1.2)

2006-10-13T22:00:00.000+01:00

Para conocer algo más el juego, vamos a hacer unas cuantas operaciones matemáticas; la base de toda programación. Crea un objeto, y escribe en el: + 2. Luego añade encima un mensajes que contenga por ejemplo un 5, y debajo una caja de números. La cosa debe quedar así:

Conecta, la salida del mensaje con la entrada (rayitas superiores) de la izquierda. A menudo a esta entrada de la izquierda, se le llama entrada caliente, mientra que la o las otras son frías.

Cuando el mensaje llega al objeto suma, procede a realizar la suma de lo que le viene, y el resultado se recoge en la cája de números.

Añade ahora otro mensaje y conéctalo a la "entrada caliente" de la suma, borra el '+ 2' dejando sólo +. Prueba a jugar con eso. Por último crea este montaje:

Recuerda que la caja de números es como un rectángulo sin una esquina, mientras que el mensaje es como una caja a la que le han dado un muerdo a la derecha, o una especie de banderín. Recuerda también, que las cajas de números cambian su valor conforme arrastras el ratón, habiendo pulsado previamente sobre ellas.

Observa que cualquier cambio que ocurra en la entrada caliente (izquierda) del objeto suma, se refleja instantaneamente en la salida, pero no ocurre lo mismo con la entrada fría (derecha). En realidad, la entrada fría, sirve para alacenar un número que se usa para realizar la operación con lo que "vaya pasando" en la entrada "caliente". También fíjate en que un bang sobre el objento suma, da como resultado, el valor de la última operación que se hizo.

Finalmente añadir, que si pulsas con el botón derecho del ratón sobre el objeto suma, y seleccionas 'Help', obtendrás una pequeña explicación (en inglés) sobre operaciones básicas matemáticas.

RecordMyDesktop

2006-10-13T17:46:00.000+01:00

Había probado istanbul, y xvidcap, para capturar lo que estás haciendo en la pantalla, pero ninguno de ellos me convencía mucho. Recientemente he oído hablar de recordmydesktop

http://recordmydesktop.sourceforge.net/

En el caso de ubuntu, para compilarlo necesitarás algunas dependencias. Escribo una línea que las instalaría todas:

sudo apt-get install libasound-dev libxext-dev libxfixes-dev libxdamage-dev libogg-dev libvorbis-dev libtheora-dev libjack0.100.0-dev

Una vez bajado el archivo:

tar zxvf recordmydesktop-x.x.x.tar.gz
cd recordmydesktop
./configure
make
sudo install

Y ya está. Un vídeo de ejemplo lo tienes aquí:

http://recordmydesktop.sourceforge.net/videos/elive-unstable_beta-3.1_20060807.ogg

Lanzas el programa con líneas del tipo:

recordmydesktop -width 500 -height 400 -fps 15 --nosound -o aua.ogg

captura una pantalla de ancho 500 y alto 400, a 15 fotogramas por segundo, sin sonido, en un archivo llamado aua.ogg

Obtienes más opciónes con

recordmydesktop --help

en la misma web se puede bajar gtk-recordmydesktop, un entorno gráfico que usa de fondo el este mismo programa. Para instalarlo he tenido que añadir dos paquetes más:

sudo aptitude install automake python-gtk2-dev
(el paquete python-gtk2-dev da problemas en algunas distribuciones)

Se baja el programa desde la web, y se sigue el mismo proceso que con el anterior. En este lanza con:

gtk-recordmydesktop

creando un incono en la zona de notificación. Con el botón derecho del ratón sobre él, puedes seleccionar visualmente el trozo de pantalla que vas a capturar, o abrir un pequeño panel de control con todas las opciones:

Pd: Cosas y cables (paso 1)

2006-10-12T19:01:00.000+01:00

Lanza Pure Data, desde un terminal, escribiendo:

pd

Empezamos directamente, abriendo un nuevo trabajo en File-->New. Se abrirá una ventana en blanco con varios menús. Échale un vistazo al menú "Put". Incluso puedes pulsar en la línea discontínua de la parte superior, convirtiendo el menú en una ventana. Las cuatro primeras opciones son:

Objeto Mensaje Número Símbolo Comentario
(todo esto en inglés)

También se indica con qué teclas podemos acceder a las mismas opciones. CONTROL+x donde x son los números del 1 al 5.

Pulsa en mensaje, y verás un símbolo como este

En el interior escribimos: Hola. Creamos otro mensaje, pero esta vez escribimos: adios. Crearemos también un objeto (Put-->Object), y en su interior escribimos: print saludo. Debes ver esto en la pantalla:

El objeto print, imprimirá en la salida standar-en este caso será seguramente la pantalla que se abrió al lanzar pd- lo que se le envíe, y lo etiquetará con el nombre que aparece después de print. Pero para eso tenemos que conectar los mensajes con el objeto print. Lleva el ratón hacia la rayita inferior del mensaje hola, y cuando veas un círculo, sin soltar, arrastra, hasta la rayita superior del objeto print. Luego haz lo mismo para conectar el mensaje 'adios' al objeto print. La cosa queda así:

Por defecto estamos en el modo edición, para activar la interacción con el circuito que estamos creando, puedes pulsar CONTROL+e, o bien ve al menú edit y pulsa 'edit mode'. Pulsando sucesivamente sobre control+e puedes cambiar entre el modo de edición y el modo interactivo.

Al pulsar sobre uno de los mensajes, se envía su contenido al objeto print, y este lo imprime. Las rayitas que hemos usado como conexión, son conocidos como inlets o outlets según estén respectivamente arriba o abajo. La entrada de datos ocurre por arriba y la salida por abajo, así de fácil.

Los mensajes, como ves tiene posiblidad de entrada. Para utilizarla vamos a usar un objeto predefinido llamado 'bang' (menú put-->bang). Coloca dos bang, uno encima de cada mensaje, y conecta la única salida de cada bang, con el mensaje que tiene debajo. Sal del modo edición (CONTROL+e) y verás como los botones bang, activan a su vez los mensajes, que al ser enviados al objeto print, se imprimen.

Añade ahora una caja de números (put-->number). Conecta la única salida que tiene al objeto print. Al salir del modo edición, puedes cambiar el número que que contiene la 'caja de números', pulsando sobre ella con el ratón y arrastrando arriba o abajo. Observa cómo el objento print va respondiendo a cada número que recibe. La caja de números envía su valor cada vez que es cambiada. La cosa queda así (fíjate que ahora cambié 'saludo' por 'imprimo', esto no es relevante, sólo cuestión de forma):

Prueba a ponerle un bang a la caja de números. Si quieres guardar el resultado, tal y como lo harías en otros programas: File --> Save as...

Pure Data (paso 0)

2006-10-10T21:11:00.000+01:00

Pure Data (o Pd) es un lenguaje de programación gráfica desarrollado por Miller Puckette durante los años 90 para la creación de música computerizada interactiva y obras de multimedia. Aunque Puckette es el principal autor del software, Pd es un proyecto de código abierto y tiene una gran base de desarroladores trabajando en nuevas extensiones al programa.
http://es.wikipedia.org/wiki/Pure_data

INSTALAR DESDE LOS REPOSITORIOS DE UBUNTU/DEBIAN

Cómo instalar Pure Data de forma sencilla con gnu/linux. Lo explico para Ubuntu Linux/Debian etch, así que supongo que será parecido en otras distros.

En los repositorios de Ubuntu/Debian se puede encontrar pure data. No es la última versión, pero te servirá para dar los primeros pasos. Es tan fácil como escribir en el terminal (Aplicaciones->accesorios->terminal):

apt-get install puredata gem pd-pdp pd-zexy

El programa lo lanzas con

pd

o si quieres cargar alguna librería, como por ejemplo Gem, usa:

pd -lib Gem

si usas jack

pd -rt -jack -alsamidi

Si quisieras añadir siempre la misma línea de carga, por ejemplo, siempre escribes pd -lib Gem, puedes crear una archivo .pdrc en tu carpeta de usuario que contenga los parámetros de carga, en este caso: -lib Gem. Haciendo esto, sólo necesitas escribir pd.

hay otras maneras más detalladas de instalarlo, o más adecuadas podríamos decir (más completas). Por ahora intenta esta. Desde el propio programa, también es posible ajustar la configuración.

INSTALAR PUREDATA EXTENDED 0.39

(actualizado)
Pure data extendido es el programa base junto con un montón de externals y librerías que aumentan notablemente las posibilidades del programa. Para ello necesitaremos bajar el paquete correspondiente desde aquí:

http://puredata.info/downloads

NOTA: elige en función de tu distribución.

Tendremos entonces en alguna parte el paquete deb ya descargado. Por ejemplo para Ubuntu gusty, tendremos el archivo:

Pd-0.39.3-extended-debian-testing-i386.deb

Desde un terminal, nos movemos hasta donde esté dicho archivo (seguramente el escritorio):

cd ~/Desktop

y lo instalamos

sudo dpkg -i Pd-*.deb

Probablemente dará "errores" de dependencias que no están instaladas. Para resolverlo hacemos

sudo apt-get -f install

lo cual bajará las dependencias que necesitamos. Con esto debe estar instalado pd-extended.

INSTALAR COMPILANDO LAS FUENTES PARA 0.4

Aquí hay una guía detallada:
http://puredata.org/docs/developer/Debian

Intro

2006-10-09T21:47:00.000+01:00

No puedes escapar, el oggro está dentro, eres tú.