CSOUND Español
Csound: FUNCTIONTABLES
FUNCTION TABLES
Note: This chapter was written before arrays had been introduced into Csound. Now the usage of arrays is in some situations preferable to using function tables. Have a look in chapter 03E to see how you can use arrays.
Nota: Este capítulo fue escrito antes de que las matrices se hubieran introducido en Csound. Ahora el uso de arrays es en algunas situaciones preferible a usar tablas de funciones. Echa un vistazo en el capítulo 03E para ver cómo puedes usar matrices.
A function table is essentially the same as what other audio programming languages might call a buffer, a table, a list or an array. It is a place where data can be stored in an ordered way. Each function table has a size: how much data (in Csound, just numbers) it can store. Each value in the table can be accessed by an index, counting from 0 to size-1. For instance, if you have a function table with a size of 10, and the numbers [1.1 2.2 3.3 5.5 8.8 13.13 21.21 34.34 55.55 89.89] in it, this is the relation of value and index:
Una tabla de funciones es esencialmente la misma que lo que otros lenguajes de programación de audio podrían llamar un búfer, una tabla, una lista o una matriz. Es un lugar donde los datos se pueden almacenar de una manera ordenada. Cada tabla de funciones tiene un tamaño: cuánto datos (en Csound, sólo números) puede almacenar. Cada valor en la tabla puede ser accedido por un índice, contando de 0 a tamaño-1. Por ejemplo, si usted tiene una tabla de funciones con un tamaño de 10, y los números [1.1 2.2 3.3 5.5 8.8 13.13 21.21 34.34 55.55 89.89] en ella, esta es la relación de valor e índice:
| VALUE | 1.1 | 2.2 | 3.3 | 5.5 | 8.8 | 13.13 | 21.21 | 34.34 | 55.55 | 89.89 |
| INDEX | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
So, if you want to retrieve the value 13.13, you must point to the value stored under index 5.
Por lo tanto, si desea recuperar el valor 13.13, debe apuntar al valor almacenado en el índice 5.
The use of function tables is manifold. A function table can contain pitch values to which you may refer using the input of a MIDI keyboard. A function table can contain a model of a waveform which is read periodically by an oscillator. You can record live audio input in a function table, and then play it back. There are many more applications, all using the fast access (because function tables are stored in RAM) and flexible use of function tables.
El uso de tablas de funciones es múltiple. Una tabla de funciones puede contener valores de tono a los que puede referirse utilizando la entrada de un teclado MIDI. Una tabla de funciones puede contener un modelo de una forma de onda que es leída periódicamente por un oscilador. Puede grabar la entrada de audio en vivo en una tabla de funciones y, a continuación, reproducirla. Hay muchas más aplicaciones, todas usando el acceso rápido (porque las tablas de funciones se almacenan en la RAM) y el uso flexible de las tablas de funciones.
How to Generate a Function Table
Each function table must be created before it can be used. Even if you want to write values later, you must first create an empty table, because you must initially reserve some space in memory for it.
Cada tabla de funciones se debe crear antes de que se pueda utilizar. Incluso si desea escribir valores más adelante, primero debe crear una tabla vacía, ya que inicialmente debe reservar algo de espacio en la memoria para ello.
Each creation of a function table in Csound is performed by one of the GEN Routines. Each GEN Routine generates a function table in a particular way: GEN01 transfers audio samples from a soundfile into a table, GEN02 stores values we define explicitly one by one, GEN10 calculates a waveform using user-defined weightings of harmonically related sinusoids, GEN20 generates window functions typically used for granular synthesis, and so on. There is a good overview in the Csound Manual of all existing GEN Routines. Here we will explain their general use and provide some simple examples using commonly used GEN routines.
Cada creación de una tabla de funciones en Csound la realiza una de las rutinas GEN. Cada GEN Routine genera una tabla de funciones de una manera particular: GEN01 transfiere muestras de audio de un archivo de sonido a una tabla, GEN02 almacena valores que definimos explícitamente uno por uno, GEN10 calcula una forma de onda usando ponderaciones definidas por el usuario de sinusoides relacionados armónicamente GEN20 genera ventana Funciones normalmente utilizadas para la síntesis granular, y así sucesivamente. Hay una buena visión general en el manual Csound de todas las rutinas GEN existentes. Aquí explicaremos su uso general y proporcionaremos algunos ejemplos sencillos usando rutinas GEN usadas comúnmente.
GEN02 and General Parameters for GEN Routines
Let's start with our example described above and write the 10 numbers into a function table with 10 storage locations. For this task use of a GEN02 function table is required. A short description of GEN02 from the manual reads as follows:
Empecemos con nuestro ejemplo descrito anteriormente y escribimos los 10 números en una tabla de funciones con 10 ubicaciones de almacenamiento. Para esta tarea se requiere el uso de una tabla de funciones GEN02. Una breve descripción de GEN02 del manual se lee de la siguiente manera:
f # time size 2 v1 v2 v3 ...
This is the traditional way of creating a function table by use of an "f statement" or an "f score event" (in a manner similar to the use of "i score events" to call instrument instances). The input parameters after the "f" are as follows:
Esta es la forma tradicional de crear una tabla de funciones mediante el uso de una instrucción f o un evento de puntuación f (de manera similar al uso de eventos de puntuación i para llamar instancias de instrumento). Los parámetros de entrada después de f son los siguientes:
- #: a number (as positive integer) for this function table;
- #: Un número (como entero positivo) para esta tabla de funciones;
- time: at what time, in relation to the passage of the score, the function table is created (usually 0: from the beginning);
- Tiempo: en qué momento, en relación con el paso de la partitura, se crea la tabla de funciones (usualmente 0: desde el principio); size: the size of the function table. A little care is required: in the early days of Csound only power-of-two sizes were possible for function tables (2, 4, 8, 16, ...); nowadays almost all GEN Routines accepts other sizes, but these non-power-of-two sizes must be declared as negative numbers!
- Size: el tamaño de la tabla de funciones. Un poco de cuidado es necesario: en los primeros días de Csound sólo poder de dos tamaños fueron posibles para las tablas de función (2, 4, 8, 16, ...); Hoy en día casi todas las rutinas GEN aceptan otros tamaños, pero estos tamaños sin poder de dos deben ser declarados como números negativos. 2: the number of the GEN Routine which is used to generate the table, and here is another important point which must be borne in mind: by default, Csound normalizes the table values. This means that the maximum is scaled to +1 if positive, and to -1 if negative. All other values in the table are then scaled by the same factor that was required to scale the maximum to +1 or -1. To prevent Csound from normalizing, a negative number can be given as GEN number (in this example, the GEN routine number will be given as -2 instead of 2).
- 2: el número de la rutina GEN que se utiliza para generar la tabla, y aquí es otro punto importante que debe tenerse en cuenta: por defecto, Csound normaliza los valores de la tabla. Esto significa que el máximo es escalado a 1 si es positivo, ya -1 si es negativo. Todos los demás valores de la tabla se escalan a continuación por el mismo factor que se requirió para escalar el máximo a 1 o -1. Para evitar que Csound se normalice, se puede dar un número negativo como número GEN (en este ejemplo, el número de rutina GEN se dará como -2 en lugar de 2).
- v1 v2 v3 ...: the values which are written into the function table.
- V1 v2 v3 ...: los valores que se escriben en la tabla de funciones.
The example below demonstrates how the values [1.1 2.2 3.3 5.5 8.8 13.13 21.21 34.34 55.55 89.89] can be stored in a function table using an f-statement in the score. Two versions are created: an unnormalised version (table number 1) and an normalised version (table number 2). The difference in their contents will be demonstrated.
El ejemplo siguiente demuestra cómo los valores [1.1 2.2 3.3 5.5 8.8 13.13 21.21 34.34 55.55 89.89] se pueden almacenar en una tabla de funciones utilizando una sentencia f en la partitura. Se crean dos versiones: una versión anormal (tabla número 1) y una versión normalizada (tabla número 2). Se demostrará la diferencia en su contenido.
EXAMPLE 03D01_Table_norm_notNorm.csd
<CsoundSynthesizer>
<CsInstruments>
;Example by Joachim Heintz
instr 1 ;prints the values of table 1 or 2
prints "%nFunction Table %d:%n", p4
indx init 0
loop:
ival table indx, p4
prints "Index %d = %f%n", indx, ival
loop_lt indx, 1, 10, loop
endin
</CsInstruments>
<CsScore>
f 1 0 -10 -2 1.1 2.2 3.3 5.5 8.8 13.13 21.21 34.34 55.55 89.89; not normalized
f 2 0 -10 2 1.1 2.2 3.3 5.5 8.8 13.13 21.21 34.34 55.55 89.89; normalized
i 1 0 0 1; prints function table 1
i 1 0 0 2; prints function table 2
</CsScore>
</CsoundSynthesizer>
Instrument 1 simply reads and prints (to the terminal) the values of the table. Notice the difference in values read, whether the table is normalized (positive GEN number) or not normalized (negative GEN number).
El instrumento 1 simplemente lee e imprime (al terminal) los valores de la tabla. Observe la diferencia en los valores leídos, si la tabla está normalizada (número GEN positivo) o no normalizada (número GEN negativo).
Using the ftgen opcode is a more modern way of creating a function table, which is generally preferable to the old way of writing an f-statement in the score.1 The syntax is explained below:
El uso del código de operación de ftgen es una forma más moderna de crear una tabla de funciones, que generalmente es preferible a la antigua forma de escribir una declaración f en la partitura.1 La sintaxis se explica a continuación:
giVar ftgen ifn, itime, isize, igen, iarg1 [, iarg2 [, ...]]
- giVar: a variable name. Each function is stored in an i-variable. Usually you want to have access to it from every instrument, so a gi-variable (global initialization variable) is given.
- GiVar: un nombre de variable. Cada función se almacena en una variable i. Por lo general, desea tener acceso a ella desde cada instrumento, por lo que una gi-variable (variable de inicialización global) se da.
- ifn: a number for the function table. If you type in 0, you give Csound the job to choose a number, which is mostly preferable.
- ifn: un número para la tabla de funciones. Si escribe 0, le da a Csound el trabajo para elegir un número, lo cual es preferible.
The other parameters (size, GEN number, individual arguments) are the same as in the f-statement in the score. As this GEN call is now a part of the orchestra, each argument is separated from the next by a comma (not by a space or tab like in the score).
Los otros parámetros (tamaño, número GEN, argumentos individuales) son los mismos que en la declaración f de la partitura. Como esta llamada GEN es ahora una parte de la orquesta, cada argumento está separado de la siguiente por una coma (no por un espacio o tabulación como en la partitura).
So this is the same example as above, but now with the function tables being generated in the orchestra header:
Así que este es el mismo ejemplo que el anterior, pero ahora con las tablas de funciones que se generan en el encabezado de la orquesta:
EXAMPLE 03D02_Table_ftgen.csd
<CsoundSynthesizer>
<CsInstruments>
;Example by Joachim Heintz
giFt1 ftgen 1, 0, -10, -2, 1.1, 2.2, 3.3, 5.5, 8.8, 13.13, 21.21, 34.34, 55.55, 89.89
giFt2 ftgen 2, 0, -10, 2, 1.1, 2.2, 3.3, 5.5, 8.8, 13.13, 21.21, 34.34, 55.55, 89.89
instr 1; prints the values of table 1 or 2
prints "%nFunction Table %d:%n", p4
indx init 0
loop:
ival table indx, p4
prints "Index %d = %f%n", indx, ival
loop_lt indx, 1, 10, loop
endin
</CsInstruments>
<CsScore>
i 1 0 0 1; prints function table 1
i 1 0 0 2; prints function table 2
</CsScore>
</CsoundSynthesizer>
GEN01: Importing a Soundfile
GEN01 is used for importing soundfiles stored on disk into the computer's RAM, ready for for use by a number of Csound's opcodes in the orchestra. A typical ftgen statement for this import might be the following:
GEN01 se utiliza para importar archivos de sonido almacenados en el disco en la RAM de los ordenadores, listos para ser utilizados por varios opcodes Csounds en la orquesta. Una sentencia típica de ftgen para esta importación podría ser la siguiente:
varname ifn itime isize igen Sfilnam iskip iformat ichn
giFile ftgen 0, 0, 0, 1, "myfile.wav", 0, 0, 0
- varname, ifn, itime: These arguments have the same meaning as explained above in reference to GEN02. Note that on this occasion the function table number (ifn) has been defined using a zero. This means that Csound will automatically assign a unique function table number. This number will also be held by the variable giFile which we will normally use to reference the function table anyway so its actual value will not be important to us. If you are interested you can print the value of giFile (ifn) out. If no other tables are defined, it will be 101 and subsequent tables, also using automatically assigned table numbers, will follow accordingly: 102, 103 etc.
Varname, ifn, itime: Estos argumentos tienen el mismo significado que se ha explicado anteriormente con referencia a GEN02. Tenga en cuenta que en esta ocasión el número de la tabla de funciones (ifn) se ha definido utilizando un cero. Esto significa que Csound asignará automáticamente un número de tabla de funciones único. Este número también se llevará a cabo por la variable giFile que utilizaremos normalmente para hacer referencia a la tabla de funciones de todos modos por lo que su valor real no será importante para nosotros. Si está interesado, puede imprimir el valor de giFile (ifn). Si no se definen otras tablas, será 101 y las tablas subsiguientes, también usando números de tabla automáticamente asignados, seguirán en consecuencia: 102, 103, etc.
- isize: Usually you won't know the length of your soundfile in samples, and want to have a table length which includes exactly all the samples. This is done by setting isize=0. (Note that some opcodes may need a power-of-two table. In this case you can not use this option, but must calculate the next larger power-of-two value as size for the function table.)
- Isize: Normalmente no sabrás la longitud de tu archivo de sonido en muestras, y quieres tener una longitud de tabla que incluya exactamente todas las muestras. Esto se hace estableciendo isize = 0. (Tenga en cuenta que algunos opcodes pueden necesitar una tabla power-of-two.En este caso, no puede utilizar esta opción, sino que debe calcular el siguiente valor más grande de power-of-two como tamaño para la tabla de funciones.)
- igen: As explained in the previous subchapter, this is always the place for indicating the number of the GEN Routine which must be used. As always, a positive number means normalizing, which is often convenient for audio samples.
- Igen: Como se explica en el subcapítulo anterior, este es siempre el lugar para indicar el número de la rutina GEN que se debe utilizar. Como siempre, un número positivo significa la normalización, que es a menudo conveniente para las muestras de audio.
- Sfilnam: The name of the soundfile in double quotes. Similar to other audio programming languages, Csound recognizes just the name if your .csd and the soundfile are in the same folder. Otherwise, give the full path. (You can also include the folder via the "SSDIR" variable, or add the folder via the "--env:NAME+=VALUE" option.)
- Sfilnam: El nombre del archivo de sonido entre comillas dobles. Similar a otros lenguajes de programación de audio, Csound reconoce sólo el nombre si su .csd y el archivo de sonido están en la misma carpeta. De lo contrario, dé el camino completo. (También puede incluir la carpeta a través de la variable SSDIR o agregar la carpeta a través de la opción --env: NAME = VALUE).
- iskip: The time in seconds you want to skip at the beginning of the soundfile. 0 means reading from the beginning of the file.
- Iskip: El tiempo en segundos que desea omitir al principio del archivo de sonido. 0 significa lectura desde el principio del archivo.
- iformat: The format of the amplitude samples in the soundfile, e.g. 16 bit, 24 bit etc. Usually providing 0 here is sufficient, in which case Csound will read the sample format form the soundfile header.
Iformat: El formato de las muestras de amplitud en el archivo de sonido, p. 16 bits, 24 bits, etc. Por lo general, proporcionar 0 aquí es suficiente, en cuyo caso Csound leerá el formato de muestra del encabezado de archivo de sonido.- ichn: 1 = read the first channel of the soundfile into the table, 2 = read the second channel, etc. 0 means that all channels are read. Note that only certain opcodes are able to properly make use of multichannel audio stored in function tables.
- Ichn: 1 = leer el primer canal del archivo de sonido en la tabla, 2 = leer el segundo canal, etc. 0 significa que todos los canales se leen. Tenga en cuenta que sólo algunos opcodes pueden utilizar correctamente el audio multicanal almacenado en las tablas de funciones.
The following example loads a short sample into RAM via a function table and then plays it. You can download the sample here (or replace it with one of your own). Copy the text below, save it to the same location as the "fox.wav" soundfile (or add the folder via the "--env:NAME+=VALUE" option),2 and it should work. Reading the function table here is done using the poscil3 opcode which can deal with non-power-of-two tables.
El ejemplo siguiente carga una muestra corta en la RAM a través de una tabla de funciones y luego la reproduce. Puede descargar el ejemplo aquí (o reemplazarlo por uno propio). Copie el texto a continuación, guárdelo en la misma ubicación que el archivo de sonido fox.wav (o agregue la carpeta a través de la opción --env: NAME = VALUE), 2 y debería funcionar. La lectura de la tabla de funciones se realiza utilizando el opcode poscil3 que puede ocuparse de tablas que no sean de potencia de dos.
EXAMPLE 03D03_Sample_to_table.csd
<CsoundSynthesizer>
<CsOptions>
-odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
giSample ftgen 0, 0, 0, 1, "fox.wav", 0, 0, 1
instr 1
itablen = ftlen(giSample) ;length of the table
idur = itablen / sr ;duration
aSamp poscil3 .5, 1/idur, giSample
outs aSamp, aSamp
endin
</CsInstruments>
<CsScore>
i 1 0 2.757
</CsScore>
</CsoundSynthesizer>
GEN10: Creating a Waveform
The third example for generating a function table covers a classic case: building a function table which stores one cycle of a waveform. This waveform will then be read by an oscillator to produce a sound.
El tercer ejemplo para generar una tabla de funciones cubre un caso clásico: construir una tabla de funciones que almacena un ciclo de una forma de onda. Esta forma de onda será entonces leída por un oscilador para producir un sonido.
There are many GEN Routines which can be used to achieve this. The simplest one is GEN10. It produces a waveform by adding sine waves which have the "harmonic" frequency relationship 1 : 2 : 3 : 4 ... After the usual arguments for function table number, start, size and gen routine number, which are the first four arguments in ftgen for all GEN Routines, with GEN10 you must specify the relative strengths of the harmonics. So, if you just provide one argument, you will end up with a sine wave (1st harmonic). The next argument is the strength of the 2nd harmonic, then the 3rd, and so on. In this way, you can build approximations of the standard harmonic waveforms by the addition of sinusoids. This is done in the next example by instruments 1-5. Instrument 6 uses the sine wavetable twice: for generating both the sound and the envelope.
Hay muchas rutinas GEN que se pueden utilizar para lograr esto. El más simple es GEN10. Produce una forma de onda mediante la adición de ondas sinusoidales que tienen la relación de frecuencia armónica 1: 2: 3: 4 ... Después de los argumentos usuales para el número de tabla de funciones, el inicio, el tamaño y el número de rutina gen, que son los primeros cuatro argumentos en ftgen para Todas las rutinas GEN, con GEN10 debe especificar las fuerzas relativas de los armónicos. Por lo tanto, si usted acaba de proporcionar un argumento, usted terminará con una onda senoidal (1 ª armónica). El siguiente argumento es la fuerza del 2do armónico, entonces el 3ro, y así sucesivamente. De esta manera, puede construir aproximaciones de las formas de onda armónicas estándar mediante la adición de sinusoides. Esto se hace en el siguiente ejemplo con los instrumentos 1-5. El instrumento 6 utiliza la tabla de ondas sinusoidales dos veces: para generar tanto el sonido como el envolvente.
EXAMPLE 03D04_Standard_waveforms_with_GEN10.csd
<CsoundSynthesizer>
<CsOptions>
-odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
giSine ftgen 0, 0, 2^10, 10, 1
giSaw ftgen 0, 0, 2^10, 10, 1, 1/2, 1/3, 1/4, 1/5, 1/6, 1/7, 1/8, 1/9
giSquare ftgen 0, 0, 2^10, 10, 1, 0, 1/3, 0, 1/5, 0, 1/7, 0, 1/9
giTri ftgen 0, 0, 2^10, 10, 1, 0, -1/9, 0, 1/25, 0, -1/49, 0, 1/81
giImp ftgen 0, 0, 2^10, 10, 1, 1, 1, 1, 1, 1, 1, 1, 1
instr 1 ;plays the sine wavetable
aSine poscil .2, 400, giSine
aEnv linen aSine, .01, p3, .05
outs aEnv, aEnv
endin
instr 2 ;plays the saw wavetable
aSaw poscil .2, 400, giSaw
aEnv linen aSaw, .01, p3, .05
outs aEnv, aEnv
endin
instr 3 ;plays the square wavetable
aSqu poscil .2, 400, giSquare
aEnv linen aSqu, .01, p3, .05
outs aEnv, aEnv
endin
instr 4 ;plays the triangular wavetable
aTri poscil .2, 400, giTri
aEnv linen aTri, .01, p3, .05
outs aEnv, aEnv
endin
instr 5 ;plays the impulse wavetable
aImp poscil .2, 400, giImp
aEnv linen aImp, .01, p3, .05
outs aEnv, aEnv
endin
instr 6 ;plays a sine and uses the first half of its shape as envelope
aEnv poscil .2, 1/6, giSine
aSine poscil aEnv, 400, giSine
outs aSine, aSine
endin
</CsInstruments>
<CsScore>
i 1 0 3
i 2 4 3
i 3 8 3
i 4 12 3
i 5 16 3
i 6 20 3
</CsScore>
</CsoundSynthesizer>
How to Write Values to a Function Table
As we have seen, GEN Routines generate function tables, and by doing this, they write values into them according to various methods, but in certain cases you might first want to create an empty table, and then write the values into it later or you might want to alter the default values held in a function table. The following section demonstrates how to do this.
Como hemos visto, las rutinas GEN generan tablas de funciones y, al hacerlo, escriben valores en ellas de acuerdo con varios métodos, pero en ciertos casos, puede que primero desee crear una tabla vacía y luego escribir los valores en ella más tarde o bien Puede querer alterar los valores predeterminados mantenidos en una tabla de funciones. La siguiente sección muestra cómo hacerlo.
To be precise, it is not actually correct to talk about an "empty table". If Csound creates an "empty" table, in fact it writes zeros to the indices which are not specified. Perhaps the easiest method of creating an "empty" table for 100 values is shown below:
Para ser exactos, no es correcto hablar de una mesa vacía. Si Csound crea una tabla vacía, de hecho escribe zeros en los índices que no se especifican. Tal vez el método más fácil de crear una tabla vacía para 100 valores se muestra a continuación:
giEmpty ftgen 0, 0, -100, 2, 0
The simplest to use opcode that writes values to existing function tables during a note's performance is tablew and its i-time equivalent is tableiw. Note that you may have problems with some features if your table is not a power-of-two size. In this case, you can also use tabw / tabw_i, but they don't have the offset- and the wraparound-feature. As usual, you must differentiate if your signal (variable) is i-rate, k-rate or a-rate. The usage is simple and differs just in the class of values you want to write to the table (i-, k- or a-variables):
El más sencillo de usar opcode que escribe valores a tablas de funciones existentes durante un rendimiento de notas es tablew y su equivalente en tiempo-i es tableiw. Tenga en cuenta que puede tener problemas con algunas características si su tabla no es un tamaño de dos. En este caso, también puede usar tabw / tabw_i, pero no tienen el offset y el wraparound. Como de costumbre, debe diferenciar si su señal (variable) es i-rate, k-rate o a-rate. El uso es simple y difiere sólo en la clase de valores que desea escribir en la tabla (i-, k- o a-variables):
tableiw isig, indx, ifn [, ixmode] [, ixoff] [, iwgmode]
tablew ksig, kndx, ifn [, ixmode] [, ixoff] [, iwgmode]
tablew asig, andx, ifn [, ixmode] [, ixoff] [, iwgmode]
- isig, ksig, asig is the value (variable) you want to write into a specified location of the table;
- Isig, ksig, asig es el valor (variable) que desea escribir en una ubicación especificada de la tabla;
- indx, kndx, andx is the location (index) where you will write the value;
- Indx, kndx, andx es la ubicación (índice) donde se escribirá el valor;
- ifn is the function table you want to write to;
- Ifn es la tabla de funciones a la que desea escribir;
- ixmode gives the choice to write by raw indices (counting from 0 to size-1), or by a normalized writing mode in which the start and end of each table are always referred as 0 and 1 (not depending on the length of the table). The default is ixmode=0 which means the raw index mode. A value not equal to zero for ixmode changes to the normalized index mode.
- Ixmode da la opción de escribir por índices sin procesar (contando de 0 a tamaño-1), o por un modo de escritura normalizado en el que el inicio y el final de cada tabla se denominan siempre 0 y 1 (no dependiendo de la longitud de la tabla ). El valor predeterminado es ixmode = 0, que significa el modo de índice sin procesar. Un valor no igual a cero para ixmode cambia al modo de índice normalizado.
ixoff (default=0) gives an index offset. So, if indx=0 and ixoff=5, you will write at index 5
Ixoff (default = 0) da una compensación de índice. Por lo tanto, si indx = 0 y ixoff = 5, escribirá en el índice 5
- .
- iwgmode tells what you want to do if your index is larger than the size of the table. If iwgmode=0 (default), any index larger than possible is written at the last possible index. If iwgmode=1, the indices are wrapped around. For instance, if your table size is 8, and your index is 10, in the wraparound mode the value will be written at index 2.
- Iwgmode indica lo que quieres hacer si tu índice es mayor que el tamaño de la tabla. Si iwgmode = 0 (valor predeterminado), cualquier índice mayor que el posible se escribe en el último índice posible. Si iwgmode = 1, los índices se envuelven alrededor. Por ejemplo, si su tamaño de tabla es 8 y su índice es 10, en el modo envolvente el valor se escribirá en el índice 2.
Here are some examples for i-, k- and a-rate values.
Aquí hay algunos ejemplos de valores de i, k y a.
i-Rate Example
The following example calculates the first 12 values of a Fibonacci series and writes them to a table. An empty table has first been created in the header (filled with zeros), then instrument 1 calculates the values in an i-time loop and writes them to the table using tableiw. Instrument 2 simply prints all the values in a list to the terminal.
El ejemplo siguiente calcula los primeros 12 valores de una serie de Fibonacci y los escribe en una tabla. En primer lugar se ha creado una tabla vacía en el encabezado (llenado con ceros), entonces el instrumento 1 calcula los valores en un bucle i-time y los escribe en la tabla usando tableiw. El instrumento 2 simplemente imprime todos los valores de una lista al terminal.
EXAMPLE 03D05_Write_Fibo_to_table.csd
<CsoundSynthesizer>
<CsInstruments>
;Example by Joachim Heintz
giFt ftgen 0, 0, -12, -2, 0
instr 1; calculates first 12 fibonacci values and writes them to giFt
istart = 1
inext = 2
indx = 0
loop:
tableiw istart, indx, giFt ;writes istart to table
istartold = istart ;keep previous value of istart
istart = inext ;reset istart for next loop
inext = istartold + inext ;reset inext for next loop
loop_lt indx, 1, 12, loop
endin
instr 2; prints the values of the table
prints "%nContent of Function Table:%n"
indx init 0
loop:
ival table indx, giFt
prints "Index %d = %f%n", indx, ival
loop_lt indx, 1, ftlen(giFt), loop
endin
</CsInstruments>
<CsScore>
i 1 0 0
i 2 0 0
</CsScore>
</CsoundSynthesizer>
k-Rate Example
The next example writes a k-signal continuously into a table. This can be used to record any kind of user input, for instance by MIDI or widgets. It can also be used to record random movements of k-signals, like here:
El siguiente ejemplo escribe una señal k continuamente en una tabla. Esto se puede utilizar para grabar cualquier tipo de entrada del usuario, por ejemplo, MIDI o widgets. También se puede utilizar para registrar movimientos aleatorios de señales k, como aquí:
EXAMPLE 03D06_Record_ksig_to_table.csd
<CsoundSynthesizer>
<CsOptions>
-odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
giFt ftgen 0, 0, -5*kr, 2, 0; size for 5 seconds of recording
giWave ftgen 0, 0, 2^10, 10, 1, .5, .3, .1; waveform for oscillator
seed 0
; - recording of a random frequency movement for 5 seconds, and playing it
instr 1
kFreq randomi 400, 1000, 1 ;random frequency
aSnd poscil .2, kFreq, giWave ;play it
outs aSnd, aSnd
;;record the k-signal
prints "RECORDING!%n"
;create a writing pointer in the table,
;moving in 5 seconds from index 0 to the end
kindx linseg 0, 5, ftlen(giFt)
;write the k-signal
tablew kFreq, kindx, giFt
endin
instr 2; read the values of the table and play it again
;;read the k-signal
prints "PLAYING!%n"
;create a reading pointer in the table,
;moving in 5 seconds from index 0 to the end
kindx linseg 0, 5, ftlen(giFt)
;read the k-signal
kFreq table kindx, giFt
aSnd oscil3 .2, kFreq, giWave; play it
outs aSnd, aSnd
endin
</CsInstruments>
<CsScore>
i 1 0 5
i 2 6 5
</CsScore>
</CsoundSynthesizer>
As you see, this typical case of writing k-values to a table requires a changing value for the index, otherwise tablew will continually overwrite at the same table location. This changing value can be created using the line or linseg opcodes - as was done here - or by using a phasor. A phasor moves continuously from 0 to 1 at a user-defined frequency. For example, if you want a phasor to move from 0 to 1 in 5 seconds, you must set the frequency to 1/5. Upon reaching 1, the phasor will wrap-around to zero and begin again. Note that phasor can also be given a negative frequency in which case it moves in reverse from 1 to zero then wrapping around to 1. By setting the ixmode argument of tablew to 1, you can use the phasor output directly as writing pointer. Below is an alternative version of instrument 1 from the previous example, this time using phasor to generate the index values:
Como se ve, este caso típico de escribir k-valores en una tabla requiere un cambio de valor para el índice, de lo contrario tablew continuamente sobrescribirá en la misma ubicación de la tabla. Este valor cambiante se puede crear usando los opcodes de línea o linseg - como se hizo aquí - o usando un fasor. Un fasor se mueve continuamente de 0 a 1 a una frecuencia definida por el usuario. Por ejemplo, si desea que un fasor se mueva de 0 a 1 en 5 segundos, debe establecer la frecuencia en 1/5. Al llegar a 1, el fasor se envolverá a cero y comenzará de nuevo. Tenga en cuenta que también se puede asignar una frecuencia negativa al fasor, en cuyo caso se mueve en sentido inverso de 1 a cero y luego se envuelve en 1. Al establecer el argumento ixmode de tablew en 1, puede utilizar la salida del fasor directamente como puntero de escritura. A continuación se muestra una versión alternativa del instrumento 1 del ejemplo anterior, esta vez usando fasor para generar los valores de índice:
instr 1; recording of a random frequency movement for 5 seconds, and playing it
kFreq randomi 400, 1000, 1; random frequency
aSnd oscil3 .2, kFreq, giWave; play it
outs aSnd, aSnd
;;record the k-signal with a phasor as index
prints "RECORDING!%n"
;create a writing pointer in the table,
;moving in 5 seconds from index 0 to the end
kindx phasor 1/5
;write the k-signal
tablew kFreq, kindx, giFt, 1
endin
a-Rate Example
Recording an audio signal is quite similar to recording a control signal. You just need an a-signal to provide input values and also an index that changes at a-rate. The next example first records a randomly generated audio signal and then plays it back. It then records the live audio input for 5 seconds and subsequently plays it back.
La grabación de una señal de audio es bastante similar a la grabación de una señal de control. Sólo necesita una señal-a para proporcionar valores de entrada y también un índice que cambia a una velocidad. El siguiente ejemplo registra primero una señal de audio generada aleatoriamente y luego la reproduce. A continuación, graba la entrada de audio en directo durante 5 segundos y posteriormente la reproduce.
EXAMPLE 03D07_Record_audio_to_table.csd
<CsoundSynthesizer>
<CsOptions>
-iadc -odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
giFt ftgen 0, 0, -5*sr, 2, 0; size for 5 seconds of recording audio
seed 0
instr 1 ;generating a band filtered noise for 5 seconds, and recording it
aNois rand .2
kCfreq randomi 200, 2000, 3; random center frequency
aFilt butbp aNois, kCfreq, kCfreq/10; filtered noise
aBal balance aFilt, aNois, 1; balance amplitude
outs aBal, aBal
;;record the audiosignal with a phasor as index
prints "RECORDING FILTERED NOISE!%n"
;create a writing pointer in the table,
;moving in 5 seconds from index 0 to the end
aindx phasor 1/5
;write the k-signal
tablew aBal, aindx, giFt, 1
endin
instr 2 ;read the values of the table and play it
prints "PLAYING FILTERED NOISE!%n"
aindx phasor 1/5
aSnd table3 aindx, giFt, 1
outs aSnd, aSnd
endin
instr 3 ;record live input
ktim timeinsts ; playing time of the instrument in seconds
prints "PLEASE GIVE YOUR LIVE INPUT AFTER THE BEEP!%n"
kBeepEnv linseg 0, 1, 0, .01, 1, .5, 1, .01, 0
aBeep oscils .2, 600, 0
outs aBeep*kBeepEnv, aBeep*kBeepEnv
;;record the audiosignal after 2 seconds
if ktim > 2 then
ain inch 1
printks "RECORDING LIVE INPUT!%n", 10
;create a writing pointer in the table,
;moving in 5 seconds from index 0 to the end
aindx phasor 1/5
;write the k-signal
tablew ain, aindx, giFt, 1
endif
endin
instr 4 ;read the values from the table and play it
prints "PLAYING LIVE INPUT!%n"
aindx phasor 1/5
aSnd table3 aindx, giFt, 1
outs aSnd, aSnd
endin
</CsInstruments>
<CsScore>
i 1 0 5 ; record 5 seconds of generated audio to a table
i 2 6 5 ; play back the recording of generated audio
i 3 12 7 ; record 5 seconds of live audio to a table
i 4 20 5 ; play back the recording of live audio
</CsScore>
</CsoundSynthesizer>
How to Retrieve Values from a Function Table
There are two methods of reading table values. You can either use the table / tab opcodes, which are universally usable, but need an index; or you can use an oscillator for reading a table at k-rate or a-rate.
Hay dos métodos de lectura de valores de tabla. Puede utilizar los opcodes table / tab, que son universalmente utilizables, pero necesitan un índice; O puede utilizar un oscilador para leer una tabla en k-rate o a-rate.
The table Opcode
The table opcode is quite similar in syntax to the tableiw/tablew opcodes (which are explained above). It is simply its counterpart for reading values from a function table instead of writing them. Its output can be either an i-, k- or a-rate signal and the value type of the output automatically selects either the a- k- or a-rate version of the opcode. The first input is an index at the appropriate rate (i-index for i-output, k-index for k-output, a-index for a-output). The other arguments are as explained above for tableiw/tablew:
El opcode de tabla es bastante similar en sintaxis a los opcodes tableiw / tablew (que se explican anteriormente). Es simplemente su contraparte para leer valores de una tabla de funciones en lugar de escribirlas. Su salida puede ser una señal i-, k- o a-rate y el tipo de valor de la salida selecciona automáticamente la versión ak o a-rate del código de operación. La primera entrada es un índice a la velocidad apropiada (i-index para i-output, k-index para k-output, a-index para a-output). Los otros argumentos son como se explicó anteriormente para tableiw / tablew:
ires table indx, ifn [, ixmode] [, ixoff] [, iwrap]
kres table kndx, ifn [, ixmode] [, ixoff] [, iwrap] ares table andx, ifn [, ixmode] [, ixoff] [, iwrap]
As table reading often requires interpolation between the table values - for instance if you read k- or a-values faster or slower than they have been written in the table - Csound offers two descendants of table for interpolation: tablei interpolates linearly, whilst table3 performs cubic interpolation (which is generally preferable but is computationally slightly more expensive) and when CPU cycles are no object, tablexkt can be used for ultimate interpolating quality.3
Como la lectura de la tabla requiere a menudo la interpolación entre los valores de la tabla - por ejemplo si usted lee los valores de k o de a más rápidamente o más lentamente que se han escrito en la tabla - Csound ofrece dos descendientes de la tabla para la interpolación: tablei interpola linear, mientras que table3 realiza Interpolación cúbica (que generalmente es preferible pero computacionalmente un poco más cara) y cuando los ciclos de la CPU no son un objeto, tablexkt puede usarse para la máxima calidad de interpolación.
Another variant is the tab_i / tab opcode which misses some features but may be preferable in some situations. If you have any problems in reading non-power-of-two tables, give them a try. They should also be faster than the table (and variants thereof) opcode, but you must take care: they include fewer built-in protection measures than table, tablei and table3 and if they are given index values that exceed the table size Csound will stop and report a performance error. Examples of the use of the table opcodes can be found in the earlier examples in the How-To-Write-Values... section.
Otra variante es el opcode tab_i / tab que falla algunas características pero puede ser preferible en algunas situaciones. Si tiene algún problema en la lectura de tablas de no poder de dos, inténtelo. También deben ser más rápidos que el código de operaciones de la tabla (y sus variantes), pero hay que tener cuidado: incluyen menos medidas de protección incorporadas que table, tablei y table3 y si se dan valores de índice que exceden el tamaño de la tabla Csound se detendrá Y reportar un error de rendimiento. Ejemplos del uso de los opcodes de tabla se pueden encontrar en los ejemplos anteriores en la sección How-To-Write-Values ....
Oscillators
It is normal to read tables that contain a single cycle of an audio waveform using an oscillator but you can actually read any table using an oscillator, either at a- or at k-rate. The advantage is that you needn't create an index signal. You can simply specify the frequency of the oscillator (the opcode creates the required index internally based on the asked for frequency).
Es normal leer tablas que contienen un solo ciclo de una forma de onda de audio usando un oscilador, pero en realidad se puede leer cualquier tabla usando un oscilador, ya sea a-o en k-rate. La ventaja es que no necesita crear una señal de índice. Simplemente puede especificar la frecuencia del oscilador (el código de operación crea el índice requerido internamente basado en la frecuencia solicitada).
You should bear in mind that many of the oscillators in Csound will work only with power-of-two table sizes. The poscil/poscil3 opcodes do not have this restriction and offer a high precision, because they work with floating point indices, so in general it is recommended to use them. Below is an example that demonstrates both reading a k-rate and an a-rate signal from a buffer with poscil3 (an oscillator with a cubic interpolation):
Debe tener en cuenta que muchos de los osciladores en Csound funcionará sólo con tamaños de mesa de dos tamaños. Los opcodes poscil / poscil3 no tienen esta restricción y ofrecen una alta precisión, ya que trabajan con índices de coma flotante, por lo que en general se recomienda su uso. A continuación se muestra un ejemplo que demuestra tanto la lectura de una k-velocidad y una señal a-tasa de un buffer con poscil3 (un oscilador con una interpolación cúbica):
EXAMPLE 03D08_RecPlay_ak_signals.csd
<CsoundSynthesizer>
<CsOptions>
-iadc -odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
; -- size for 5 seconds of recording control data
giControl ftgen 0, 0, -5*kr, 2, 0
; -- size for 5 seconds of recording audio data
giAudio ftgen 0, 0, -5*sr, 2, 0
giWave ftgen 0, 0, 2^10, 10, 1, .5, .3, .1; waveform for oscillator
seed 0
; -- ;recording of a random frequency movement for 5 seconds, and playing it
instr 1
kFreq randomi 400, 1000, 1; random frequency
aSnd poscil .2, kFreq, giWave; play it
outs aSnd, aSnd
;;record the k-signal with a phasor as index
prints "RECORDING RANDOM CONTROL SIGNAL!%n"
;create a writing pointer in the table,
;moving in 5 seconds from index 0 to the end
kindx phasor 1/5
;write the k-signal
tablew kFreq, kindx, giControl, 1
endin
instr 2; read the values of the table and play it with poscil
prints "PLAYING CONTROL SIGNAL!%n"
kFreq poscil 1, 1/5, giControl
aSnd poscil .2, kFreq, giWave; play it
outs aSnd, aSnd
endin
instr 3; record live input
ktim timeinsts ; playing time of the instrument in seconds
prints "PLEASE GIVE YOUR LIVE INPUT AFTER THE BEEP!%n"
kBeepEnv linseg 0, 1, 0, .01, 1, .5, 1, .01, 0
aBeep oscils .2, 600, 0
outs aBeep*kBeepEnv, aBeep*kBeepEnv
;;record the audiosignal after 2 seconds
if ktim > 2 then
ain inch 1
printks "RECORDING LIVE INPUT!%n", 10
;create a writing pointer in the table,
;moving in 5 seconds from index 0 to the end
aindx phasor 1/5
;write the k-signal
tablew ain, aindx, giAudio, 1
endif
endin
instr 4; read the values from the table and play it with poscil
prints "PLAYING LIVE INPUT!%n"
aSnd poscil .5, 1/5, giAudio
outs aSnd, aSnd
endin
</CsInstruments>
<CsScore>
i 1 0 5
i 2 6 5
i 3 12 7
i 4 20 5
</CsScore>
</CsoundSynthesizer>
Saving the Contents of a Function Table to a File
A function table exists only as long as you run the Csound instance which has created it. If Csound terminates, all the data is lost. If you want to save the data for later use, you must write them to a file. There are several cases, depending firstly on whether you write at i-time or at k-time and secondly on what kind of file you want to write to.
Una tabla de funciones sólo existe mientras ejecute la instancia de Csound que la ha creado. Si Csound termina, todos los datos se pierden. Si desea guardar los datos para su uso posterior, debe escribirlos en un archivo. Hay varios casos, dependiendo en primer lugar de si se escribe en i-time o en k-time y en segundo lugar en qué tipo de archivo que desea escribir.
Writing a File in Csound's ftsave Format at i-Time or k-Time
Any function table in Csound can be easily written to a file using the ftsave (i-time) or ftsavek (k-time) opcode. Their use is very simple. The first argument specifies the filename (in double quotes), the second argument selects between a text format (non zero) or a binary format (zero) output. Finally you just provide the number of the function table(s) to save.
Cualquier tabla de funciones en Csound se puede escribir fácilmente en un archivo usando el opcode ftsave (i-time) o ftsavek (k-time). Su uso es muy simple. El primer argumento especifica el nombre de archivo (entre comillas dobles), el segundo argumento selecciona entre un formato de texto (no cero) o un formato binario (cero). Por último, sólo proporcione el número de la (s) tabla (s) de funciones a guardar.
With the following example, you should end up with two textfiles in the same folder as your .csd: "i-time_save.txt" saves function table 1 (a sine wave) at i-time; "k-time_save.txt" saves function table 2 (a linear increment produced during the performance) at k-time.
Con el siguiente ejemplo, debe terminar con dos archivos de texto en la misma carpeta que su .csd: i-time_save.txt guarda la tabla de funciones 1 (una onda senoidal) en i-time; K-time_save.txt guarda la tabla de funciones 2 (un incremento lineal producido durante la ejecución) en k-tiempo.
EXAMPLE 03D09_ftsave.csd
<CsoundSynthesizer>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
giWave ftgen 1, 0, 2^7, 10, 1; sine with 128 points
giControl ftgen 2, 0, -kr, 2, 0; size for 1 second of recording control data
seed 0
instr 1; saving giWave at i-time
ftsave "i-time_save.txt", 1, 1
endin
instr 2; recording of a line transition between 0 and 1 for one second
kline linseg 0, 1, 1
tabw kline, kline, giControl, 1
endin
instr 3; saving giWave at k-time
ftsave "k-time_save.txt", 1, 2
endin
</CsInstruments>
<CsScore>
i 1 0 0
i 2 0 1
i 3 1 .1
</CsScore>
</CsoundSynthesizer>
The counterpart to ftsave/ftsavek are the ftload/ftloadk opcodes. You can use them to load the saved files into function tables.
La contrapartida de ftsave / ftsavek son los opcodes ftload / ftloadk. Puede utilizarlos para cargar los archivos guardados en tablas de funciones.
Writing a Soundfile from a Recorded Function Table
If you have recorded your live-input to a buffer, you may want to save your buffer as a soundfile. There is no opcode in Csound which does that, but it can be done by using a k-rate loop and the fout opcode. This is shown in the next example in instrument 2. First instrument 1 records your live input. Then instrument 2 creates a soundfile "testwrite.wav" containing this audio in the same folder as your .csd. This is done at the first k-cycle of instrument 2, by repeatedly reading the table values and writing them as an audio signal to disk. After this is done, the instrument is turned off by executing the turnoff statement.
Si ha grabado su entrada en directo en un búfer, puede guardar su búfer como un archivo de sonido. No hay código de operación en Csound que lo haga, pero se puede hacer usando un bucle k-rate y el opcode fout. Esto se muestra en el siguiente ejemplo en el instrumento 2. El primer instrumento 1 registra su entrada en vivo. Luego el instrumento 2 crea un archivo de sonido testwrite.wav que contiene este audio en la misma carpeta que su .csd. Esto se hace en el primer ciclo k del instrumento 2, leyendo repetidamente los valores de la tabla y escribiéndolos como una señal de audio en el disco. Una vez hecho esto, el instrumento se apaga ejecutando la instrucción de apagado.
EXAMPLE 03D10_Table_to_soundfile.csd
<CsoundSynthesizer>
<CsOptions>
-i adc
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
; -- size for 5 seconds of recording audio data
giAudio ftgen 0, 0, -5*sr, 2, 0
instr 1 ;record live input
ktim timeinsts ; playing time of the instrument in seconds
prints "PLEASE GIVE YOUR LIVE INPUT AFTER THE BEEP!%n"
kBeepEnv linseg 0, 1, 0, .01, 1, .5, 1, .01, 0
aBeep oscils .2, 600, 0
outs aBeep*kBeepEnv, aBeep*kBeepEnv
;;record the audiosignal after 2 seconds
if ktim > 2 then
ain inch 1
printks "RECORDING LIVE INPUT!%n", 10
;create a writing pointer in the table,
;moving in 5 seconds from index 0 to the end
aindx phasor 1/5
;write the k-signal
tablew ain, aindx, giAudio, 1
endif
endin
instr 2; write the giAudio table to a soundfile
Soutname = "testwrite.wav"; name of the output file
iformat = 14; write as 16 bit wav file
itablen = ftlen(giAudio); length of the table in samples
kcnt init 0; set the counter to 0 at start
loop:
kcnt = kcnt+ksmps; next value (e.g. 10 if ksmps=10)
andx interp kcnt-1; calculate audio index (e.g. from 0 to 9)
asig tab andx, giAudio; read the table values as audio signal
fout Soutname, iformat, asig; write asig to a file
if kcnt <= itablen-ksmps kgoto loop; go back as long there is something to do
turnoff ; terminate the instrument
endin
</CsInstruments>
<CsScore>
i 1 0 7
i 2 7 .1
</CsScore>
</CsoundSynthesizer>
This code can also be used in the form of a User Defined Opcode. It can be found here.
Este código también puede utilizarse en forma de un código de usuario definido por el usuario. Se puede encontrar aquí.
Other GEN Routine Highlights
GEN05, GEN07, GEN25, GEN27 and GEN16 are useful for creating envelopes. GEN07 and GEN27 create functions table in the manner of the linseg opcode - with GEN07 the user defines segment duration whereas in GEN27 the user defines the absolute time for each breakpoint from the beginning of the envelope. GEN05 and GEN25 operate similarly to GEN07 and GEN27 except that envelope segments are exponential in shape. GEN16 also create an envelope in breakpoint fashion but it allows the user to specify the curvature of each segment individually (concave - straight - convex).
GEN17, GEN41 y GEN42 se utilizan las funciones generadoras de tipo histograma que pueden resultar útiles en la composición algorítmica y trabajar con probabilidades.
GEN09 and GEN19 are developments of GEN10 and are useful in additive synthesis.
GEN09 y GEN19 son desarrollos de GEN10 y son útiles en síntesis aditiva.
GEN11 es una versión de rutina GEN del código de operación gbuzz y como es una forma de onda fija (a diferencia de gbuzz) puede ser una fuente de sonido útil y eficiente en síntesis sustractiva.
GEN08
f # time size 8 a n1 b n2 c n3 d ...
GEN08 creates a curved function that forms the smoothest possible line between a sequence of user defined break-points. This GEN routine can be useful for the creation of window functions for use as envelope shapes or in granular synthesis. In forming a smooth curve, GEN08 may create apexes that extend well above or below any of the defined values. For this reason GEN08 is mostly used with post-normalisation turned on, i.e. a minus sign is not added to the GEN number when the function table is defined. Here are some examples of GEN08 tables:
GEN08 crea una función curvada que forma la línea más lisa posible entre una secuencia de puntos de ruptura definidos por el usuario. Esta rutina GEN puede ser útil para la creación de funciones de ventana para su uso como formas de envolvente o en síntesis granular. Al formar una curva suave, GEN08 puede crear ápices que se extienden bien por encima o por debajo de cualquiera de los valores definidos. Por esta razón GEN08 se utiliza principalmente con post-normalización activada, es decir, un signo menos no se añade al número GEN cuando se define la tabla de funciones. Estos son algunos ejemplos de tablas GEN08:
f 1 0 1024 8 0 1 1 1023 0
f 2 0 1024 8 0 97 1 170 0.583 757 0
f 3 0 1024 8 0 1 0.145 166 0.724 857 0
f 4 0 1024 8 0 1 0.079 96 0.645 927 0
GEN16
f # time size 16 val1 dur1 type1 val2 [dur2 type2 val3 ... typeX valN]
GEN16 allows the creation of envelope functions using a sequence of user defined breakpoints. Additionally for each segment of the envelope we can define a curvature. The nature of the curvature – concave or convex – will also depend upon the direction of the segment: rising or falling. For example, positive curvature values will result in concave curves in rising segments and convex curves in falling segments. The opposite applies if the curvature value is negative. Below are some examples of GEN16 function tables:
GEN16 permite la creación de funciones de envolvente utilizando una secuencia de puntos de interrupción definidos por el usuario. Además, para cada segmento del sobre podemos definir una curvatura. La naturaleza de la curvatura - cóncava o convexa - también dependerá de la dirección del segmento: subiendo o bajando. Por ejemplo, los valores de curvatura positiva darán lugar a curvas cóncavas en segmentos ascendentes y curvas convexas en segmentos descendentes. Lo contrario se aplica si el valor de curvatura es negativo. A continuación se presentan algunos ejemplos de tablas de funciones GEN16:
f 1 0 1024 16 0 512 20 1 512 20 0
f 2 0 1024 16 0 512 4 1 512 4 0
f 3 0 1024 16 0 512 0 1 512 0 0
f 4 0 1024 16 0 512 -4 1 512 -4 0
f 5 0 1024 16 0 512 -20 1 512 -20 0
GEN19
f # time size 19 pna stra phsa dcoa pnb strb phsb dcob ...
GEN19 follows on from GEN10 and GEN09 in terms of complexity and control options. It shares the basic concept of generating a harmonic waveform from stacked sinusoids but in addition to control over the strength of each partial (GEN10) and the partial number and phase (GEN09) it offers control over the DC offset of each partial. In addition to the creation of waveforms for use by audio oscillators other applications might be the creation of functions for LFOs and window functions for envelopes in granular synthesis. Below are some examples of GEN19:
GEN19 sigue a GEN10 y GEN09 en términos de complejidad y opciones de control. Comparte el concepto básico de generar una forma de onda armónica a partir de sinusoides apilados, pero además de controlar la fuerza de cada parte (GEN10) y el número parcial y fase (GEN09) ofrece control sobre el offset DC de cada parcial. Además de la creación de formas de onda para uso de osciladores de audio, otras aplicaciones podrían ser la creación de funciones para LFOs y funciones de ventana para sobres en síntesis granular. A continuación se presentan algunos ejemplos de GEN19:
f 1 0 1024 19 1 1 0 0 20 0.1 0 0
f 2 0 1024 -19 0.5 1 180 1
GEN30
f # time size 30 src minh maxh [ref_sr] [interp]
GEN30 uses FFT to create a band-limited version of a source waveform without band-limiting. We can create a sawtooth waveform by drawing one explicitly using GEN07 by used as an audio waveform this will create problems as it contains frequencies beyond the Nyquist frequency therefore will cause aliasing, particularly when higher notes are played. GEN30 can analyse this waveform and create a new one with a user defined lowest and highest partial. If we know what note we are going to play we can predict what the highest partial below the Nyquist frequency will be. For a given frequency, freq, the maximum number of harmonics that can be represented without aliasing can be derived using sr / (2 * freq). Here are some examples of GEN30 function tables (the first table is actually a GEN07 generated sawtooth, the second two are GEN30 band-limited versions of the first):
GEN30 utiliza FFT para crear una versión limitada de banda de una forma de onda de fuente sin límite de banda. Podemos crear una forma de onda de diente de sierra dibujando uno explícitamente utilizando GEN07 por utilizado como una forma de onda de audio esto creará problemas ya que contiene frecuencias más allá de la frecuencia Nyquist por lo tanto, causará aliasing, sobre todo cuando se tocan notas más altas. GEN30 puede analizar esta forma de onda y crear una nueva con un parcial más bajo y más alto definido por el usuario. Si sabemos qué nota vamos a tocar, podemos predecir cuál será la parte más alta por debajo de la frecuencia de Nyquist. Para una frecuencia dada, freq, el número máximo de armónicos que se pueden representar sin aliasing se puede derivar usando sr / (2 * freq). Aquí hay algunos ejemplos de tablas de funciones GEN30 (la primera tabla es en realidad un GENO7 generado en dientes de sierra, el segundo dos son GEN30 bandas limitadas versiones de la primera):
f 1 0 1024 7 1 1024 -1
f 2 0 1024 30 1 1 20
f 3 0 1024 30 1 2 20
Related Opcodes
ftgen: Creates a function table in the orchestra using any GEN Routine.
Ftgen: Crea una tabla de funciones en la orquesta usando cualquier rutina GEN.
Table / tablei / table3: Lea los valores de una tabla de funciones en cualquier caso, ya sea por indexación directa (tabla), o por interpolación lineal (tablei) o cúbica (tabla3). Estos opcodes ofrecen muchas opciones y son seguros debido a la comprobación de límites, pero es posible que tenga problemas con tablas que no sean de potencia de dos.
tab_i / tab: Read values from a function table at i-rate (tab_i), k-rate or a-rate (tab). Offer no interpolation and less options than the table opcodes, but they work also for non-power-of-two tables. They do not provide a boundary check, which makes them fast but also give the user the resposability not reading any value off the table boundaries.
tableiw / tablew: Write values to a function table at i-rate (tableiw), k-rate and a-rate (tablew). These opcodes provide many options and are safe because of boundary check, but you may have problems with non-power-of-two tables.
tabw_i / tabw: Write values to a function table at i-rate (tabw_i), k-rate or a-rate (tabw). Offer less options than the tableiw/tablew opcodes, but work also for non-power-of-two tables. They do not provide a boundary check, which makes them fast but also give the user the resposability not writing any value off the table boundaries.
Tab_i / tab: Leer los valores de una tabla de funciones en i-rate (tab_i), k-rate o a-rate (tab). No ofrecen interpolación y menos opciones que los opcodes de tabla, pero también funcionan para tablas que no son de potencia de dos. No proporcionan una comprobación de límites, lo que los hace rápidos, pero también dan al usuario la resposabilidad de no leer ningún valor fuera de los límites de la tabla.
Tableiw / tablew: Escribe valores en una tabla de funciones en i-rate (tableiw), k-rate y a-rate (tablew). Estos opcodes ofrecen muchas opciones y son seguros debido a la comprobación de límites, pero es posible que tenga problemas con tablas que no sean de potencia de dos.
Tabw_i / tabw: Escribe valores en una tabla de funciones en i-rate (tabw_i), k-rate o a-rate (tabw). Ofrecen menos opciones que los opcodes tableiw / tablew, pero también trabajan para tablas que no sean de potencia de dos. No proporcionan una comprobación de límites, lo que los hace rápidos, sino que también le dan al usuario la responsabilidad de no escribir ningún valor fuera de los límites de la tabla.
Poscil / poscil3: Osciladores precisos para leer las tablas de funciones en k o a-tasa, con interpolación lineal (poscil) o cúbica (poscil3). También admiten tablas que no son de potencia de dos, por lo que usualmente se recomienda usarlas en lugar de las viejas opcodes oscili / oscil3. Poscil también tiene una entrada de frecuencia para la amplitud y la frecuencia, mientras que poscil3 tiene sólo k-tasa de entrada.
Oscili / oscil3: Los osciladores estándar en Csound para leer las tablas de función en k o a-tasa, con interpolación lineal (oscili) o cúbica (oscil3). Apoyan todas las velocidades para la entrada de amplitud y frecuencia, pero se limitan a las tablas power-of-two. Particularmente para tablas largas y frecuencias bajas no son tan precisas como los poscil / poscil3 osciladores.
Ftsave / ftsavek: Guarda una tabla de funciones como un archivo, en i-time (ftsave) o k-time (ftsavek). Esto puede ser un archivo de texto o un archivo binario, pero no un archivo de sonido. Si desea guardar un archivo de sonido, utilice el Opcode definido por el usuario TableToSF.
ftload / ftloadk: Load a function table which has been written by ftsave/ftsavek.
Ftload / ftloadk: Carga una tabla de funciones que ha sido escrita por ftsave / ftsavek.
Line / linseg / fasor: Puede usarse para crear valores de índice que son necesarios para leer / escribir k-o-señales con los códigos de tabla / tablew o tab / tabw.
- ftgen is preferred mainly because you can refer to the function table by a variable name and must not deal with constant tables numbers. This will enhance the portability of orchestras and better facilitate the combining of multiple orchestras. It can also enhance the readability of an orchestra if a function table is located in the code nearer the instrument that uses it.^
- If your .csd file is, for instance, in the directory /home/jh/csound, and your sound file in the directory /home/jh/samples, you should add this inside the <CsOptions> tag:
--env:SSDIR+=/home/jh/samples. This means: 'Look also in /home/jh/sample as Sound Sample Directory (SSDIR)'
^ - For a general introduction about interpolation, see for instance http://en.wikipedia.org/wiki/Interpolation^
varname, ifn, itime: These arguments have the same meaning as explained above in reference to GEN02. Note that on this occasion the function table number (ifn) has been defined using a zero. This means that Csound will automatically assign a unique function table number. This number will also be held by the variable giFile which we will normally use to reference the function table anyway so its actual value will not be important to us. If you are interested you can print the value of giFile (ifn) out. If no other tables are defined, it will be 101 and subsequent tables, also using automatically assigned table numbers, will follow accordingly: 102, 103 etc.