Documentacion de los Instrumentos de RTCmix

Instrumentos de RTCmix

por R. Luke DuBois, plagiando juiciosamente Charles Dodge, Curtis Roads Paul Lansky, Perry Cook, Doug Scott, y, bien sûr, Brad Garton, Dave Topper, y Chris Bailey.

un par de notas:

las notas sobre la sintaxis de los instrumentos, especialmente para los makegens, no son de ninguna manera definitivas. Pruebe y experimente diversos tipos de gen. Todas las "partituras" (scores) se tomaron de la distribucion de Brad en el direcotrio /musr/cmix/insts.

Y tambien mi "afinidad"con el calculo es limitada (lease virtualmente inexistente), asi que alguna de estas ecuaciones es un poco "iffy" (en mi propia opinion) : ).

Es usada la sintaxis de comentario de C estandar, asi que usted puede copiar y pegar desde su navegador hacia una "partitura" (score) o archivo de C.

am/AM

AM toma un archivo de sonidos de entrada y modula su amplitud de acuerdo con un oscilador, el cual es definido por las tablas 1 (envolvente de amplitud) y la tabla 2 (forma de onda). La frecuencia de la modulacion esta determinada por el parametro 4 (p4) del comando AM(). La frecuencia de modulacion como la configuracion del oscilador cambiara la modulacion desde un ligero tremolo hasta un instrumento "completamente-soplado" o "completamente-artificial".

Syntaxis:

makegen(1, 24, 1000, t0, a0, t1, a1...) /* la envolvente de amplitud de la salida donde tn y an son un par tiempo/amplitud */
makegen(2, 10, 1000, p0, p1...) /* forma de onda del oscilador modulador donde pn es la amplitud de los armonicos sucesivos en el espectro */

AM(outskip, inskip, duration, amp, frequency, inchan, spread)

en forma comentario:


/* am -- modula una señal de entrada
*
*  p0 = salto de salida 
*  p1 = salto de entrada
*  p2 = duracion
*  p3 = amplitud
*  p4 = frecuencia (en hz) del modulador de Amplitud AM
*  p5 = canal de entrada [opcional]
*  p6 = posicion estereo <0-1> [opcional]
*  se asume que la tabla funcion 1 es la envolvente de amplitud
*  la tabla funcion 2 es la forma de onda del modulador AM
*
*/

Un ejemplo de "partitura":

rtsetparams(44100, 1)
rtinput("/sndh/bob.dole.mono")
makegen(1, 24, 1000, 0,0, 2,1, 5,1, 7,0)
makegen(2, 10, 1000, 1)
AM(0, 0, 7, 1, 14)
AM(8, 0, 7, 1, 187)

Otra partitura, que toma la entrada desde el ADC (convertidor Analogico Digital):

rtsetparams(44100, 1, 256)
rtinput("AUDIO")
makegen(1, 24, 1000, 0,0, 2,1, 5,1, 7,0)
makegen(2, 10, 1000, 1)
AM(0, 0, 7, 1, 14)
AM(8, 0, 7, 1, 187)

Una tercera "partitura", procesando una structura de bucle:

rtsetparams(44100, 2, 256)
rtinput("AUDIO", "MIC", 2)
makegen(1, 24, 1000, 0,0, 0.1,1, 0.2,1, 0.3,0)
makegen(2, 10, 1000, 1)

for(start = 0; start < 15.0; start = start + 0.1) {
        freq = random() * 400.0
        AM(start, 0, 0.3, 1, freq, 0, random())
        }

aminst/AMINST

modulacion de amplitud: tipo de modulacion donde una señal portadora ( o frecuencia f_c con una amplitud media a) es variada por una señal moduladora (de frecuencia f_m con un indice de modulacion I) formandose dos bandas laterales de frecuencias f_c ± f_m y de amplitud a-I/2. El resultado depende de la frecuancia moduladora: una frecuencia moduladora menor que 10Hz resultara como un efecto de tremolo basado en la amplitud de la señal moduladora. Si la modulante esta comprendida entre 10Hz y una frecuencia donde las bandas laterales continuan en la banda critica de la frecuencia central, el sonido tendra una amplitud proporcional a la amplitud media de la modulante. Para frecuencias mayores, las bandas laterales seran perceptibles. (adaptado del Dodge y Jerse, 1985).

Sintaxis:

makegen(1, 24, 1000, t0, a0, t1, a1...) /* envolvente de la amplitud de la portadora */
makegen(2, 24, 1000, t0, a0, t1, a1...) /* envolvente de la amplitud de la modulante */
makegen(3, 10, 1000, p0, p1...) /* espectro de la portadora */
makegen(4, 10, 1000, p0, p1...) /* espectro de la modulante */

AMINST(outskip, duration, amp, f_c, f_m, spread)

en forma comentario:


/* aminst -- sintesis de modulacion de amplitud
*
*  p0 = inicio
*  p1 = duracion
*  p2 = amplitud
*  p3 = frecuencia portadora (hz)
*  p4 = frecuencia modulante (hz)
*  p5 = posicion estereo <0-1> [opcional]
*  asume que la tabla funcion 1 es la envolvente de amplitud
*  asume que la tabla funcion 2 es la envolvente de modulacion
*  tabla funcion 3 es la forma de onda de la portadora
*  tabla funcion 4 es la forma de onda de la modulante
*
*/

Un ejemplo de "partitura":

rtsetparams(44100, 1)

makegen(1, 24, 1000, 0,0, 0.1,1, 3.4,1, 3.5,0)
makegen(2, 24, 1000, 0,0, 1,1, 2,0)
makegen(3, 10, 1000, 1)
makegen(4, 10, 1000, 1)
AMINST(0, 3.5, 10000, 178, 315)

makegen(1, 24, 1000, 0,1, 1,0)
makegen(2, 24, 1000, 0,1, 1.0,0.2, 3.4,0)
AMINST(3.9, 3.4, 10000, cpspch(8.00), cpspch(8.02))

clar/CLAR

CLAR es un algoritmo de modelo fisico de un clarinete. modelo fisico es un paradigma de la sintesis (desarrollado por Perry Cook) donde la computadora sintetiza sonidos no de acuerdo con el espectro de la salida deseada, sino basado en la descripcion del proceso fisico que produce el sonido (asi que: un modelo fisico de un violin, deberia incluir un sistema que describe la fisica de una cuerda que vibra, junto con una descripcion de los efectos de la presion del arco, el "vibrato" de la cuerda, etc.). Los instrumentos de modelo fisico, por lo tanto, son simulados y controlados por sistemas expertos que describen las relaciones entre las causas y los efectos deo acciones especificas con sus resultados acusticos correspondientes. (adaptado de Cook, 1992, 1995). efectos

Sintaxis:

makegen(1, 24, 1000, t0, a0, t1, a1...) /* amplitud del ruido (presion del soplo) inyectado al modelo por pares ordenados tiempo/amplitud */
makegen(2, 24, 1000, t0, a0, t1, a1...) /* amplitud global de la nota de salida */

CLAR(outskip, duration, noiseamp, length1, length2, amp, d2gain, spread)

en forma comentario:


/* clar -- modelo fisico del clarindete de Perry Cook
*
*  p0 = inicio
*  p1 = duracion
*  p2 = amplitud del ruido
*  p3 = longitud1
*  p4 = longitud2
*  p5 = amplitud de salida
*  p6 = ganancia d2
*  p7 = posicion estereo (0-1) 
*  funcion 1 es la envolvente de la amplitud del ruido
*  funcion 2 es la envolvente de la amplitud de salida
*
*/

Una partitura ejemplo:

rtsetparams(22050, 1)
makegen(1, 24, 1000, 0, 1, 1, 1)
makegen(2, 24, 1000, 0, 1, 1, 1)
CLAR(0, 1, 0.02, 78, 31, 7000, 0)
CLAR(1, 1, 0.02, 35, 4, 7000, 0)
CLAR(2, 1, 0.02, 35, 9, 7000, 0)
CLAR(3, 1, 0.02, 51, 20, 7000, 0.5)

Otra partitura, que procesa una structura de bucle

rtsetparams(22050, 1)
makegen(1, 24, 1000, 0, 1, 1, 1)
makegen(2, 24, 1000, 0, 1, 1, 1)

d2 = 0
for (start = 0; start < 10; start = start + 0.5) {
	CLAR(start, 0.5, 0.02, 69, 34, 7000, d2)
	d2 = d2 + 0.05
	}

combit/COMBIT

Un filtro comb es una linea corta de retardo realimentado donde el tiempo tel cual, cuando se aplica a una señal de entrada , haciendola "girar" alrededor de la frecuencia 1/t por una cierta cantidad de tiempo que decae exponencialmente proporcional al porcentaje de realimentacion. (adaptado de Roads, 1997). COMBIT toma un archivo de sonido de entrada y lo hace "girar" alrededor de la frecuencia especificada en el parametro p4 del instrumento, y que decae en el tiempo en segundos especificado en el parametro p5. La eficacia del filtro comb depende de la cantidad de esa frecuencia ya presente en la señal de entrada (por eso, una frecuencia muy baja aplicada a un sonido de alta frecuencia, no funcionara tan bien, como si aplicado a un sonido de baja frecuencia).

Sintaxis

setline(t0,a0,t1,a1...) /* determina la envolvente del sonido de salida en pares ordenados tiempo/amplitud */

COMBIT(inskip, outskip, duration, amplitude, pitch, reverb, inchan, spread)

en forma comentario:


/* combit --  instrumento filtro comb
*
* p0 = salto de salida
* p1 = salto de entrada
* p2 = duracion de la entrada
* p3 = multiplicador de amplitud
* p4 = altura (en ciclos por segundo)
* p5 = tiempo de reverber
* p6 = canal de entrada [opcional]
* p7 = posicion estereo [opcional]
*
*/

Una partitura ejemplo:

rtsetparams(44100, 2)
rtinput("/sndh/bob.dole.mono")
COMBIT(0, 0, 3.5, 0.08, cpspch(7.09), .5, 0, 0)
COMBIT(0.2, 0, 3.5, 0.08, cpspch(7.07), .5, 0, 1)

otra partitura, usando una estructura de bucle:

rtsetparams(44100, 2)
rtinput("/sndh/bob.dole.mono")

dur = 0.1
setline(0,0, 0.1,1, 1,0) 
reset(1000)
for (outsk = 0; outsk < 14.0; outsk = outsk + 0.1) {
	insk = random() * 7.0
	pitch = random() * 500 + 100
	COMBIT(outsk, insk, dur, 0.1, pitch, .5, 0, random());
	}

Una tercera partitura, que toma la entrada directamente del convertidor analogico/digital:

rtsetparams(44100, 2, 1024)
rtinput("AUDIO")
COMBIT(0, 0, 3.5, 0.08, cpspch(7.09), .5, 0, 0)
COMBIT(0.2, 0, 3.5, 0.08, cpspch(7.07), .5, 0, 1)

fminst/FMINST

frequency modulation (frecuencia modulada): un tipo de sintesis de distorsion donde una forma de onda (portadora) de frecuencia f_c es modulada por otra forma de onda (moduladora) con frecuencia f_m y con un indice de modulacion I (definido por la desviacion maxima de amplitud del modulador dividido por su frecuencia). El sonido resultante consiste en un sonido con la frecuencia de la portadora asi como un numero de bandas laterales f_c ± kf_m, donde k es una serie de enteros que aumenta a partir de 0 (la frecuencia de la portante). La amplitud de las bandas laterales a travez del tiempo esta determinada por una funcion de bessel del primer tipo J_k(I). Frecuencias negativas son posibles, resultando fuera de fase a 180° del valor absoluto de la frecuencia. Las amplitudes negativas son tambien posibles, resultando en una fase inversa a esa banda. (parafrasis de Dodge y Jerse, 1985).

FM ha sido tradicionalmente considerada como un metodo eficiente para crear espectros variables con el tiempo y solo con dos osciladores. Un indice de modulacion muy bajo y/o frecuencia, resultaran como un vibrato de la señal portadora. A medida que la modulacion aumenta, el espectro se transforma en un espectro mas rico. FMINST permite un indice de modulacion variable basado en el gen3 y los parametros p4 y p5 del instrumento (los cuales definen la curva indice, el punto bajo y el alto, respectivamente).

Sintaxis

