Clase 1 Introducción y Sintaxis

s.boot;

http://www.audiosynth.com/
http://supercollider.sourceforge.net/
http://cmm.cenart.gob.mx/tallerdeaudio

INTRODUCCIÓN:
¿Que es SuperCollider?
- Un editor de texto: escribimos líneas de código que contienen instrucciones para sintetizar sonidos y manipularlos. Este código es guardado como texto. El editor no sólo contiene las funciones típicas de cualquier procesador de textos básico, como copiar, pegar, buscar y remplazar; sino que también tiene otras funciones que son muy útiles al programar y compilar.
- Un lenguaje de programación: orientado a objetos, basado en el lenguaje SmallTalk.
- Es software open source, es gratuito y construido por la comunidad.
- Es muy portable.
- Es un lenguaje interpretado para sintesis de audio.

Primeros pasos

Cuando arrancamos el programa aparece una ventana con información, conocida como Post Window. En ésta se imprimirá información útil, como los mensajes de error o los resultados de nuestros códigos.

La primera información que vemos es el resultado de la inicialización del programa y de la compilación de su librería.

Necesitamos saber algunas cosas antes de comenzar

1.para correr lineas de código:
Usa enter, no return (MacOSX)
ctrl Return (Windows)
ctrl E (Linux-gedit)

2. Antes de crear cualquier sonido debemos de prender alguno de los dos servidores.

3. para detener el sonido
command + punto [manzana + .] (MacOSX)
alt + punto (Windows)
esc (Linux-gedit)

4. Para la Ayuda seleccionamos y tecleamos
command + D [manzana + D] (MacOSX)
F1 (Windows)
ctrl U (Linux-gedit)

//evalua las siguientes líneas, una por una

1 + 1

2 * 2

5 / 2

2**2

2 ** 3

1<2

0.0323>0.2

"hola"=="ola"

===================================================================

Para poder producir sonido necesitamos prender un servidor. Tenemos dos distintos servidores predefinidos: interno y local.

El servidor interno corre en el mismo proceso que la aplicación SuperCollider, es interno al programa y por esto mismo tiene ciertas ventajas, producto de la mayor comunicación entre los dos.

El local corre en la misma máquina que la aplicación SuperCollider, pero es un programa diferente, 'scsynth'. La ventaja de usarlo es que en caso de que el servidor se caiga, la aplicación seguirá corriendo y viceversa.

También es posible crear más servidores y que estos estén en distintas computadoras, comunicadas vía internet o ethernet.

Sólo es necesario prender el servidor una vez por sesión. Hay dos formas de hacerlo, a través de las ventanas que los representan (abajo a la izquierda) o prográmaticamente.

s=Server.local
s.boot
s.quit

s=Server.internal
s.boot
s.quit

===============================================================

UGENS

Los 'UGens (Unit Generators)' son objetos que producen algún tipo se señal(SinOsc, Pulse, Saw, LFTri). Al conectar varios de ellos creamos lo que se conoce como 'patch'.

Sus nombres siempre empiezan con mayúscula y pueden ser de dos tipos:

- Audio Rate (.ar)

Los UGens que reciben el mensaje .ar corren a velocidad de audio: 44100 samples por segundo.

Hay que mandar el mensaje .ar a los UGens cuando sean parte de la cadena de audio que será escuchada.

- Control Rate (.kr)

Los UGens que reciben el mensaje .kr corren a velocidad de control. Producen un sample por cada 64 samples hechos por un UGen a velocidad de audio. Es por esto que los UGens de control son más baratos, computacionalmente hablando, que sus contrapartes a velocidad de audio.

Los UGens de control los usamos como moduladores, esto es, como señales que le dan forma a una señal de audio.

----------------------------------------------------------------

s=Server.local
s.boot

{   }.play es la forma más simple para generar sonido, muy útil para probar  código rápidamente, pero no muy conveniente para la construcción de piezas

{   }.play // se usa para el servidor local
{   }.scope // se usa para el servidor internal

Veamos los siguientes osciladores básicos:

Todos los oscliadores comprenden una serie de argumentos ordenados que representan los parametros que indican el comportamieto del mismo.
En otras palabras es el medio por el cual le puedes comunicar al ugen lo que quieres que haga.
Los argumetos básicos de practicamente todo oscilador son:
frecuencia (es decir la altura de una nota),fase (que por el momento la dejaremos en 0) amplitud (el volumen de una nota),
Estos argumetnos son generales para todos los ugen aunque existen ugen con argumetno exclusivos

{SinOsc.ar(700,0,0.1)!2}.play //senoide
{Pulse.ar(700,0.2,0.1)!2}.scope //cuadrada
{Saw.ar(700,0.1)!2}.scope //diente de sierra
{LFTri.ar(700,0,0.3)!2}.scope//triangular

Osciladores:

SinOsc: Un oscilador de onda senoidal

Funciona con .ar y con .kr. Sus argumentos son freqcuencia, fase, mul y add. Su sintaxis es como sigue:

SinOsc.ar(frecuencia, fase, mul, add)