makegen(1, 10, 1000, p0, p1...) /* espectro del oscilador "portante" */
makegen(2, 24, 1000, t0, a0, t1, a1...) /* envolvente de amplitud de la señal de entrada, en pares ordenados tiempo/amplitud */
makegen(3, 24, 1000, t0, a0, t1, a1...) /* envolvente del indice del oscilador modulador, en pares ordenados tiempo/amplitud */

FMINST(outskip, duration, f_c, f_m, indexlow, indexhi, amplitude, spread)
en forma comentario:


/* p0 = start; p1 = dur; p2 = altura de la portadora   (hz o oct.pc); 
   p3 = altura del modulador  (hz or oct.pc); p4 = punto inferior del indice de fm ;
   p5 = indice superior de fm ;  p6 = amp;  p7 = posicion estereo (0-1) 
   la puerta 1 es para la funcion forma de onda, la 2 es para la amplitud;
   la 3 es la guia indice /*

Una partitura ejemplo:

rtsetparams(44100, 1)
makegen(1, 10, 1000, 1)
makegen(2, 24, 1000, 0, 0, 3.5,1, 7,0)
makegen(3, 24, 1000, 0,1, 7,0)
FMINST(0, 7, 8.00, 179, 0, 10, 20000)

Otra partitura, mostrando diferentes indices de envolvente:

rtsetparams(44100, 2)
makegen(1, 10, 1000, 1)
makegen(2, 24, 1000, 0, 0, 3.5,1, 7,0)
makegen(3, 24, 1000, 0, 0, 5,1, 7, 0)
FMINST(0, 7, 8.00, 179, 0, 10, 10000, 0.1)
makegen(3, 24, 1000, 0,1, 7,0)
FMINST(3.5, 7, 8.07, 179, 0, 10, 10000, 0.9)

Una tercera partitura, con una estructura de bucle:

rtsetparams(22050, 1)
print_off()
makegen(1, 10, 1000, 1)
makegen(2, 7, 1000, 0, 500, 1, 500, 0)
makegen(3, 24, 1000, 0,1, 2,0)

nfms = 1
for (start = 0; start < 60; start = start + 1.5) {
	freq = 8.00
	for (n = 0; n < nfms; n = n + 1) {
		FMINST(start, 1.5, freq, 179, 0, 10, 1000)
		freq = freq + 0.02
		}
	nfms = nfms + 1
}

iir/IIR

IIR define un filtro de respuesta de impulso infinita ( o recursiva) con una frecuencia central, banda-pasante, y amplitud de refuerzo en ternas por el comando setup(). IIR puede tomar como entrada un archivo de sonidos (INPUTSIG), ruido blanco (NOISE), una señal del tipo pulsante (PULSE) , o una señal del tipo buzz (BUZZ). Los filtros IIR son exitados basados en las muestras previas de salida y en las muestras previas de entrada, asi que ellas pueden "circular" infinitamente usando la ecuacion:
y(n)=a₀x(n)-b₁y(n-1)-b₂y(n-2)...b_Ny(n-N)
donde y es una muestra de entrada al tiempo n, x es una muestra de entrada, y a₀ y b_N son los coeficientes del filtro que estan determinados por la forma del filtro deseado (robado de Dodge y Jerse, 1985). el numero de coeficientes usados basados en las muestras de salida es llamado numero de poles del filtro. IIR usa una ecuacion de 4 polos estandar. Por lo menos, eso es lo que queremos que piense.

Sintaxis:

variantes:
setup(f0, bw0, a0, f1, bw1, a1...) /* define el filtro en ternas frecuencia/banda-pasante/amplitud relativa hasta 64 picos. puede ser definido en una sola llamada */
makegen(1, 24, 1000, t0, a0, t1, a1...) /* devine la envolvente de la señal de salida en pares ordenados tiempo/amplitud */

para inputsig() (señal de entrada):

INPUTSIG(outskip, inskip, duration, amplitude, inchan, spread)

para noise() (ruido blanco):

NOISE(outskip, duration, amplitude, spread)

para buzz():

makegen(2, 10, 1000, 1) /* sine wave */

BUZZ(outskip, duration, amplitude, pitch, spread)

para pulse() (señal del tipo pulsante):

PULSE(outskip, duration, amplitude, pitch, spread)

en forma comentario:


/* iir -- crea un filtro del tipo iir con hasta 64 picos de resonancia, siendo especificables
*  las frecuencias centrales y la banda pasante para cada pico.
*
*  subcomandos:
*
*  setup() (definicion)
*  p0 = frecuencia central 1 (hertz o oct.pc)
*  p1 = banda-pasante 1 (o multiplicador de fc si negativo)
*  p2 = amplitud relativa 1
*  
*
*  inputsig()  (señal de entrada)
*  p0 = salto de salida
*  p1 = salto de entrada
*  p2 = duracion
*  p3 = multiplicador de amplitud
*  p4 = canal de entrada (0 o 1)
*  p5 = posicion estereo (0-1) [opcional]
*  asume que la tabla funcion 1 es la envolvente de amplitud
*
*  noise() (ruido blanco)
*  p0 = inicio
*  p1 = duracion
*  p2 = amplitud 
*  p3 = posicion estereo  (0-1) [opcional]
*  asume que la tabla funcion 1 es la amplitud de la envolvente
*
*  buzzit()
*  p0 = inicio
*  p1 = duracion
*  p2 = amplitud
*  p3 = altura (hz or oct.pc)
*  p4 = posicion estereo  (0-1) [opcional]
*  asume que la tabla funcion 1 es la amplitud de la envolvente
*  asume que la tabla funcion 2 es una onda sinusoidal
*
*  pulseit() (señal del tipo pulsante)
*  p0 = inicio
*  p1 = duracion
*  p2 = amplitud
*  p3 = altura (hz or oct.pc)
*  p4 = posicion estereo  (0-1) [opcional]
*  asume que la tabla funcion 1 es la amplitud de la envolvente
*
*/

Un ejemplo usando inputsig():

rtsetparams(44100, 1)
rtinput("/sndh/bob.dole.mono.snd")

makegen(1, 24, 1000, 0, 0, 1,1, 5,1, 7,0)
setup(149.0, 25.0, 1.0, 1415.0, 100.0, 0.8)
INPUTSIG(0, 0, 7, 0.3, 0)

setup(9.0, 25.0, 1.0, 10.0, 100.0, 0.8)
INPUTSIG(8, 0, 7, 0.15, 0)

Otro ejemplo usandonoise():

rtsetparams(44100, 2)
makegen(1, 24, 1000, 0,0, 0.1,1, 0.2,0)

start = 0
for(pc = 0; pc < 0.25; pc = pc + 0.01) {
	setup(8.00 + pc, 1.0, 1.0)
	NOISE(start, 0.2, 5000, random())
	start = start + 0.1
	}

Una tercera partitura usando buzz() y pulse():

rtsetparams(44100, 2)
makegen(1, 24, 1000, 0,1, 0.1,0)
makegen(2, 10, 1000, 1)

pitch = 134.0
for(start = 0; start < 7.8; start = start + 0.1) {
	setup((random()*2000.0) + 300.0, -0.5, 1)
	BUZZ(start, 0.1, 4000, pitch, random())
	BUZZ(start, 0.1, 4000, pitch + 2.5, random())
/*	pitch = pitch + 0.5 */
	}

for(start = 7.8; start < 15; start = start + 0.1) {
	setup((random()*2000.0) + 200.0, -0.5, 1)
	PULSE(start, 0.1, 8000, pitch, random())
	PULSE(start, 0.1, 8000, pitch + 2.5, random())
	pitch = pitch - 0.5
	}

metaflute/METAFLUTE

METAFLUTE es otro instrumento basado en sintesis por modelo fisico (ver CLAR, arriba), designado para simular una flauta. METAFLUTE tiene algunas variantes: un simple modelo de flauta (SFLUTE), un modelo con pitch-bending (BSFLUTE), y un modelo con un curva de envolvente de vibrato defininida (VSFLUTE).

Sintaxis:

para todos:

makegen(1, 24, 1000, t0, a0, t1, a1...) /* amplitud del ruido (presion de aire) inyectada en el modelo fisico en pares ordenados tiempo/amplitud */
makegen(2, 24, 1000, t0, a0, t1, a1...) /* amplitud total de la nota de salida */

para sflute():

SFLUTE(outskip, duration, noiseamp, length1, length2, amp, spread)

para bsflute():

makegen(3, 7, 1000, a0, g0, a1, g1...aN) /* curva de alturas para longitud 1, donde aN y aN+1 son las amplitudes y gN es el numero de puntos en la curva para interpolar entre ellos (la suma de los valores de g no puede exceder del numero definido en p2, en ese caso 1000) */
makegen(4, 7, 1000, 10, g0, a1, a1...aN) /* curva de alturas para longitud 2 */

BSFLUTE(outskip, duration, noisamp, length1low, length1high, length2low, length2high, amp, spread)

para vsflute():

makegen(3, 10, 1000, p0, p1...) /* funcion vibrato para longitud 1, definiendo una forma de onda con amplitudes parciales pN */
makegen(4, 10, 1000, p0, p1...) /* funcion vibrato para longitud 2, definiendo una forma de onda con amplitudes parciales pN */

BSFLUTE(outskip, duration, noisamp, length1low, length1high, length2low, length2high, amp, vibrato1low, vibrato1high, vibrato2low, vibrato2high, spread)

en forma comentario:


/* sflute -- modelo fisico de flauta de Perry Cook
*
*  p0 = inicio
*  p1 = duracion
*  p2 = amplitud de ruido
*  p3 = longitud1
*  p4 = longitud2
*  p5 = multiplicador de amplitud
*  p6 = posicion estereo (0-1) 
*  la funcion en puerta 1 es la envolvente de amplitud del ruido
*  la funcion en puerta 2 es la envolvente de amplitud de salida
*
*/

Una partitura ejemplo para sflute():

rtsetparams(22050, 1)
reset(2000)
makegen(1, 24, 1000, 0,1, 1.5,1)
makegen(2, 24, 1000, 0,0, 0.05,1, 1.49,1, 1.5,0)
SFLUTE(0, 1.5, 0.1, 20, 14, 10000)
SFLUTE(1.5, 1.5, 0.1, 20, 11, 10000)

Otra partitura, para bsflute():

rtsetparams(22050, 1)
makegen(1, 7, 1000, 1, 1000, 1)
makegen(2, 7, 1000, 1, 1000, 1)
makegen(3, 7, 1000, 0, 500, 1, 500, 0)
makegen(4, 7, 1000, 0, 1000, 1)
BSFLUTE(0, 1.5, 0.1, 20,25, 14,19, 10000)

una tercera partitura, para vsflute():

rtsetparams(22050, 1)
makegen(1, 7, 1000, 1, 1000, 1)
makegen(2, 7, 1000, 1, 1000, 1)
makegen(3, 10, 1000, 1)
makegen(4, 10, 1000, 1)
VSFLUTE(0, 3.5, 0.1, 30,31, 15,19, 7000, 1.0,4.0, 1.0,5.0)
VSFLUTE(4, 3.5, 0.1, 24,25, 15,21, 7000, 4.0,7.0, 3.0,5.0)

mix/MIX

MIX es el mas viejo y el mas simple de la familia de instrumentos de cmix. Toma un archivo de entrada, y lo mezcla en un archivo de salida. Ya que usted puede cambiar el archivo de entrada a medida que procede, usted puede usarlo para mezclar una gran cantidad de archivos juntos.

la parte mas dificil de MIX (opuestamente a su primo ligeramente mas normal, STEREO), es la manera que maneja p4-pN (el canal mix matrix). Por lo tanto:

Los proximos (hasta 4) argumentos son los numeros de canal de salida en los cuales poner el canal de entrada como determinado en por su orden en las series. Con otras palabras las series, 0 1 1 0 indicara que usted esta poniendo el canal de entrada 0 en el canal de salida 0, el canal de entrada 1 en el canal de salida 1, el canal de entrada 2 en el canal de salida 1, y el canal de entrada 3 en el canal de salida 0. Si usted especifica un numero incorrecto de canales el programa comienza a "vomitar". Si usted quiere simplemente saltar sobre un canal simplemente ponga un -1 en ese campo. (de Lansky, 1987).

Sintaxis:

setline(t0,a0,t1,a1...) /* la envolvente del sonido de salida en pares ordenados tiempo/amplitud */

MIX((outskip, inskip, duration, amplitude, channel0... channelN) /* el campo duracion, si es negativo, especifica un valor absoluto de timpo final */

en forma comentario:


/* p0 = outsk; p1 = insk; p2 = duration (-endtime); p3 = amp; 
   p4-n = channel mix matrix
   estamos integrando la informacion de setline en la tabla gen 1 */

Una partitura ejemplo:

rtsetparams(44100, 2)
rtinput("/sndh/bob.dole.mono.snd")
setline(0,0, 1, 1)
MIX(0, 0, 7.0, 1, 0, 0)
setline(0, 1, 1, 0)
MIX(0.1, 0, 7.0, 1, 1, 1)

A second example, using a looping structure and random numbers for panning:

rtsetparams(44100, 2)
rtinput("/snd/pablo1.snd")
setline(0,0, .1, 1, 2,0)

reset(10000)
dur = 1;
for(outsk = 0; outsk < 14.0; outsk = outsk + dur) {
	insk = random() * 7.0
	dur = random() * 0.2

	if (random() > 0.5) ch1 = 0
	else ch1 = 1
	if (random() > 0.5) ch2 = 0
	else ch2 = 1
	MIX(outsk, insk, dur, 1, ch1, ch2)
}

Una tercera partitura, usando el convertidor analogico-digital:

rtsetparams(44100, 2)
rtinput("AUDIO", "MIC", 2)
setline(0,0, 1, 1)
MIX(0, 0, 5, 1, 0, 0)
setline(0, 1, 1, 0)
MIX(0.1, 0, 5, 1, 1, 1)

multicomb/MULTICOMB

MULTICOMB toma un archivo de entrada y lo procesa a travez de cuatro filtros comb. La cosa "comica" es, que usted pude solo especificar el rango superior y el rango inferior de los filtros -- las fecuencias son elegidas aleatoriamente (carcajada de Brad). MULTICOMB trabaja muy bien en estereo, ya que los filtros son difusos sobre los dos canales de salida automaticamente.

Sintaxis

makegen(1, 24, 1000, t0, a0, t1, a1) /* la envolvente de amplitud de la señal de salida en pares ordenados tiempo/amplitud */

MULTICOMB(outskip, inskip, duration, amplitude, comblow, combhigh, reverb)

en forma comentario:


/* multicomb -- 4 filtros comb simultaneos elegidos aleatoriamente dentro de un rango especificado
*       (difundido en el espacio estereo)
*  p0 = salto de salida
*  p1 = salto de entrada
*  p2 = duracion de salida
*  p3 = mulitplicador de amplitud
*  p4 = frecuencia inferior del filtro comb
*  p5 = frecuencia superior del filtro comb
*  p6 = tiempo de reverber
*  asume que la tabla funcion 1 es la envolvente de amplitud
*
*/

Una partitura ejemplo:

rtsetparams(44100, 2)
rtinput("/sndh/bob.dole.mono.snd")
reset(20000)
makegen(1, 24, 1000, 0,0, 0.5,1, 4.0,1, 4.3,0)
MULTICOMB(0, 0, 4.3, 0.02, cpspch(6.02), cpspch(9.05), 1)

Otra partitura:

rtsetparams(44100, 2)
rtinput("/sndh/bob.dole.mono.snd")
reset(20000)
makegen(1, 24, 1000, 0,0, 0.5,1, 8.6,1, 8.7,0, 8.8,0)
MULTICOMB(0, 0, 8.8, 0.01, cpspch(7.02), cpspch(8.05), 5)

Otro ejemplo usando el convertidor analogico-digital:

rtsetparams(22050, 2, 256)
rtinput("AUDIO")
reset(20000)

srand(87)

makegen(1, 24, 1000, 0,0, 1,1, 3,1, 5,0)
for(start = 0; start < 30; start = start + 2.5) {
	low = random() * 500.0 + 50.0
	hi = low + (random() * 300.0)
	MULTICOMB(start, 0, 5, 0.01, low, hi, 2.5)
	}

sculpt/SCULPT

SCULPT es un instrumento que resintetiza basado en pares ordenados frecuencia/amplitud que han sido analizados en makegens. Es interesante usarlo cuando usted quiere hacer una resintesis rapida de la salida de, oh, digamos, AudioSculpt, et vous n'avez pas de CSOUND, ou quelque chose comme ça. Inspirado por Stanko Juzbasic, en cualquier lugar que el este.

Sintaxis:

makegen(1, 10, 1000, p0, p1...) /* forma de onda para la resintesis, generalmente un seno */
makegen(2, 24, 1000, t0, a0, t1, a1...) /* curva de amplitud para la señal de salida en pares ordenados tiempo/amplitud */

infile("filename", fileno) /* lee numeros en un grupo de datos limitados por espacio/tab/return para usarlos -- fileno es el numero asignado al archivo (notese -- loas archivos de entrada y de salida, son generalmente asignados a los numeros 0 y 1) */
makegen(-3, 2, points, fileno) /* lee el primer numero de points (puntos), desde el archivo abierto de datos fileno en un makegen para posicionar las frecuencias */
infile("filename", fileno+1)
makegen(-4, 2, points, fileno+1) /* hace lo mismo para posicionar las amplitudes correspondientes a makegen 3 */

si usted se siente masoquista, usted pude tambien rellenar las tablas gen manualmente:

makegen(3, 2, points, 0) /* 0 como fileno quiere decir, mire en la linea abajo */
freq0, freq1... freqN */ N debe ser igual al numero de puntos-1 */
makegen(4, 2, points, 0)
amp0, amp1... ampN */ lo mismo para los valores de amplitudes */

SCULPT(outskip, pointdur, amplitude, numpoints, spread) /* pointdur es la longitud de cada punto en los gens */

en forma comentario:


/* sculpt: instrumento para seguimiento de datos de audiosculpt localizados en makegens
*
*  p0 = tiempo inicial
*  p1 = duracion de cada punto
*  p2 = amplitud todal
*  p3 = numero de puntos
*  p4 = posicion estereo (0-1) 
*  la puerta de funcion 1 es la forma de onda, la numero 2 es la envolvente de amplitud total
*  la puerta de funcion 3 es para el numero de puntos, puerta 4 la amplitud de los puntos
*/

Una partitura ejemplo:

rtsetparams(44100, 1)
makegen(1, 10, 1000, 1)
makegen(2, 24, 1000, 0, 1, 1, 1)
makegen(3, 2, 10, 0)
149.0 159.0 169.0 179.0 189.0 199.0 214.0 215.0 234.0 314.0
makegen(4, 2, 10, 0)
0.0 -7.0 -10.0 -3.0 0.0 -10.0 -20.0 -15.0 -2.1 -1.1

SCULPT(0, 0.5, 10, 10)

stereo/STEREO

STEREO es mucho mas parecido a MIX (ver arriba). Los campos p-panoramicos , son la posicion en el espacio estereo para el canal izquierdo y el derecho, respectivamente (ejemplo: si p4 es determinado como 0, el lanal izquierdo de la entrada, sera colocado en la parte de la extrema izquierda; si determinado como 1, sera colocatdo en la extrema derecha).

Sintaxis

setline(t0,a0,t1,a1...) /* la envolvente del sonido de salida en pares ordenados tiempo/amplitud */

STEREO(outskip, inskip, duration, amplitude, channel0... channelN) /* el campo duracion, si es negativo, especifica un tiempo absoluto final en el archivo de sonidos de salida */
en forma comentario:


/* p0 = outsk; p1 = insk; p2 = dur (normal) OR if - , endtime; p3 = amp; 
   p4-n = canal de  mix matrix
   estamos integrando la informacion de setline en la tabla gen 1 */

Un ejemplo de partitura:

rtsetparams(44100, 2)
rtinput("/sndh/bob.dole.mono.snd")
setline(0,0, 1, 1, 1.1, 0)
STEREO(0, 0, 3.5, 0.7, 0.5, 0.5)
setline(0,0, 0.1, 1, 1, 0)
STEREO(2, 0, 3.5, 0.7, 0.1, 0.1)

Otra partitura, utilizando una estructura de bucle:

rtsetparams(44100, 2)
rtinput("/snd/pablo1.snd")
setline(0,0, .1, 1, 2,0)

reset(10000)
dur = 1;
for(outsk = 0; outsk < 10.0; outsk = outsk + dur) {
        insk = random() * 7.0
        dur = random() * 0.2
        STEREO(insk, outsk, dur, 1, random(), -1)
}

strum/STRUM

STRUM genera sonidos de cuerda pinzada basados en el algoritmo desarrollado por Kevin Karplus y Alex Strong. El agortimo k-s de cuerda pinzada es un sistema de sintesis substracitva usando una rafaga de ruido blanco, una linea de retardo recirculante, un filtro pasa-bajos, un filtro pasa banda, y una serie de cosas serias matematicas, como la lietra sigma, de las cuales no hablaremos aqui. (ver Roads, 1997).

La idea de basa es que la rafaga de ruido blanco, es impulsada hacia una linea de retardo, la cual divide su entrada, mandando una mitad como salida y el resto hacia atras, dentro de si misma, despues de pasarla por los filtros pasa-bajos y pasabanda. El resultado es una rafaga de sonido rico que gradualmente pierde sus armonicos mas altos al mismo tiempo que decae (como lo hace una cuerda pinzada). Un numero de simple adiciones a ese instrumento, lo han "afinado" pudiendo asi tener sonidos muy reales ( o decididamente raros) a lo largo de guitarras amplificadas o mandolinos tremolados.

STRUM, como METAFLUTE, tiene algunos subinstrumentos dentro. El instrumento basico, START(), es su cuerda pinzada generica. Cuando se colocan despues de START(), comandos como BEND(), adiciona una "curva" (bend) a la cuerda, y FRET(), emula, el tapping a dos-manos (?). START1() y sus amigos, BEND1(), FRET1(), adicionan distorcion amplificada, y VSTART1() y VFRET1() adicionan vibrato.

Sintaxis:

la sintaxis para strum es un poco una desordenada, pero veamos:

START(outskip, duration, pitch, funddecay, nyquistdecay, amplitude, squish, spread)

BEND(start, duration, pitch0, pitch1, glissfunc, funddecay, nyquistdecay, updatefreq, spread) /* nota importante -- funcionara solo despues de un comando START() */

FRET(start, duration, pitch, funddecay, nyquistdecay, spread) /* la altura es la altura que se alterna con la especificada en el precedente comando START() */

START1(outskip, duration, pitch, funddecay, nyquistdecay, distortiongain, feedbackgain, feedbackpitch, cleanlevel, distortionlevel, amplitude, squish, spread)

BEND1(start, duration, pitch0, pitch1, glissfunc, funddecay, nyquistdecay, distortiongain, feedbackgain, feedbackpitch, cleanlevel, distortionlevel, amplitude, updatefreq, spread)

FRET1(start, duration, pitch, funddecay, nyquistdecay, distortiongain, feedbackgain, feedbackpitch, cleanlevel, distortionlevel, amplitude, spread)

para VSTART1 y VFRET1 solo:

makegen(1, 10, 1000, p0, p1...) /* forma de onda para el vibrato */
makegen(2, 24, 1000, t0, a0, t1, a1...) /* envolvente para el vibrato en pares ordenados tiempo/amplitud */

VSTART1(outskip, duration, pitch, funddecay, nyquistdecay, distortiongain, feedbackgain, feedbackpitch, cleanlevel, distortionlevel, amplitude, squish, lowvibratorange, hivibratorange, vibratodepth, randomseed, updatefreq, spread)

VFRET1(outskip, duration, pitch, funddecay, nyquistdecay, distortiongain, feedbackgain, feedbackpitch, cleanlevel, distortionlevel, amplitude, lowvibratorange, hivibratorange, vibratodepth, randomseed, updatefreq, spread)

en forma comentario:


/* START:
   p0 = start; p1 = dur; p2 = pitch (oct.pc); p3 = tiempo fundamental de decadencia
   p4 = tiempo de decadencia de nyquist; p5 = amp, p6 = squish; p7 = posicion estereo [opcional]

   BEND:
   p0 = start; p1 = dur; p2 = pitch0 (oct.pc); p3 = pitch1 (oct.pc);
   p4 = funcion glissando; p5 = tiempo fundamental de decadencia:; p6 = tiempo de decadencia de nyquist;
   p7 = puesta al dia de tiempo/segundo; p8 = posicion estereo [opcional]

   FRET:
   p0 = start; p1 = dur; p2 = pitch(oct.pc); p3 = tiempo fundamental de decadencia;
   p4 = tiempo de decadencia de nyquist; p5 = posicion estereo [opcional]

   START1:
   p0 = inicio; p1 = dur; p2 = altura (oct.pc); p3 = tiempo fundamental de decadencia
   p4 = tiempo de decadencia de nyquist; p5 = ganancia de distorsion; p6 = ganancia de realimentacion
   p7 = altura de realimentacion (oct.pc); p8 =  nivel de señal limpia 
   p9 = nivel de señal de distorsion; p10 = amp; p11 = squish
   p12 = posicion estereo [opcional]

   BEND1:
   p0 = inicio; p1 = dur; p2 = altura0 (oct.pc); p3 = altura1 (oct.pc)
   p4 = funcion glissando #; p5 = tiempo fundamental de decadencia
   p6 = tiempo de decadencia de nyquist ; p7 = ganancia de la distorsion; p8 = ganancia de realimentacion
   p9 = altura de realimentacion (oct.pc); p10 = nivel de la señal limpia
   p11 = nivel de la señal de distorsion; p12 = amp; p13 = pone al dia el glissando nsamples
   p14 = posicion estereo [opcional]

   FRET1:
   p0 = inicio; p1 = dur; p2 = altura (oct.pc); p3 = tiempo fundamental de decadencia
   p4 = tiempo de decadencia de nyquist; p5 = ganancia de distorsion; p6 = ganancia de realimentacion
   p7 = altura de realimentacion (oct.pc); p8 = nivel de la señal limpia
   p9 = nivel de la señal de distorsion; p10 = amp; p11 = stereo spread [optional]

   VSTART1:
   p0 = inicio ; p1 = dur; p2 = altura (oct.pc); p3 = tiempo fundamental de decadencia
   p4 = tiempo de decadencia de nyquist; p5 = ganancia de distorsion; p6 = ganancia de realimentacion
   p7 = altura de realimentacion (oct.pc); p8 = nivel de la señal limpia
   p9 = nivel de la señal de distorsion; p10 = amp; p11 = squish
   p12 = rango de frecuencia baja de vibrato; p13 = rango de frecuencia alta de vibratohi
   p14 = profundidad de la frecuencia de vibrato (expresada en cps); p15 = valor de la semilla "aleatoria"
   p16 = puesta al dia de la altura (default 200/seg)
   p17 = posicion estereo [opcional]
   asume que makegen 1 es la funcion de vibrato y que makegen 2 es la envolvente de la amplitud del vibrato
   

   VFRET1:
   p0 = inicio; p1 = dur; p2 = altura (oct.pc); p3 = tiempo fundamental de decadencia
   p4 = tiempo de decadencia de nyquist; p5 = ganancia de distorsion; p6 = ganancia de realimentacion
   p7 = altura de realimentacion (oct.pc); p8 = nivel de la señal limpia
   p9 = nivel de la señal de distorsion; p10 = amp; 
   p11 = rango de frecuencia baja de vibrato; p12 = rango de frecuencia alta de vibratohi
   p13 = profundidad de la frecuencia de vibrato (expresada en cps); p14 = valor de la semilla "aleatoria"
   p15 = puesta al dia de la altura (default 200/seg)
   p16 = posicion estereo [opcional]
  asume que makegen 1 es la funcion de vibrato y que makegen 2 es la envolvente de la amplitud del vibrato

*/

Una partitura ejemplo:

rtsetparams(44100, 2)
makegen(1, 2, 7, 0)
7.00 7.02 7.05 7.07 7.10 8.00 8.07


srand(0.314)
for (st = 0; st < 15; st = st + 0.1) {
        pind = random() * 7
        pitch = sampfunc(1, pind)
        START(st, 1.0, pitch, 1.0, 0.1, 10000.0, 1, random())
}

Otra partitura:

rtsetparams(44100, 2)
makegen(1, 2, 7, 0)
7.00 7.02 7.05 7.07 7.10 8.00 8.07
 
srand(0.314)
for (st = 0; st < 15; st = st + 0.2) {
        pind = random() * 7
        pitch = sampfunc(1, pind)
        stereo = random()
        START(st, 0.05, pitch, 1.0, 0.1, 10000, 1,  stereo)
        FRET(st+0.05, 0.05, pitch+0.07, 1.0, 0.1, stereo)
        FRET(st+0.1, 0.05, pitch+0.04, 1.0, 0.1, stereo)
        FRET(st+0.15, 0.05, pitch+0.02, 1.0, 0.1, stereo)
}

Una tercera partitura:

rtsetparams(44100, 1)
START1(0, 4, 6.08, 1, 1, 10, 0.05, 7.00, 0, 1, 10000, 2)
makegen(1, 24, 1000, 0, 0, 1, 1, 2, 0)
BEND1(4, 4, 6.08, 7.00, 1, 1, 1, 10, 0.05, 7.00, 0, 1, 10000, 100)

wavetable/WAVETABLE

WAVETABLE es un instrumento de sintesis aditiva. Esto quiere decir que el computa basicamente un grupo de ondas sinusoidales. Mientras esto quiere decir que sus sonidos producidos con Wavetable no tendran la riqueza armonica de los sonidos producidos por FMINST o el espectro variable de los producidos por STRUM(), bueno, .....

hmm. WAVETABLE. Aprendalo. Amelo. Adorelo. Le puede slavar la vida alguna vez.

Sintaxis

makegen(1, 10, 1000, p0, p1...) /* define el espectro de la nota sintetizada, donde p0 es la fundamental, seguida de los overtones sucesivos */
makegen(2, 24, 1000, t0, a0, t1, a1...) /* pares tiempo/amplitud definen la envolvente del sonido resultante */

WAVETABLE(outskip, duration, amplitude, frequency, spread)

en forma comentario:


/* wavetable: un instrumento simple
*
*  p0=tiempo_inicial
*  p1=duracion
*  p2=amplitud 
*  p3=frecuencia en oct.pc
*  p4=posicion estereo (0-1) 
*  la puerta de funcion 1 es la forma de onda, la puerta 2 es la envolvente de amplitud
*/

Una partitura ejemplo:

rtsetparams(44100, 1)
makegen(1, 10, 1000, 1, 0.3, 0.2)
makegen(2, 7, 1000, 0, 50, 1, 900, 1, 50, 0)

start = 0.0
freq = 149.0

for (i = 0; i < 40; i = i+1) {
        WAVETABLE(start, 40-start, 500, freq)
        start = start + 1.0
        freq = freq + 25
        }

Otra partitura:

rtsetparams(44100,2)
/* saque los comentarios de la linea siguiente para eliminar la salida en pantalla */
/* print_off() */
makegen(1, 10, 1000, 1, 0.3, 0.2)
makegen(2, 24, 1000, 0,0, 0.01,1, 0.1,0.2, 0.4, 0)

reset(20000)
start = 0.0
freq = 149.0

for (i = 0; i < 100; i = i+1) {
        WAVETABLE(start, 0.4, 5000, freq, 0)
        WAVETABLE(start+random()*0.07, 0.4, 5000, freq+random()*2, 1)
        start = start + 0.1
        makegen(1, 10, 1000, 1, random(), random(), random(), random(), random()
, random())
        }

A third score:

rtsetparams(22050, 2)
print_off()
makegen(1, 10, 1000, 1, 0.3, 0.2)
makegen(2, 24, 1000, 0, 1,  950, 0)

srand(0.35)

for (start = 0; start < 7; start = start + 0.14) {
freq = random() * 200 + 35
        for (i = 0; i < 3; i = i+1) {
                WAVETABLE(start, 0.4, 1500, freq, 0)
                WAVETABLE(start+random()*0.1, 0.4, 1500, freq+(random()*7), 1)
                if (start > 3.5) {
                        makegen(1, 10, 1000, 1, random(), random(),random(),rand
om(),random(),random(),random(),random(),random(),random(),random())
                        }
                freq = freq + 125
                }
}

wshape/WSHAPE

waveshaping: un tipo de sintesis de distorsion donde una forma de onda en entrada es modificada por una funcion de transferimiento para producir una señal de salida. Por lo tanto, la señal de entrada, x, saca una señal de salida, y, pasando por una funcion definida como y = f(x). asi que:
f(x) = x² expandera exponencialmente la amplitud de la forma de onda entrante. (Dodge y Jerse, 1985).

Otras funciones de transferimiento a usar son formas de onda y ecuaciones polinomicas de Chebyshev, las cuales pueden sacar espectros armonicos pre-definidos.

El comando WSH() en WSHAPE, usa un makegen para definir la funcion de transfer. El makegen escencialmente dibuja un grafico con las muestras de entrada en el eje de las x y las muestras de salida en el eje de las y.

Sintaxis:

makegen(1, 10, 1000, p0, p1...) /* la forma de onda de entrada definida por la amplitud relativa de sus parciales */
makegen(2, 24, 1000, t0, a0, t1, a1...) /* la amplitud de la salida en pares ordenados tiempo/amplitud */
makegen(3, 7, 1000, a0, g0, a1, g1...aN) /* funcion de transfer para el "formador" de ondas, donde aN y aN+1 son las amplitudes y gN es el numero de puntos en la curva para interpolar entre ellos (la suma de los valores g no puede exceder el numero determinado en 02, en este caso 1000) */
makegen(4, 24, 1000, t0, a0, t1, a1...) /* el indice de la envolvente del "waveshaper" permitiendo al proceso de incrementar o de decrementar con el tiempo */

WSH(outskip, duration, pitch, indexlow, indexhigh, amplitude, spread)

en forma comentario:


/* intrumento de  waveshaping
*  p0 = inicio
*  p1 = duracion
*  p2 = altura (hz or oct.pc)
*  p3 = indice del punto bajo
*  p4 = indice del punto alto
*  p5 = amp
*  p6 = posicion estereo (0-1) 
*  la puerta de la funcion 1 es la forma de onda para ser modelada (generlamente un seno)
*     puerta 2 - envolvente de amplitud
*     puerta 3 - funcion de transfer
*     puerta 4 - indice de la envolvente
*/

Una partitura ejemplo:

rtsetparams(44100, 1)
makegen(1, 10, 1000, 1)
makegen(2, 24, 1000, 0,0, 3.5,1, 7,0)
makegen(3, 7, 1000, -0.7, 200, -0.5, 300, 0, 300, 0.5, 200, 0.7)
makegen(4, 24, 1000, 0,0, 3.5,1, 7,0)
WSH(0, 7, 7.02, 0, 1, 10000)
WSH(0, 7, 7.021, 0, 1, 10000)

Otra partitura. Notese que makegen 3 usa elnumero de gen 17, el cual crea un polinomio de Chebyshev para definir los armonicos:

rtsetparams(44100, 2)
makegen(1, 10, 1000, 1)
makegen(2, 24, 1000, 0,0, 3.5,1, 7,0)
makegen(3, 17, 1000, 0.9, 0.3, -0.2, 0.6, -0.7)
makegen(4, 24, 1000, 0,0, 3.5,1, 7,0)
WSH(0, 7, 7.02, 0, 1, 9000, 0.99)
makegen(2, 24, 1000, 0,0, 1.5,1, 7,0)
makegen(4, 24, 1000, 0,1, 7,0)
WSH(4, 7, 6.091, 0, 1, 10000, 0.01)

del1/DEL1

DEL! es un simple instrumento retardo-no regenerante el cual toma como entrada un archivo de sonidos y lo mezcla con una copia retardada de si mismo con una opcional diferencia de amplitud. Los sonidos son colocados en un campo estereo.

Sintaxis:

makegen(1, 24, 1000, t0, a0, t1, a1) /* envolvente de amplitud en pares ordenados tiempo/amplitud */

DEL1(outskip, inskip, duration, amplitude, delaytime, delayamp, inchan)

en forma comentario:


/* del1: instrumento de unico retardo
*       hacia una salida estereo
*
*  p0 = tiempo de inicio de la salida
*  p1 = inicio de la entrada
*  p2 = duracion
*  p3 = multiplicador de amplitud
*  p4 = tiempo de retardo
*  p5 = multiplicador de retardo de amplitud
*  p6 = numero del canal de entrada 
*  asume que la puerta 2 es la envolvente de amplitud
*/

Una partitura ejemplo:

rtsetparams(44100, 2)
rtinput("/sndh/bob.dole.mono.snd")
makegen(1, 24, 1000, 0,0, 0.5,1, 3.5,1, 7,0)
DEL1(0, 0, 7, 1, .14)

makegen(1, 24, 1000, 0,0, 0.1,1, 1.5,0.21, 3.5,1, 7,0)

Otra partitura que toma la entrada del convertidor Analogico-Digital:

rtsetparams(44100, 2, 512)
rtinput("AUDIO", "MIC")
makegen(1, 24, 1000, 0,0, 1,1, 16,1, 17,0)
DEL1(0, 0, 17, 1, 4.3, 1)

delay/DELAY

DELAY es un simple instrumento de retardo-regenerante. Tiene parametros para la regeneracion (cantidad de realimentacion) y para el tiempo de "ring-down", asi que el retardo decae naturalmente.

Sintaxis:

makegen(1, 24, 1000, t0, a0, t1, a1) /* envolvente de amplitud en pares ordenados tiempo/amplitud */

DELAY(outskip, inskip, duration, amplitude, delaytime, delayamp, regeneration, ringdown, inchan, spread) /* la regeneracion debe ser menor que 1 */

en forma comentario:


/* delay: intrumento de retardo-regenerante
*
*  p0 = comienzo de la salida
*  p1 = tiempo inicial de salida
*  p2 = duracion de la entrada
*  p3 = multiplicador de amplitud
*  p4 = tiempo de retardo
*  p5 = multiplicador de regeneracion (< 1!)
*  p6 = duracion de ring-down 
*  p7 = numero del canal de entrada 
*  p8 = posicion estereo (0-1) 
*  asume que la puerta 1 es la envolvente de amplitud
*/

Una partitura ejemplo:

rtsetparams(44100, 1)
rtinput("/sndgr/bob.dole.mono")
makegen(1, 24, 1000, 0,0, 0.5,1, 3.5,1, 7,0)
DELAY(0, 0, 7, 0.7, .14, 0.7, 3.5)

makegen(1, 24, 1000, 0,0, 0.1,1, 1.5,0.21, 3.5,1, 7,0)
DELAY(3.5, 0, 7, 1, 1.4, 0.3, 5)

Otra partitura, que toma la entrada desde el convertidor Analogico-Digital:

rtsetparams(44100, 2, 512)
rtinput("AUDIO", "MIC")
makegen(1, 24, 1000, 0,1, 100,1)
DELAY(0, 0, 14, 1.0, .078, 0.8, 3.5, 0, 0.1)

DELAY(7, 0, 10, 1, .415, 0.5, 3, 0, 0.9)

A third score:

rtsetparams(44100, 2)
rtinput("/snd/pablo1.snd")
makegen(1, 24, 1000, 0,0, 0.5,1, 3.5,1, 7,0)
DELAY(0, 0, 7, 0.5, .14, 0.7, 3.5, 0, 0.1)

makegen(1, 24, 1000, 0,0, 0.1,1, 1.5,0.21, 3.5,1, 7,0)
DELAY(3.5, 0, 7, 1, 1.4, 0.3, 5, 1, 0.9)

panecho/PANECHO

PANECHO es un instrumento mas complejo de retardo estereo que DELAY. PANECHO toma su señal de entrada y juega "ping-pong" con el retardo entre el canal derecho e izquierdo.

Sintaxis:

makegen(1, 24, 1000, t0, a0, t1, a1) /* envolvente de amplitud en pares ordenados tiempo/amplitud */

PANECHO(outskip, inskip, duration, amplitude, delaytime, delayamp, regeneration, ringdown, inchan) /* la regeneracion debe ser menor che 1 */

en forma comentario:


/* panecho: instrumento de retardo stereo-panoramico
*
*  p0 = inicio de la salida
*  p1 = tiempo inicial de la entrada
*  p2 = duracion
*  p3 = multiplicador de amplitud
*  p4 = tiempo de retardo del canal 0
*  p5 = tiempo de retardo del canal 1
*  p6 = multiplicador de regeneracion (< 1!)
*  p7 = duracion del ring-down 
*  p8 = numero del canal de entrada 
*  asume que la puerta 1 es la envolvente de amplitud
*/

Una partitura ejemplo:

rtsetparams(44100, 2)
rtinput("/sndgr/bob.dole.mono")
makegen(1, 24, 1000, 0,0, 0.5,1, 3.5,1, 7,0)
PANECHO(0, 0, 7, 1, .14, 0.069, .7, 3.5)

makegen(1, 24, 1000, 0,0, 0.1,1, 1.5,0.21, 3.5,1, 7,0)
PANECHO(4.9, 0, 7, 1, 3.14, 0.5, 0.35, 9.5)

Otra partitura que toma la señal de entrada desde el convertidor Analogico-Digital:

rtsetparams(44100, 2)
rtinput("AUDIO", "MIC")
makegen(1, 24, 1000, 0,1, 100, 1)
PANECHO(0, 0, 14, 1.0, 5.14, 1.14, .7, 9.5)
PANECHO(10, 0, 7, 1.0, 1.14, 0.14, .7, 3.5)

Una tercera partitura, que ejecuta una structura de bucle:

rtsetparams(22050, 2)
rtinput("/sndh/bob.dole.mono.snd")
makegen(1, 24, 1000, 0,0, 0.5,1, 3.5,1, 7,0)
PANECHO(0, 0, 7, 0.8, .14, 0.14, .7, 3.5)

makegen(1, 24, 1000, 0,0, 1.5,1, 3.5,1, 7,0)
PANECHO(4.9, 0, 7, 0.8, .514, 0.05, 0.95, 3.4, 0)

convolve

convolution: el proceso de multiplicar dos FFT (una derivada de un sonido fuente y la otra derivada de un sonido usado como respuesta de impulso). El resultado es una mezcla de los dos sonidos, y es un algoritmo frecuentemente usado en sintesis-cruzada y simulacion de reverber. El intrumento convolve tomo dos archivos de sonidos como entrada, ejecuta una FFT de ambos, y despues utiliza un algoritmo rapido de convulsion para multiplicar las dos FFT, usando una media ponderada. El impulso respuesta FFT es reflejado desde atras hacia adelante, con cada muestra de su FFT multiplicando la muestra correspondiente de la FFT fuente. El resultado es entonces integrado, resultando en la frecuencia specta de las dos señales multiplicadas.

La verdadera convulsion requiere una seria cantidad de poder de calculo, y convolve "correra" bastante lentamente si usted usa archivos grandes. Si usted usa impulsos de respuesta pequeños, esto podra ahorrar tiempo.

Sintaxis:

input("archivo_fuente")
input("archivo_respuesta_impulso", 2) /* notese que se abren dos archivos de sonido */
output("archivo_salida")

setwindow(0, d, t0, a0, t1, a1...) /* define la ventana FFT para el archivo fuente -d es el tamaño de la ventana en segundos, y tN y aN son pares ordenados tiempo/amplitud que definen la ventana envolvente */
setwindow(1, d, t0, a0, t1, a1...) /* define la ventana FFT para el archivo impulso respuesta */

convolve(outskip, source_duration, source_inskip, impulse_number, impulse_duration, impulse_inskip, gain, i, dry, spread) /* numero_impulso es el numero del archivo de respuesta de impulso (generalmente determinado como 2, dependiendo en su llamada ainput(), i es una condicion de invercion, donde los dos archivos son intercambiados, y dry es un numero entre 0 y 1 que determina la cantidad de fuente original que estara presente en la salida */

in comment form:


/* ventana fuente (2o argumento es la dur)
   setwindow(0, dur, time1, amp1, time2, amp2...)
   impulse window (2o argumento es la dur)
   setwindow(1, dur, time1, amp1, time2, amp2...) */

/* convolve
*
*  p0 = salto de salida
*  p1 = duracion de la salida
*  p2 = salto de entrada en la fuente
*  p3 = numero de archivo impulso(p1 en el comando input())
*  p4 = numero de ventana impulso (p0 en el parametro setwindow())
*  p5 = salto en el impulso de entrada
*  p6 = multiplicador de amplitud
*  p7 = condicion de invercion  (0 o 1, intercambia imp + fuente, creo)
*	-- generalmente "0"
*  p8 = "dry" (generalmente 0)
*  p9 = panoramica de salida (0-1)
*
*/

Una partitura ejemplo:

input("/sndh/bob.dole.mono.snd")
output("/sndh/moderate.snd")
input("/sndh/clinton.blabs.snd", 2)

setwindow(0, 0.2, 0,0, 20,1, 80,1, 100,0)
setwindow(1, 0.2, 0,0, 20,1, 80,1, 100,0)

outsk = 0.0
srcinsk = 0.0
impinsk = 0.0
for(i = 0; i < 30; i = i + 1) { /*  0.1 quiere decir 3 minutos hechos */
	convolve(outsk, 0.1, srcinsk, 2, 1, impinsk, 1, 0, 0, 0.5)
	outsk = outsk + 0.1
	srcinsk = srcinsk + 0.1
	impinsk = impinsk + 0.1
	}

Otra partitura, usando una dimension de ventana FFT igual al archivo entero (tomara mucho tiempo para calcular):

input("/sndh/luke/source.snd")
input("/sndh/luke/impulse.snd",2)
output("/sndh/luke/convolve.snd")
/* cola de la respuesta impulso   */
outskip    = 0
src_dur    = dur[0] /* determina que el tamaño de la FFT sea la del archivo */
src_inskip = 0
imp_num    = 2
imp_dur    = dur[2] /* determina que el tamaño de la FFT sea la del archivo - debe ser menor que el de la funete */
imp_inskip = 0
gain       = .5
i          = 0
dry        = 0
outpan     = .5
/* funciones opcionales de la ventana (0) fuente,  (1) impulso.
    args = [1] function # , [2] dur, setline args    */
setwindow(0,src_dur,0,0,20,1,95,1,100,0)
setwindow(1,imp_dur,0,0,20,1,95,1,100,0)

convolve(outskip,src_dur,src_inskip,imp_num,imp_dur,imp_inskip,gain,i,dry,outpan)

fir

fir filtra un archivo con impulso de respuesta finita de acuerdo con los coeficientes pasados por el instrumento. Esto es todo lo que se.

Sintaxis:

fir(inskip, outskip, duration, coefficient1, coefficient2...) /* hasta 99 coeficientes pueden ser especificados */

en forma comentario:


/* p0-insk; p1-outsk; p2-dur; p3-ncoefs; p4...-coefs */
/* hasta 99 coeficientes de fir */

Una partitura ejemplo:

input("bob.dole.snd")
output("bob.dole.filtered.snd")
fir(0, 0, 3.5, 2, 0.5, 0.1)

flange

flanging es un procedimiento de dsp (tratamiento de señales digitales) donde un sonido es retardado de acuerdo con un lfo (oscilador de baja frecuencia), produciendo un efecto "whooshing".

Sintaxis:

makegen(1,10,512,1) /* ciclo del lfo para el flanger */

flange(outskip, inskip, duration, amp, frequency, regeneration, delay, inchan, spread) /* la regeneracion debe ser menor que 1 en segundos */

en forma comentario:


/* flange -- un instrumento flanger estereo
*
*  p0 = salto de salida
*  p1 = salto de entrada
*  p2 = duracion de la entrada
*  p3 = multiplicador de amplitud
*  p4 = frecuencia de flange (en hertz)
*  p5 = regeneracion de flange (<1)
*  p6 = retardo de flange (segundos)
*  p7 = canal de entrada [opcional]
*  p8 = panoramica estereo (0-1) [opcional]
*  asume que la tabla funcion 1 es el ciclo de flange
*  el archivo de salida debe ser estereo (por ahora)
*
*/

Una partitura ejemplo:

input("/sndh/bob.dole.mono.snd")
output("/sndh/bob.dole.flanged.snd")

setline(0,0, 1,1, 4,1, 5,0)
makegen(1,10,512,1)
flange(0, 0, 5, 1, .5, .7, .05, 0, 0)
flange(1, 0, 5, 1, .9, .7, .05, 1, 1)

gravy

gravy toma un archivo de sonidos, lo corta en 'cuadros' y despues transpone y/o alarga esos cuadros. El resultado es una especie de falso 'vocoding', donde un sonido puede ser alargado y transpuesto independientemente de su duracion original y altura.

Sintaxis:

makegen(1, 7, 512, 0, 512, 1) /* la funcion uno describe la funcion de 'bevel' de las ventanas (como los cuadros son formados) */

gravy(inskip, outskip, duration, windowsize, amp, lengthmult, transp, inchan, spread) /* el tamaño de las ventanas es en segundos, la transposicion en 8ve.pc */

en forma comentario:


/* gravy -- un instrumento para cambiar la altura    
*       (modificado en 11/89 por D.S. para usar una interpolacion parabolica)
*
*  p0 = salto de entrada
*  p1 = salto de salida
*  p2 = duracion (en la entrada)
*  p3 = tamaño de la ventana (en segundos)
*  p4 = multiplicador de la amplitud
*  p5 = multiplicador de longitud (del original)
*  p6 = intervalo de transposicion (oct.pc)
*  p7 = canal de entrada [opcional]
*  p8 = panorama estereo (0-1) [opcional]
*  asume que la tabla funcion 1 contiene la envolvente de la ventana
*
*/

Una partitura ejemplo:

input("/sndh/bob.dole.mono.snd")
output("/sndh/bob.dole.gravy.snd")

makegen(1, 25, 1000, 1)
gravy(0, 0, 2.5, 0.1, 0.2, 3.0, 0.00, 0, 0.5)
gravy(0, 0, 2.5, 0.1, 0.2, 3.0, 0.02, 0, .9)
gravy(0, 0, 2.5, 0.1, 0.2, 3.0, -0.03, 0, 0.01)

Otra partitura, que toma el ingreso del convertidor Analogico-Digital (ADC):

input("/sndh/bob.dole.mono.snd")
output("/sndh/bob.dole.gravy.snd")
makegen(1, 25, 1000, 1)
gravy(1, 0, 7.0, 0.1, 0.2, 0.7, -0.04, 1, 0.5)
gravy(1, 0, 7.0, 0.1, 0.2, 0.7, -0.09, 0, .4)
gravy(1, 0, 7.0, 0.1, 0.2, 0.7, -0.03, 0, 0.61)

lpc

lpc (linear predictive coding)(codigo de prediccion lineal) es un algoritmo de compresion usado para resintetizar sonidos basados en grupos de datos derivados de un analisis estadistico de la curva de amplitud y de la frecuencia fundamental de un archivo de sonidos. Los grupos de datos son entonces usados como curvas de respuesta de filtros las cuales pueden ser usadas para predecir las muestras entre los cuadros clave de datos en el analisis.

El paquete de cmix lpc incluye un numero de rutinas:lpc crea un grupo de datos a partir de un archivo de sonidos usando el algoritmo de prediccion. stabilize elimina cualquier obvia irregularidad del grupo de datos. ptrack ejecuta un seguimiento rudimentario de la frecuancia fundamental del archivo de sonidos. mergelpcplot y pchplot son programas-terminales interactivos que permiten ver y modificar cualquier error (y hay muy seguido algunos) de los grupos de datos. Finalmente, lpcplay, el cual es el unico instrumento real de cmix del grupo, toma los grupos de datos y resintetiza sonidos basandose en ellos.

lpc tiene muchas ventajas sobre muchos analisis/resintesis basados en fft de un archivo de sonidos, incluso si tiene bastante limitaciones. lpc resintetiza sonidos usando una cantidad seria de interpolacion basada en prediccion, asi que los grupos de datos que usa son comparativamente menores (por ello su uso en tecnologias de compresion como en el minidisc de sony). Ademas, lpc de cmix crea grupos de datos de lpc y de seguimiento de altura independientes, asi que usted puede hacer algo de sintesis-cruzada uniendo grupos de datos creados con diferentes sonidos. El lado debil es que lpc es un metodo de compresion con perdidas, asi que muchas "nuance" se pierde y muchos errores se crean cuando se analiza un sonido, y la resintesis (si no es fuertemente "tirada") siempre tiene defectos.

Sintaxis:

para crear un grupo de datos de lpc (.lpc file):

lpc -o lpc_anal_file -p #poles -f framesize [-i inskip] [-d duration] soundfile

para estabilizar un grupo de datos:

stabilize lpc_anal_file #poles

para hacer un seguimiento de altura (.pch file):

ptrack -rsampling_rate -fframe_size -iinterframe_offset -hhigh_pitch_estimate -llow_pitch_estimate -sinksip -dduration -opch_anal_file soundfile

(usted puede tambien probar ptrack -q para correr esto en un modo interactivo)

para unir los grupos de datos:

merge -a lpc_anal_file -n #poles -p pch_anal_file -l lpc_starting_frame -s pch_starting_frame -e pch_end_frame

(-q corre esto tambien en modo interactivo)

para resintetizar sonidos:

output("output.snd")

dataset("lpcdataset.lpc", #poles)

lpcstuff(threshhold, random_amplitude_factor, unvoiced_rate(optional), rise(optional), decay(optional))

lpcplay(outskip, duration, pitch, starting_frame, end_frame, amplitude, warp, resonator_centerfreq, resonator_bandwidth, [frame1, pitch1, frame2, pitch2...]) /* the resonator values are optional */

en forma comentario:


/* lpcplay -- instrumento de resintesis lpc
*
* p0 = salto de salida
* p1 = duracion
* p2 = altura
* p3 = cuadro1
* p4 = cuadro2
* p5 = amplitud
* p6 = deformacion 
* p7 = resonbw
* p8=resoncf
* p9--> curvas de altura       
*
*/

Una partitura ejemplo:

output("test.snd")
float frames;

frames = dataset("test.lpc", 24)

lpcstuff(.001, .003, 0)

lpcplay(0, 6, 0, 1, frames, 1, 0, 0, 0)

move

move es un instrumento de doug scott que simula el movimiento de sonidos, el cual simula el espacio acustico de un ambiente y deja al usuario definir la trayectoria del archivo de sonidos que se mueve a travez del espacio en ese ambiente, en relacion a la posicion del escucha. El instrumento tiene parametros opcionales para ubicacion del microfono y el calculo de retardos inter-aural. La simulacion de ambientes en cmix necesita de un procedimiento muy intenso de calculo, asi que archivos mas pequeños y trayectorias mas simples funcionaran mucho mejor. El archivo de entrada que se mueve tiene que ser mono, y el archivo de salida debe ser estereo.

Sintaxis:

(tomada de la documentacion de doug scott)

para definir el espacio acustico:

space (dist_to_front, dist_to_right, -dist_to_back, -dist_to_left, height, abs_fact, rvbtime)

space es la llamada para definir el ambiente en el cual el sonido aparecera. Ya que el escucha (usted) es el punto (0,0) en coordenadas planas, las ubicaciones de las cuatro paredes estan especificadas como en un eje de coordenadas x,y:

Por eso las distancias hacia atras y hacia la izquierda deben ser especificadas como negativas. Todo, incluyendo la altura, se mide en pies. Abs_fac es un numero entre 0 (min) y 10 (max) que determinan cuan reflectivas son las paredes. Rvtime es la longitud aproximada de reverber en segundos (max depende en la dimension del ambiente).

para configurar los microfonos:

mikes(mike_angle, pattern_factor) /* esto es opcional..... */

mikes_off() /* o esto */

mikes es una llamada de configuracion opcional para cuando usted quiere simular una grabacion con microfono (la mayoria de las veces). Los argumentos son mike_angle, el cual es el angulo que *cada* microfono tiene con la linea dibujada entre ellos (por ejemplo, 45 grados los pone a 90 grados ENTRE ELLOS). pattern_factor es un valor entre 0 y 1; 0 produce un microfono omnidireccional, 1 produce uno modelo hipocardioide, 0.5 produce uno del tipo familiar modelo cardioide. Si esta llamada no se usa, entonces el modelo sera omnidireccional.

mikes_off() es usada siguiendo una previa llamada a mikes(), para cancelar el modo microfono en el evento que usted quiera usar el modo binaural (ver abajo), o por default a omnidireccional.

para definir la trayectoria para un archivo de sonidos:

path(time0,distance0,angle0, time1,distance1,angle1, ..., timeN,distN,angleN)

or:
cpath(time0,xcoord0,ycoord0, time1,xcoord1,ycoord1, ..., timeN,xcoordN,ycoordN)

o incluso algo como esto:
makegen(-1, 9, 1024, 1, 30, 0) /* x dimension = 1 +- 30 ft sine */
makegen(-2, 9, 1024, 1, 20, 30) /* y dimension = 1 +- 20 ft sine 30 deg. */

cparam(1, 2) /* combinados, estos producen una via de acceso de 20 x 30 pies eliptica */

La via de acceso permite de especificar la trayectoria de la fuente de sonido como ternas que representan relativamente el tiempo (como en setline), la distancia (en pies), el angulo (en grados).


                                  0.0  fuente
                                   |    /
                                   |   /
                                   |  /
                                   | /
                                   |/
                                  usted

Asegurese de quedar al interno del limite del ambiente (se necesitan un poco de calculos trigonometricos (o adivinacion) para hacerlo).
Si usted prefiere las coordenadas cartesianas, use en cambio cpath introduciendo ternas de tiempo, coordenada x (izquierda-derecha), y coordenada y (adelante-atras).

                                           fuente
                                             |     
                                             |     
                                             |     
                                             |    
                                             | (dist. y)  
                                             |  
                                  (dist. x)  | 
                           usted -------------

Cparam permite de especificar parametricamente los cambios en x y en y en funcion del tiempo. Por ejemplo, para tener su sonido en un circulo de 50 pies, una vez durante su duracion, cree dos funciones gen como las del ejemplo, una con 0 grado de fase (seno) y otra con 90 grados de fase (coseno). Si el numero del armonico esta definido sobre 1, el sonido circulara ciclicamente hacia adelante y hacia atras en esa dimension (x o y) un numero de veces igual al numero del armonico. La amplitud de la funcione representa el desplazamiento (mas y menos) en pies en cualquiera de los lados de la linea central. Asegurese de usar un numero negativo de slot para evitar re-escalar los valores (ver pagina del manual de makegen).

para controlar el tiempo de puesta al dia:

threshold(reset_distance)

Threshold le permite de determinar cuan seguido el programa pone al diala ubicacion de la fuente. Un valor tipico es 0.01 (pies). Valores menores dan de alguna manera resultados mas suaves con el costo de tiempo de calculo (que puede ser de 600 a 1!!).,br>
y finalmente:

move (inskip, outskip, dur, amp, dist_between_mikes, rvb_amp)

Move tiene los mismos primeros tres argumentos que mix, etc.

amp: factor de amplitud de la señal de entrada (hecho antes de cualquier proceso).

dist_between_mikes: recuerda que esto simula una imagen estereo. Sus 'microfonos' deben de estar en cualquier lugar desde 1 hasta digamos, 10 pies separados dependiendo del tamaño del ambiente. Si se le da un valor menor que 1 pie (< 1.0), y si mikes() no ha sido llamada (o mikes_off() ha sido llamada), el programa sera en modo binaural, lo cual simula los efectos filtro de las orejas humanas. Este modo es substancialmente mas lento, pero produce resultados dramaticos cuando es escuchado con auriculares.

El ultimo numero es un factor global de amplificacion que afecta todas las refelxiones y el reverber igualmente, pero no la señal directa. A este se le da usualmente el valor 1.0.

en forma comentario:


/* move -- simulador de ambientes de doug scott com fuentes moviles de sonido
*
* space (dist_to_front, dist_to_right, -dist_to_back, -dist_to_left, height, abs_fact, rvbtime)
*
* mikes(mike_angle, pattern_factor)
* mikes_off()
*
* path(time0,distance0,angle0, time1,distance1,angle1, ..., timeN,distN,angleN)
* or:
* cpath(time0,xcoord0,ycoord0, time1,xcoord1,ycoord1, ..., timeN,xcoordN,ycoordN)
* or:
* makegen(-1, 9, 1024, 1, 30, 0)
* makegen(-2, 9, 1024, 1, 20, 30)
* cparam(1, 2)
*
* threshold(reset_distance)
*
* move (inskip, outskip, dur, amp, dist_between_mikes, rvb_amp)
*
*/

Una partitura ejemplo:

input("/sndh/bob.dole.snd")
output("/sndh/bob.dole.bigroom.snd")

space(50, 50, -750, -80, 25, 1, 3)

mikes_off()

path(0, 25, 0, 3, 15, 90)

move(0, 0, 5, 1, 0, 1)

mrotate

mrotate es un instrumento basado-en-el-disco que ejecuta una transposicion de altura en el estilo 'tape-head' (similar a la funcion gliss() rt). el instrumento abre una "ventana" en el archivo de sonido y la transpone de acuerdo con la curva definida en makegen 3.

Sintaxis:

makegen(1, 24, 1000, t0, a0, t1, a1...) /* curva de amplitud de la señal de salida */
makegen(2, 25, 1000, 1) /* determina una funcion de ventana de hamming para usar con la señal */
makegen(3, 24, 1000, t0, a0, t1, a1...) /* curva para la funcion transposicion */

mrotate(inskip, outskip, duration, amp, pitch_shift_0, pitch_shift_1, windowsize, inchan, spread) /* los dos campos pitch-shift estan en 8ve.pc, positivos o negativos, definiendo la transposicion de la señal de entrada cuando makegen 3 esta en 0 y 1 respectivamente */

en forma comentario:


/*  mrotate -- un instrumento de transposicion de altura basado en una vieja idea de rotacion de
*   la cabeza-de-cintas de los transpositores
*
*  p0 = salto en entrada
*  p1 = salto en salida
*  p2 = duracion
*  p3 = multiplicador de amplitud
*  p4 = transposicion de altura hacia arriba o abajo (oct.pc) cuando la tabla funcion 3 es 0
*  p5 = transposicion de altura hacia arriba o abajo (oct.pc) cuando la tabla funcion 3 es 1
*  p6 = tamaño de la ventana
*  p7 = numero del canal de entrada
*  p8 = panorama estereo (0-1) [opcional]
*  asume que la tabla 1 es la envolvente de amplitud
*  asume que la tabla 2 es la envolvente de la ventana
*	(generalmente una ventana de hanning -- use "makegen(2, 25,1000, 1)")
*  asume que la tabla 3 es la envolvente de la transposicion de altura
*
*/

Una partitura ejemplo:

input("/sndh/bob.dole.mono.snd")
output("/sndh/bob.dole.rotate.snd")
makegen(1, 24, 1000, 0,0, 1,1, 7.0,1, 7.8,0)
makegen(2, 25, 1000, 1) /* ventana de hanning */
makegen(3, 7, 1000, 0, 500, 1, 500, 0)
mrotate(0, 0, 7.8, 1, -0.07, 0.09, 0.14)

Una segunda partitura:

input("/sndh/bob.dole.mono.snd")
output("/sndh/bob.dole.rotate.snd")
makegen(1, 24, 1000, 0,0, 1,1, 7.0,1, 7.8,0)
makegen(2, 25, 1000, 1) /* ventana de hanning */
makegen(3, 7, 1000, 0, 500, 1, 500, 0)
mrotate(0, 0, 7.8, 1, -0.07, 0.09, 0.14, 0, 0)
mrotate(0, 0, 7.8, 1, 0.07, -0.09, 0.15, 0, 1)

noise

noise tiene como salida un ruido blanco espectro-completo sobre un archivo de sonidos.

Sintaxis:

noise(outskip, duration, amplitude)

en forma comentario:


/* noise -- produce ruido.
*
* p0 = salto en salida (outskip)
* p1 = duracion (duration)
* p2 = amplitud (amplitude)
*
*/

Una partitura ejemplo:

output("noise.snd")

noise(0, 7, 1000)

place

place es el simulador de ambientes de doug scott en cmix. Ubica un sonido en un ambiente que usted diseña y simula las resonancias acusticas del ambiente. Como move, place es un programa bastante lento, el archivo de entrada debe ser monoaural y el de salida estereo.

Sintaxis:

Tomado de la documentacion de Doug Scott.

mikes(mike_angle, pattern_factor) /* esto es opcional... */

mikes_off() /* o esto */

mikes es una llamada opcional para cuando usted quiera simular una grabacion con microfono (muchas veces). Los argumentos son mike_angle, el cual es el angulo que *cada* microfono tiene con una linea dibujada entre ellos (por ejemplo, 45 grados los pone a 90 grados UNO CON EL OTRO). pattern_factor tiene un valor comprendido entre 0 y 1; 0 produce un microfono de tipo omnidireccional, 1 produce uno del tipo hipocardioide, 0.5 produce el tipo tan familiar cardioide. Si esta llamada no se hace, el tipo sera omnidireccional.

mikes_off() es usada siguiendo una previa llamada a mikes(), para cancelar el modo mike (microfono) en el evento que usted desee usar el modo binaural (ver abajo), o como el omnidirectional de default.

space (dist_to_front, dist_to_right, -dist_to_back, -dist_to_left, height, abs_fact, rvbtime)

space es la llamada definiendo el ambiente en el cual el sonido aparecera. Siendo el escucha (USTED) en el punto (0,0) en un sistema de coordenadas planas, la ubicacion de las cuatro paredes estan especificadas como en un eje de coordenadas x,y:

Por eso las distancias hacia atras y hacia la izquierda deben ser especificadas como negativas. Todo, incluyendo la altura, se mide en pies.abs_fac es un numero comprendido entre 0 (min) y 10 (max) que determina cuan reflectivas son las paredes. rvbtime es la longitud aproximada de reverber en segundos (max depende en la dimension del ambiente).

place (inskip, outskip, dur, amp, distance_to_sound, angle_of_sound, dist_between_mikes, 1.0)

Place tiene como primeros 3 argumentos los mismos que mic, etc.
La locacion de la fuente es mas facilmente especificada en terminos de distancia y angulo:



                                  0.0   fuente
                                   |    /
                                   |   /
                                   |  /
                                   | /
                                   |/
                                  usted

en pies y en grados, respectivamente. Asegurese de quedar en el interior del ambiente (con un poco de calculo trigonometrico (o adivinacion)). Para determinar la distancia entre los microfonos (negativa) usted debe poner los datos en pares ordenados (x,y).

amp: el factor de amplitud de la señal de entrada (hecho antes de procesar).

dist_between_mikes: recuerde que esto simula una imagen estereo. Sus 'microfonos' deben de estar en cualquier lugar con una distancia de 1 a digamos 10 pies entre ellos, dependiendo de la dimension del ambiente. Si se pone como negativa, actua como una bandera (condicion) diciendo que las coordenadas son cartesianas (x, y) en vez que polares (distancia, angulo).

El ultimo numero es una factor global de amplificacion que afecta todas las reflexiones y el reverber igualmente, pero no la señal directa. Este es generalmente definido como 1.0.

en forma comentario:


/* place -- simulador de ambientes de doug scott
*
* space (dist_to_front, dist_to_right, -dist_to_back, -dist_to_left, height, abs_fact, rvbtime)
*
* mikes(mike_angle, pattern_factor)
* mikes_off()
*
* place(inskip, outskip, dur, amp, distance_to_sound, angle_of_sound, dist_between_mikes, 1.0)
*
*/

Una partitura ejemplo:

input("/sndgr/blah.snd")
output("/sndgr/blah.place.snd")

space(400,400,-400,-400,400,8.,10.)
place(0,0,14.3,1,10,20,-1,1.)

pvoc

phase vocoding: es una tecnica de resintesis desarrollada por J. Moorer donde el sonido es analizado a travez de un banco de filtros con calculos adicionales de desviacion de fase para cada uno de los canales del vocoder (una especie de transformada de Fourier expansa). Los datos descernidos en el analisis permiten una transposicion real independiente del tiempo y, por coroloraio, altura-independiente estiramiento-de-tiempo de un archivo de sonidos, con muchos menos artefactos de resintesis de los normalmente posibles. (de Dodge y Jerse, 1997).

El instrumento de cmix pvoc (que reemplaza el instrumento mas viejo cmixpv) usa un analisis estandard fft con computacion adicional de fase, permitiendo al usuario de especificar los parametros de fft y modificacion de tiempo- y de altura en terminos de los multiples del sonido original.

Sintaxis:

pvoc(outskip, duration, inskip, inchan, fftsize, windowsize, readin, putout, pitchmult, npoles) /* readin y putout son el numero de muestras leidas en el vocoder versus el numero de las muestras que salieron, pitchmult permite la transposicion, y npoles generalmente es determinada con el valor 0 */

p5 (tamaño de la ventana) es un dificil parametro a determinar, y si es tratado correctamente el eliminara una cantidad significante de artefactos contenidos en la señal procesada ya por el vocoder. Para sonidos "asperos" como la voz debera tener entre la mitad y el total del tamaño de la fft, piense que para sonidos mas puros usted puede hacerla valer hasta cuatro veces el valor de la fft.

en forma comentario:


/* pvoc -- vocoder de fase de cmix
*
* p0 = salto en salida
* p1 = duracion
* p2 = salto en entrada
* p3 = canal de entrada
* p4 = tamaño de la fft
* p5 = tamaño de la ventana
* p6 = numero de muestras leidos en la entrada
* p7 = numero de muestras que salen
* p8 = multiplicador de altura
* p9 = npoles
*/

Una partitura ejemplo:

input("/sndgr/bob.dole.snd")
output("/sndgr/bob.dole.stretch.snd")

pvoc(0, 50, 0, 0, 1024, 2056, 150, 100, 0)

Otra partitura:

input("/sndgr/bob.dole.snd")
output("/sndgr/bob.dole.pvoc.snd")

pvoc(0, 3.5, 0, 0, 1024, 2048, 100, 100, 0.9)

rotate

El instrumento rotate simula el funcionamiento de un grabador de cintas con varias velocidades, permitiento la reproduccion de muestras a diferentes niveles de transposicion. Diferentemente a mrotate, rotate solo permite una transposicion estatica

Sintaxis:

makegen(1, 24, 1000, t0, a0, t1, a1...) /* curva de amplitud en pares ordenados tiempo/amplidud */
makegen(2, 25, 1000, window) /* una ventana hanning (1) o hamming (0) para el "enmarcado" del sonido */

rotate(inskip, outskip, duration, amplitude, pitch_shift, window_size, inchan, spread) /* pitch_shift tiene valores del tipo positivo/negativo 8ve.pc, y window_size, importante, en segundos, no en muestras */

en vorma comentario:


/*  rotate -- un instrumento de cambio de altura basado en una idea de
*       los viejos grabadores de cinta con cabezas rotativas
*
*  p0 = salto en salida
*  p1 = salto en entrada
*  p2 = duracion
*  p3 = multiplicador de amplitud
*  p4 = cambio de altura hacia arriba o abajo (oct.pc)
*  p5 = dimension de la ventana EN SEGUNDOS!!!!!!!!!!!!!!!!!!!
*  p6 = numero del canal de entrada
*  p7 = posicion panoramica estereo (0-1) [opcional]
*  asume que la funcion tabla 1 es la envolvente de amplitud
*  asume que la funcion tabla 2 es la envolvente de la ventana
*       
*
*/

Una partitura ejemplo:

input("/sndh/bob.dole.mono.snd")
output("/sndh/rotate.snd")
makegen(1, 24, 1000, 0,0, 1,1, 8,1, 8.7,0)
makegen(2, 25, 1000, 1) /* ventana hanning */

rotate(0, 0, 8.7, 0.2, 0, 0.1)
rotate(0, 0, 8.7, 0.2,  0.02, 0.11)
rotate(0, 0, 8.7, 0.2, 0.07, 0.14)
rotate(0, 0, 8.7, 0.2, -0.03, 0.09)

Otra partitura:

input("/sndh/bob.dole.mono.snd")
output("/sndh/rotate.snd")
makegen(1, 24, 1000, 0,0, 1,1, 8,1, 8.7,0)
makegen(2, 25, 1000, 1) /* ventana hanning */

rotate(0, 0, 8.7, 0.2, 0, 0.1, 0, 0.5)
rotate(0, 0, 8.7, 0.2,  1.00, 0.11, 0, 0)
rotate(0, 0, 8.7, 0.2, -1.07, 0.14, 1, 0.99)

Una tercera partitura, demostrando diferentes tipo de ventana:

input("/sndh/bob.dole.mono.snd")
output("/sndh/rotate.snd")
makegen(1, 24, 1000, 0,0, 1,1, 8,1, 8.7,0)
makegen(2, 25, 1000, 1) /* ventana hanning */
rotate(0, 0, 3.4, 0.2, 1, 0.1)
makegen(2, 25, 1000, 2) /* ventana hamming */
rotate(0, 3.5, 3.4, 0.2, 1, 0.1)

sgran

sintesis granular: tipo de sintesis que involucra el orden sistematico de fragmentos muy pequeños de muestras, llamados granos, los cuales cuando son organizados juntos pueden crear una gran variedad de efectos de sintesis.

sgran, o sintesis granular estocastica, es un metodo desarrollado por mara Helmuth para manipular granos usando probabilidades estocasticas. Como resultado, sgran tiene muchos argumentos (p-fields), asi que ponga atencion.

Sintaxis:

para sintesis granular de FM:

makegen(1, 24, 1000, t0, a0, t1, a1...) /* envolvente de los granos en pares ordenados tiempo/amplitud */
makegen(2, 24, 1000, t0, a0, t1, a1...) /* forma del cambio en la densidad de los granos */
makegen(3, 24, 1000, t0, a0, t1, a1...) /* forma del cambio en la duracion de los granos */
makegen(4, 24, 1000, t0, a0, t1, a1...) /* forma del cambio en la locacion de los granos */
makegen(5, 24, 1000, t0, a0, t1, a1...) /* forma del cambio en la frecuencia del portador (usualmente estatica) */
makegen(6, 10, 1000, p0, p1...) /* forma de onda del grano */
makegen(7, 24, 1000, t0, a0, t1, a1...) /* forma del indice de modulacion */

sgran(outskip, duration, amplitude, start_grain_rate, end_grain_rate,
low, average, hi, tightness [rate variation - beginning],
low, average, hi, tightness [rate variation - emd],
low, average, hi, tightness [grain duration - beginning],
low, average, hi, tightness [grain duration - end],
low, average, hi, tightness [grain location - beginning],
low, average, hi, tightness [grain location - end],
low, average, hi, tightness [pitch band - beginning],
low, average, hi, tightness [pitch band - end])
/* tightness debe ser < 1. si p29 < 0 entonces se tiene ruido en la entrada */

en forma comentario:


/*
sgran:
0       tiempo de comienzo del grupo
1       duracion del grupo
2       amplitud
3       comienzo de la cantidad de granos   
4       final 
	valor de la proporcion: (porcentage del valor de los granos) 
5-8             beg: lo, average, hi, tightness (0-1, is 0-100%)
9-12            end: lo, average, hi, tightness (0-1, is 0-100%)
	average duration:
13-16           starting lo, average, hi, tightness
17-20           ending lo, average, hi, tightness
	location:
21-24           starting lo, average, hi, tightness
25-28           ending lo, average, hi, tightness
	pitch band AS:
29-32           starting lo, average, hi, tightness
			if p29 < 0, noise is the input
33-36           ending lo, average, hi, tightness
      input type 0=AS 1=FM 2=SAM
	*       *       *
funciones: (la variacion de los cambios de stt son lineales)

1       envolvente de los granos
	forma del cambio:
2               densidad de los granos
3               duracion de los granos
4               locacion de los granos
AS-band
5       forma del cambio: frecuencia (generalmente lineal para todas las formas)
6       forma de onda
FM
5       forma del cambio: frecuencia de la portante
6       forma del cambio: c:m ratio
7       forma del cambio: mi
*/

Una partitura ejemplo:

output("ttt.snd")

makegen(1, 7, 1000, 0, 500, 1, 500, 0)
makegen(2, 7, 1000, 0, 50, 1, 950, 0)
makegen(3, 7, 1000, 1, 400, 0.1, 600, 0.4)
makegen(4, 7, 1000, 0, 400, 0.1, 600, 0.9)
makegen(5, 7, 1000, 0, 1000, 1)
makegen(6, 10, 1000, 1, 0.1, 0.3)
makegen(7, 7, 1000, 1, 1000, 0)

sgran(0, 3.5, 3000, 0.1, 0.005,
 0, 0.5, 0.9, 0.2,
 0.9, 0.5, 0.1, 0.7,
 0.9, 0.2, 0.9, 0.5,
 0.9, 0.5, 0.1, 0.7,
 0.1, 0.7, 0.9, 0.2,
 0.5, 0.9, 0.2, 0.9,
 200, 900, 500, 0.1,
 2000, 1000, 1500, 0.5)

trans

trans es un transpositor simple sin-ventanas que simplemente re-muestrea el archivo de sonidos para "tocarlo" mas alto o mas bajo.

Syntax:

trans(inskip, outskip, duration, transposition_interval, amplitude) /* donde p3 esta en notacion de 8ve.pc relativa */

en forma comentario:


/* trans -- un simple transpositor
*
* p0 = salto en entrada
* p1 = salto en salida
* p2 = duracion
* p3 = intervalo de transposicion (8ve.pc)
* p4 = amplitud
*
*/

Una partitura ejemplo:

input("/sndh/bob.dole.mono.snd")
output("/sndh/bob.dole.trans.snd")
trans(0.2, 0, 3.5, .07, 1)
trans(0.5, 4.0, 3.5, -.07, 1)

vwavetable

vwavetalbe es el instrumento wavetable con parametros adicionales para vibrato (cambio de alturas con el tiempo).

Sintaxis:

makegen(1, 10, 1000, p0, p1...) /* amplitud de los parciales en la forma de onda */
makegen(2, 24, 1000, t0, a0, t1, a1...) /* envolvente del sonido en pares ordenados tiempo/amplitud */
makegen(3, 10, 1000, p0...) /* forma de onda de la funcion vibrato */

vwavetable(outskip, duration, pitch, amplitude, vibrato_rate_lo, vibrato_rate_hi, vibrato_depth, spread) /* vibrato_depth is un numero porcentaje */

en forma comentario:


/* vwavetable -- un instrumento de sintesis con vibrato wavetable
*
*  p0 = inicio
*  p1 = duracion
*  p2 = altura (oct.pc o hz)
*  p3 = amplitud
*  p4 = valor del vibrato bajo
*  p5 = valor del vibrato alto
*  p6 = profundidad del vibrato (porcentaje)
*  p7 = panoramica estereo [opcional]
*  asume que la tabla funcion 1 es la forma de onda de sintesis
*  asume que la tabla funcion 2 es la envolvente de amplitud
*  asume que la tabla funcion 2 es la forma de onda del vibrato
*
*/

Una partitura ejemplo:

output("ttt.snd")
makegen(1, 10, 1000, 1, 0, 0.3, 0, 0.1, 0, 0.05)
makegen(2, 24, 1000, 0,0, 0.5,1, 3.4,1, 3.5,0)
makegen(3, 10, 1000, 1)
fplot(3) /* muestra la onda vibrato */
vwavetable(0, 3.5, 8.02, 10000, 4, 7, 1)
vwavetable(4.0, 3.5, 8.04, 10000, 4, 7, 10)

wah

wah es un instrumento que corre un archivo de sonidos a travez de un filtro "sweeping" que puede ser definido con una funcion guiadora.

Sintaxis:

makegen(1, 24, t0, a0, t1, a1...) /* funcion guiadora para el filtro con valores entre el maximo y el minimo */

wah(inskip, outskip, duration, freq_lo, freq_hi, bandwidth)

en forma comentario:


/* wah - un filtro del tipo "sweeping" wah 
*
* p0 = salto de entrada
* p1 = salto de salida
* p2 = duracion
* p3 = frecuencia baja del wah
* p4 = frecuencia alta del wah (hz)
* p5 = ancho de banda
* 
* la funcion 1 "guiara" el filtro
*
*/

Una partitura ejemplo:

input("/sndh/bob.dole.snd")
output("/sndh/bob.dole.wah.snd")
makegen(1, 7, 1000, 0, 100, 1, 100, 0, 100, 1, 100, 0, 100, 1, 100, 0, 400, 1)
wahwah(0, 0, 15, 100, 1000, 20)

wahwah

wahwah es un filtro wah ligeramente diferente, con el filtro "sweeping" de acuerdo a un parametro de frecuencia y a una forma de onda.

Sintaxis:

makegen(1, 10, 1000, p0...) /* forma de onde del sweep del wah */

wahwah(inskip, outskip, duration, freq_lo, freq_hi, bandwidth, wah_frequency)

en forma comentario:


/* wahwah - un filtro periodico sweeping 
*
* p0 = salto en etrada
* p1 = salto en salida
* p2 = duracion
* p3 = frecuencia baja del wah
* p4 = frecuencia alta del wah (hz)
* p5 = ancho de la banda
* p6 = frecuencia del wah
*
* la funcion 1 debe ser una periodica para el wah
*
*/

Una partitura ejemplo:

input("/sndh/bob.dole.mono.snd")
output("/sndh/bob.dole.wahwah.snd")
makegen(1, 10, 1000, 1)
wahwahwah(0, 0, 15, 400, 3500, 5, 8)

wow

El instrumento wow modula en frecuencia un archivo de sonidos de entrada, de la misma manera que fminst aplica fm a una forma de onda. El resultado varia desde un vibrato hasta un sonido rico en banda-lateral.

Sintaxis:

makegen(1, 24, 1000, t0, a0, t1, a1...) /* curva de amplitud para la nota */
makegen(2, 10, 1000, p0, p1...) /* modulador de la forma de onda */

wow(outskip, inskip, duration, amplitude, modulation_index, modulation_frequency, inchan, spread) /* ver fminst, arriba para una descripcion de esos parametros */

en forma comentario:


/*  wow -- aplica una fm a un archivo de sonidos
*
*  p0 = salto en salida
*  p1 = salto en entrada
*  p2 = duracion
*  p3 = amplitud
*  p4 = frecuencia del modulador (indice)
*  p5 = frecuencia del modulador (hz)
*  p6 = cnal de entrada [opcional]
*  p7 = panoramica estereo <0-1> [opcional]
*  asume que la tabla funcion 1 es la envolvente de amplitud
*  asume que la tabla funcion 2 es la forma de onda del modulador
*
*/

Una partitura ejemplo:

input("/sndgr/bob.dole.mono")
output("/sndgr/tryit.snd")
makegen(1, 24, 1000, 0,0, 1,1, 7,1, 8,0)
makegen(2, 10, 1000, 1)
wow(0, 0, 8, 1, 1, 4, 0, 0.5)

numtest

numtest es un instrumento para debugging (encontrar problemas) que escribe un numero en un archivo de sonidos por una cantidad de tiempo especifica.

Sintaxis:

numtest(outskip, duration, number)

en forma comentario:


/* numtest: escribe un numero repetido en un archivo de sonidos
*
*  p0=tiempo_inicialstart
*  p1=duracion
*  p2=el numero
*/

Una partitura ejemplo:

output("ttt.snd")
numtest(0, 10, 10000)

Instrumentos de RTCmix

am/AM

Syntaxis:

aminst/AMINST

Sintaxis:

clar/CLAR

Sintaxis:

combit/COMBIT

Sintaxis

fminst/FMINST

Sintaxis

iir/IIR

Sintaxis:

metaflute/METAFLUTE

Sintaxis:

mix/MIX

Sintaxis:

multicomb/MULTICOMB

Sintaxis

sculpt/SCULPT

Sintaxis:

stereo/STEREO

Sintaxis

strum/STRUM

Sintaxis:

wavetable/WAVETABLE

Sintaxis

wshape/WSHAPE

Sintaxis:

del1/DEL1

Sintaxis:

delay/DELAY

Sintaxis:

panecho/PANECHO

Sintaxis:

convolve

Sintaxis:

fir

Sintaxis:

flange

Sintaxis:

gravy

Sintaxis:

lpc

Sintaxis:

move

Sintaxis:

mrotate

Sintaxis:

noise

Sintaxis:

place

Sintaxis:

pvoc

Sintaxis:

rotate

Sintaxis:

sgran

Sintaxis:

trans

Syntax:

vwavetable

Sintaxis:

wah

Sintaxis:

wahwah

Sintaxis:

wow

Sintaxis:

numtest

Sintaxis:

that's all, folks.