frecuencia: Ciclos por segundo o Hertz. Una frecuancia alta nos dara una frecuencia aguda. Una frecuencia baja nos dará una nota grave. El rango auditivo del ser humano es de 20Hz a 20KHz. El default es 440 que es la nota La índice 5.
fase: Punto del ciclo en el que queremos que inicie el oscilador. Se especifíca en radianes y su rango es de 0 a 2pi. El default es 0 que es el inicio del ciclo.

mul : Número por el cual multiplicamos la señal del oscilador. Generalmente se identifica con el
volumen o amplitud del sonido siendo 0 el mínimo y 1 el máximo recomendado. El default es
1 dejando la señal sin alterar.

add : Número que se le suma a la señal del oscilador. Observar que a la señal se le aplica primero el mul y luego el add. El default es 0 dejando la señal sin alterar.

Ejemplos:

{SinOsc.ar}.play /* El SinOsc con los argumentos de default o sea frecuencia=440, fase=0, mul=1, add=0. */
{SinOsc.ar(100)}.play /*Con una frecuencia grave. Si no tienes audífonos o bocinas de buena calidad no la vas a oír por que las bocinas de la computadoras no pueden hacer sonar frecuencias graves*/
{SinOsc.ar(300,0,0.5)}.play // Una frecuencia media, con un volumen (mul) medio.
{SinOsc.ar(3000,0,0.1)}.play // Una frecuencia aguda con un volumen bajo.
{SinOsc.ar(13000,0,0.9)}.play // Una frecuencia muy agudacon un volumen alto.

Pulse: Un oscilador de onda cuadrada

Funciona solo con .ar. Sus argumentos son freqcuencia, ancho de banda, mul y add. Su sintaxis es como sigue:

Pulse.ar(frecuencia, ancho de banda, mul, add)

frecuencia : Ciclos por segundo o Hertz. El default es de 440.
ancho de banda : El ancho del valle de la onda (la parte de abajo o el periodo de apagado). El rango esta comprendido por el intervalo abierto (0,1) o por un número mayor que cero y
menor que uno. El default es 0.5. Al cambiar este argumento estamos cambiando el
tímbre de la señal.
mul: Número por el cual multiplicamos la señal del oscilador. Generalmente se identifica con el
volumen o amplitud del sonido siendo 0 el mínimo y 1 el máximo recomendado. El default es
1 dejando la señal sin alterar.

add : Número que se le suma a la señal del oscilador. Observar que a la señal se le aplica primero el mul y luego el add. El default es 0 dejando la señal sin alterar.

Ejemplos:

{Pulse.ar}.play // El Pulse con los argumentos de default.
{Pulse.ar(100)}.play /* Con la frecuencia grave. En este caso si se oye en las bocinas de la computadora por la característica del tímbre que es rico en armónicos que son frecuencias más agudas. */
{Pulse.ar(100,MouseX.kr(0.1,1))}.scope /* La misma frecuencia pero con un ancho de pulso menor. Observar cómo cambia el timbre pero la nota sigue siendo la misma */
{Pulse.ar(100,0.9,0.1)}.play /* La misma frecuencia pero con el ancho de pulso mayor. La amplitud baja. Nótese que el timbre no varía ya que el ancho de pulso es simétrico con su eje de simetría en 0.5 de tal modo que 0.1=0.9, 0.2=0.8, 0.7=0.3, etc. */


LFTri: Un oscilador de onda triangular

Funciona con .ar y .kr. Sus argumentos son freqcuencia, mul y add. Su sintaxis es como sigue:

LFTri.ar(freqcuencia, fase, mul, add)

frecuencia : Ciclos por segundo o Hertz. El default es de 440.
mul : Número por el cual multiplicamos la señal del oscilador. Generalmente se identifica con el
volumen o amplitud del sonido siendo      0 el mínimo y 1 el máximo recomendado. El default es
1 dejando la señal sin alterar.

add : Número que se le suma a la señal del oscilador. Observar que a la señal se le aplica primero el mul y luego el add. El default es 0 dejando la señal sin alterar.
     
     
Ejemplos:

{LFTri.ar}.play // El Pulse con los argumentos de default.
{LFTri.ar(150)}.scope /* Con la frecuencia grave. En este caso si se oye en las bocinas de la computadora por la característica del tímbre que es rico en armónicos que son frecuencias más agudas. */
{LFTri.ar(1000,0.1)}.play // Con la frecuencia aguda y poca amplitud.

Saw    Un oscilador de onda de sierra.

Funciona solo con .ar. Sus argumentos son frecuencia, mul y add. Su sintaxis es como sigue:

Saw.ar(frecuencia, mul, add)

frecuencia: Ciclos por segundo o Hertz. El default es de 440.
mul : Número por el cual multiplicamos la señal del oscilador. Generalmente se identifica con el
volumen o amplitud del sonido siendo 0 el mínimo y 1 el máximo recomendado. El default es
1 dejando la señal sin alterar.

add : Número que se le suma a la señal del oscilador. Observar que a la señal se le aplica primero el mul y luego el add. El default es 0 dejando la señal sin alterar.

Ejemplos:

{Saw.ar}.play // El Saw con los argumentos de default.
{Saw.ar(350)}.scope /* Con la frecuencia grave. En este caso si se oye en las bocinas de la computadora por la característica del tímbre que es rico en armónicos que son frecuencias más agudas. */
{Saw.ar(10000,0.1)}.play // Con la frecuencia aguda y poca amplitud.


///////////////////////////
Ruidos

{WhiteNoise.ar(0.19)!2}.scope //señal aleatoria que contiene todas las frecuencias y todas ellas tienen la misma potencia.//
{PinkNoise.ar(0.9)!2}.scope //señal aleatoria que sus contenido de energia por frecuencia disminuye en 3 db por octava.
{BrownNoise.ar(0.8)!2}.scope //señal aleatoria que sus contenido de energia por frecuencia disminuye en 6 db por octava.
{Dust.ar(100)!2}.scope//generador de impulsos aleatorios



Abre el archivo from-SC2.rtf que se encuentra en el directorio supercollider/examples/from-SC2.rtf

//////////////////////////////////////////////////////

Ejercicios.

Vamos a ejercitar una de las técnicas más sencillas para crear nuevos timbres.
Esta técnica tiene como principio la uitlización de dos operadores básicos, estos son, la multiplicación y la suma.

Suma:

Al aplicar una suma entre dos osciladores obtenemos un nuevo timbre en donde se puede escuchar que las caracteristicas de los objetos que participan no pierden su "personalidad". Esta técnica tiene relación con lo que se da a conocer como sintesis aditiva.
Observar que las amplitudes de las señales se suman. Las suma de las amplitudes no deben de superar 1.0.

{SinOsc.ar(2000,0,0.2)+WhiteNoise.ar(0.1)!2}.play


{SinOsc.ar(2000,0,0.2)!2}.play

{WhiteNoise.ar(0.1)!2}.play


Multiplicación:

Al aplicar una multiplicacion entre dos osciladores obtenemos un timbre complejo que esta determinado por diferentes factores que analizaremos con el transcurso del taller. Esta técnica tiene relación con lo que se da a conocer como Amplitud Modulada y modulación de anillo

{SinOsc.ar(2000,0,0.7)*WhiteNoise.kr(0.8)!2}.scope

{WhiteNoise.ar(0.8)*SinOsc.kr(2000,0,0.7)!2}.play

{WhiteNoise.kr(0.8)*SinOsc.ar(2000,0,0.7)!2}.play


Completa los espacios en blanco.

/*1-*/{LFTri.ar(1360,0,0.6)*WhiteNoise.kr(3)}.scope
2-{-----.ar(60,0.5)*------.kr(780,0,0.34)}.scope
3-{-----.ar(----,0,0.5)*-----.kr(240,0,0.5,0.5)}.scope
4-{------.ar(0.3)*-------.kr(3,0,0.9)}.scope
5-{Pulse.ar(--,--,0.5)*----.kr(100,---)}.scope
6-{-----.ar(30,0.3)*--------.kr(0.6)}.scope
7-{LFTri.ar(30,0.1,0.3)*--------.kr(0.6)*------.kr(10,0,0.4,0.6)}.scope
8-{----.ar(302,0.3)*--------.kr(10.6,0,0.6)*------.kr(0.710)}.scope
9-{SinOsc.ar(----,0,0.5)*SinOsc.kr(----,0,0.5,0.5)}.scope
10-{----.ar(---,0.4)*WhiteNoise.kr(---)*----.ar(1200,0.4)*SinOsc.kr(---,0,0.6)}.scope
11-{(------.ar(---)*----.kr(0.2))+Saw.ar(---,0.041)}.scope
12-{(Pulse.ar(40,0.01,0.3)*-----.kr(---,0,0.4,0.5)*WhiteNoise.kr(---))+----.ar(---,0.4)}.scope
13-{((--------.ar(0.5)*Dust.kr(----))+PinkNoise.ar(---))*SinOsc.kr(----,0,0.4,0.5)}.scope
14-{Saw.ar(---,0.3)+Saw.ar(---,0.3)}.scope
15-{((Saw.ar(460,0.3)+Pulse.ar(462,---,0.3))*Dust.kr(---))+LFTri.ar(---,0.1,----)}.scope
16-{----.ar(14000,0,0.9)*Dust.kr(-----)}.scope
17-{----.ar(70,0,---)*Dust.kr(----)}.scope
18-{SinOsc.ar(-----,0,0.3)+-----.ar(----,0,0.3)+SinOsc.ar(----,0,0.2)+------.ar(50,0,0.7)}.scope
19-{LFTri.ar(---,0,0.5)*SinOsc.kr(----,0,0.7)}.scope
20-{-----.ar(130,0.2)+-----.ar(100,0,0.3)+-------.ar(0.031)}.scope

Descargar clase 1

Curso de Supercollider principiantes by Ernesto Romero, Ezequiel Netri is licensed under a Creative Commons Reconocimiento-NoComercial-CompartirIgual 3.0 Unported License.

Este trabajo está bajo licencia Creative Commons Attribution-Noncommercial-Share Alike 2.5 México License