CSOUND Español
LIVE EVENTS
The basic concept of Csound from the early days of the program is still valid and useful because it is a musically familiar one: you create a set of instruments and instruct them to play at various times. These calls of instrument instances, and their execution, are called "instrument events".
El concepto básico de Csound desde los primeros días del programa sigue siendo válido y útil porque es musicalmente familiar: se crea un conjunto de instrumentos y se les instruye a jugar en diferentes momentos. Estos llamados de instancias instrumentales, y su ejecución, se llaman eventos instrumentales.
Whenever any Csound code is executed, it has to be compiled first. Since Csound6, you can change the code of any running Csound instance, and recompile it on the fly. There are basically two opcodes for this "live coding": compileorc re-compiles any existing orc file, whereas compilestr compiles any string. At the end of this chapter, we will present some simple examples for both methods, followed by a description how to re-compile code on the fly in CsoundQt.
Cada vez que se ejecuta un código Csound, primero se debe compilar. Desde Csound6, puede cambiar el código de cualquier instancia de Csound en ejecución, y volver a compilarlo sobre la marcha. Existen básicamente dos opcodes para esta codificación en vivo: compileorc vuelve a compilar cualquier archivo orc existente, mientras compilestr compila cualquier cadena. Al final de este capítulo, presentaremos algunos ejemplos sencillos para ambos métodos, seguidos de una descripción de cómo volver a compilar el código al vuelo en CsoundQt.
The scheme of instruments and events can be instigated in a number of ways. In the classical approach you think of an "orchestra" with a number of musicians playing from a "score", but you can also trigger instruments using any kind of live input: from MIDI, from OSC, from the command line, from a GUI (such as Csound's FLTK widgets or CsoundQt's widgets), from the API (also used in CsoundQt's Live Event Sheet). Or you can create a kind of "master instrument", which is always on, and triggers other instruments using opcodes designed for this task, perhaps under certain conditions: if the live audio input from a singer has been detected to have a base frequency greater than 1043 Hz, then start an instrument which plays a soundfile of broken glass...
El esquema de instrumentos y eventos puede ser instigado de varias maneras. En el enfoque clásico se piensa en una orquesta con un número de músicos que juegan a partir de una partitura, pero también se puede activar instrumentos con cualquier tipo de entrada en vivo: desde MIDI, desde OSC, desde la línea de comandos, desde una GUI (como Csounds Widgets FLTK o widgets CsoundQts), desde la API (también utilizada en la hoja de eventos en vivo de CsoundQts). O puede crear un tipo de instrumento maestro, que está siempre encendido, y dispara otros instrumentos usando opcodes diseñados para esta tarea, tal vez bajo ciertas condiciones: si se ha detectado que la entrada de audio en vivo de un cantante tiene una frecuencia base superior a 1043 Hz, a continuación, iniciar un instrumento que reproduce un soundfile de vidrio roto ...
Order of Execution Revisited
Whatever you do in Csound with instrument events, you must bear in mind the order of execution that has been explained in the first chapter of this section about the Initialization and Performance Pass: instruments are executed one by one, both in the initialization pass and in each control cycle, and the order is determined by the instrument number.
Sea lo que sea que hagas en Csound con eventos de instrumentos, debes tener en cuenta el orden de ejecución que se ha explicado en el primer capítulo de esta sección sobre el paso de inicialización y rendimiento: los instrumentos se ejecutan uno por uno, tanto en el paso de inicialización como en Cada ciclo de control, y el orden se determina por el número del instrumento.
It is worth to have a closer look to what is happening exactly in time if you trigger an instrument from inside another instrument. The first example shows the result when instrument 2 triggers instrument 1 and instrument 3 at init-time.
Vale la pena tener una mirada más cercana a lo que está sucediendo exactamente en el tiempo si se dispara un instrumento desde dentro de otro instrumento. El primer ejemplo muestra el resultado cuando el instrumento 2 activa el instrumento 1 y el instrumento 3 a init-time.
EXAMPLE 03F01_OrderOfExc_event_i.csd
<CsoundSynthesizer> <CsOptions> -nm0 </CsOptions> <CsInstruments> sr = 44100 ksmps = 441 instr 1 kCycle timek prints "Instrument 1 is here at initialization.\n" printks "Instrument 1: kCycle = %d\n", 0, kCycle endin instr 2 kCycle timek prints " Instrument 2 is here at initialization.\n" printks " Instrument 2: kCycle = %d\n", 0, kCycle event_i "i", 3, 0, .02 event_i "i", 1, 0, .02 endin instr 3 kCycle timek prints " Instrument 3 is here at initialization.\n" printks " Instrument 3: kCycle = %d\n", 0, kCycle endin </CsInstruments> <CsScore> i 2 0 .02 </CsScore> </CsoundSynthesizer> ;example by joachim heintz
This is the output:
Instrument 2 is here at initialization.
Instrument 3 is here at initialization.
Instrument 1 is here at initialization.
Instrument 1: kCycle = 1
Instrument 2: kCycle = 1
Instrument 3: kCycle = 1
Instrument 1: kCycle = 2
Instrument 2: kCycle = 2
Instrument 3: kCycle = 2
Instrument 2 is the first one to initialize, because it is the only one which is called by the score. Then instrument 3 is initialized, because it is called first by instrument 2. The last one is instrument 1. All this is done before the actual performance begins. In the performance itself, starting from the first control cycle, all instruments are executed by their order.
El Instrumento 2 es el primero en inicializar, porque es el único que es llamado por la partitura. Entonces se inicializa el instrumento 3, porque es llamado primero por el instrumento 2. El último es el instrumento 1. Todo esto se hace antes de que empiece el funcionamiento real. En el propio funcionamiento, a partir del primer ciclo de control, todos los instrumentos se ejecutan por su orden.
Let us compare now what is happening when instrument 2 calls instrument 1 and 3 during the performance (= at k-time):
Comparemos ahora lo que está sucediendo cuando el instrumento 2 llama al instrumento 1 y 3 durante el desempeño (= en k-tiempo):
EXAMPLE 03F02_OrderOfExc_event_k.csd
<CsoundSynthesizer> <CsOptions> -nm0 </CsOptions> <CsInstruments> sr = 44100 ksmps = 441 0dbfs = 1 nchnls = 1 instr 1 kCycle timek prints "Instrument 1 is here at initialization.\n" printks "Instrument 1: kCycle = %d\n", 0, kCycle endin instr 2 kCycle timek prints " Instrument 2 is here at initialization.\n" printks " Instrument 2: kCycle = %d\n", 0, kCycle if kCycle == 1 then event "i", 3, 0, .02 event "i", 1, 0, .02 endif printks " Instrument 2: still in kCycle = %d\n", 0, kCycle endin instr 3 kCycle timek prints " Instrument 3 is here at initialization.\n" printks " Instrument 3: kCycle = %d\n", 0, kCycle endin instr 4 kCycle timek prints " Instrument 4 is here at initialization.\n" printks " Instrument 4: kCycle = %d\n", 0, kCycle endin </CsInstruments> <CsScore> i 4 0 .02 i 2 0 .02 </CsScore> </CsoundSynthesizer> ;example by joachim heintz
This is the output:
Instrument 2 is here at initialization.
Instrument 4 is here at initialization.
Instrument 2: kCycle = 1
Instrument 2: still in kCycle = 1
Instrument 4: kCycle = 1
Instrument 3 is here at initialization.
Instrument 1 is here at initialization.
Instrument 1: kCycle = 2
Instrument 2: kCycle = 2
Instrument 2: still in kCycle = 2
Instrument 3: kCycle = 2
Instrument 4: kCycle = 2
Instrument 2 starts with its init-pass, and then instrument 4 is initialized. As you see, the reverse order of the scorelines has no effect; the instruments which start at the same time are executed in ascending order, depending on their numbers.
El instrumento 2 comienza con su init-pass y luego se inicializa el instrumento 4. Como puede ver, el orden inverso de los resultados no tiene ningún efecto; Los instrumentos que comienzan al mismo tiempo se ejecutan en orden ascendente, dependiendo de sus números.
In this first cycle, instrument 2 calls instrument 3 and 1. As you see by the output of instrument 4, the whole control cycle is finished first, before instrument 3 and 1 (in this order) are initialized.1 These both instruments start their performance in cycle number two, where they find themselves in the usual order: instrument 1 before instrument 2, then instrument 3 before instrument 4.
En este primer ciclo, el instrumento 2 llama a los instrumentos 3 y 1. Como se ve por la salida del instrumento 4, todo el ciclo de control se termina primero, antes de que se inicialicen los instrumentos 3 y 1 (en este orden). Rendimiento en el ciclo número dos, donde se encuentran en el orden habitual: instrumento 1 antes instrumento 2, luego instrumento 3 antes instrumento 4.
Usually you will not need to know all of this with such precise timing. But in case you experience any problems, a clearer awareness of the process may help.
Por lo general, no necesitará saber todo esto con un calendario tan preciso. Pero en caso de que experimente algún problema, una conciencia más clara del proceso puede ayudar.
Instrument Events From The Score
This is the classical way of triggering instrument events: you write a list in the score section of a .csd file. Each line which begins with an "i", is an instrument event. As this is very simple, and examples can be found easily, let us focus instead on some additional features which can be useful when you work in this way. Documentation for these features can be found in the Score Statements section of the Canonical Csound Reference Manual. Here are some examples:
Esta es la forma clásica de activar eventos de instrumentos: escribe una lista en la sección de puntuación de un archivo .csd. Cada línea que comienza con un i, es un evento de instrumento. Como esto es muy simple, y los ejemplos se pueden encontrar fácilmente, nos centramos en cambio en algunas características adicionales que pueden ser útiles cuando se trabaja de esta manera. La documentación de estas características se puede encontrar en la sección \Documentation for these features can be found in the Score Statements section of the Canonical Csound Reference Manual.Here are some examples:
EXAMPLE 03F03_Score_tricks.csd
<CsoundSynthesizer>
<CsOptions>
-odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
giWav ftgen 0, 0, 2^10, 10, 1, .5, .3, .1
instr 1
kFadout init 1
krel release ;returns "1" if last k-cycle
if krel == 1 && p3 < 0 then ;if so, and negative p3:
xtratim .5 ;give 0.5 extra seconds
kFadout linseg 1, .5, 0 ;and make fade out
endif
kEnv linseg 0, .01, p4, abs(p3)-.1, p4, .09, 0; normal fade out
aSig poscil kEnv*kFadout, p5, giWav
outs aSig, aSig
endin
</CsInstruments>
<CsScore>
t 0 120 ;set tempo to 120 beats per minute
i 1 0 1 .2 400 ;play instr 1 for one second
i 1 2 -10 .5 500 ;play instr 1 indefinetely (negative p3)
i -1 5 0 ;turn it off (negative p1)
; -- turn on instance 1 of instr 1 one sec after the previous start
i 1.1 ^+1 -10 .2 600
i 1.2 ^+2 -10 .2 700 ;another instance of instr 1
i -1.2 ^+2 0 ;turn off 1.2
; -- turn off 1.1 (dot = same as the same p-field above)
i -1.1 ^+1 .
s ;end of a section, so time begins from new at zero
i 1 1 1 .2 800
r 5 ;repeats the following line (until the next "s")
i 1 .25 .25 .2 900
s
v 2 ;lets time be double as long
i 1 0 2 .2 1000
i 1 1 1 .2 1100
s
v 0.5 ;lets time be half as long
i 1 0 2 .2 1200
i 1 1 1 .2 1300
s ;time is normal now again
i 1 0 2 .2 1000
i 1 1 1 .2 900
s
; -- make a score loop (4 times) with the variable "LOOP"
{4 LOOP
i 1 [0 + 4 * $LOOP.] 3 .2 [1200 - $LOOP. * 100]
i 1 [1 + 4 * $LOOP.] 2 . [1200 - $LOOP. * 200]
i 1 [2 + 4 * $LOOP.] 1 . [1200 - $LOOP. * 300]
}
e
</CsScore>
</CsoundSynthesizer>
Triggering an instrument with an indefinite duration by setting p3 to any negative value, and stopping it by a negative p1 value, can be an important feature for live events. If you turn instruments off in this way you may have to add a fade out segment. One method of doing this is shown in the instrument above with a combination of the release and the xtratim opcodes. Also note that you can start and stop certain instances of an instrument with a floating point number as p1.
Disparar un instrumento con una duración indefinida ajustando p3 a cualquier valor negativo, y detenerlo por un valor p1 negativo, puede ser una característica importante para eventos en vivo. Si apaga los instrumentos de esta manera puede que tenga que agregar un segmento de fundido. Un método para hacer esto se muestra en el instrumento anterior con una combinación de los códigos de liberación y el xtratim. También tenga en cuenta que puede iniciar y detener ciertas instancias de un instrumento con un número de punto flotante como p1.
Using MIDI Note-On Events
Csound has a particular feature which makes it very simple to trigger instrument events from a MIDI keyboard. Each MIDI Note-On event can trigger an instrument, and the related Note-Off event of the same key stops the related instrument instance. This is explained more in detail in the chapter Triggering Instrument Instances in the MIDI section of this manual. Here, just a small example is shown. Simply connect your MIDI keyboard and it should work.
Csound tiene una característica particular que hace que sea muy sencillo disparar eventos de instrumentos desde un teclado MIDI. Cada evento MIDI Note-On puede activar un instrumento, y el evento Note-Off relacionado de la misma tecla detiene la instancia del instrumento relacionado. Esto se explica más detalladamente en el capítulo Triggering Instrument Instances en la sección MIDI de este manual. Aquí, sólo un pequeño ejemplo se muestra. Simplemente conecte su teclado MIDI y debería funcionar.
EXAMPLE 03F04_Midi_triggered_events.csd
<CsoundSynthesizer>
<CsOptions>
-Ma -odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
giSine ftgen 0, 0, 2^10, 10, 1
massign 0, 1; assigns all midi channels to instr 1
instr 1
iFreq cpsmidi ;gets frequency of a pressed key
iAmp ampmidi 8 ;gets amplitude and scales 0-8
iRatio random .9, 1.1 ;ratio randomly between 0.9 and 1.1
aTone foscili .1, iFreq, 1, iRatio/5, iAmp+1, giSine ;fm
aEnv linenr aTone, 0, .01, .01 ; avoiding clicks at the note-end
outs aEnv, aEnv
endin
</CsInstruments>
<CsScore>
f 0 36000; play for 10 hours
e
</CsScore>
</CsoundSynthesizer>
Using Widgets
If you want to trigger an instrument event in realtime with a Graphical User Interface, it is usually a "Button" widget which will do this job. We will see here a simple example; first implemented using Csound's FLTK widgets, and then using CsoundQt's widgets.
Si desea activar un evento de instrumento en tiempo real con una interfaz gráfica de usuario, normalmente es un widget de botón que realizará este trabajo. Veremos aquí un ejemplo simple; Primero implementado utilizando widgets Csounds FLTK, y luego utilizando widgets CsoundQts.
FLTK Button
This is a very simple example demonstrating how to trigger an instrument using an FLTK button. A more extended example can be found here.
Este es un ejemplo muy simple que demuestra cómo activar un instrumento usando un botón FLTK. Un ejemplo más extenso se puede encontrar aquí.
EXAMPLE 03F05_FLTK_triggered_events.csd
<CsoundSynthesizer>
<CsOptions>
-odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
; -- create a FLTK panel --
FLpanel "Trigger By FLTK Button", 300, 100, 100, 100
; -- trigger instr 1 (equivalent to the score line "i 1 0 1")k1, ih1 FLbutton "Push me!", 0, 0, 1, 150, 40, 10, 25, 0, 1, 0, 1
; -- trigger instr 2
k2, ih2 FLbutton "Quit", 0, 0, 1, 80, 40, 200, 25, 0, 2, 0, 1
FLpanelEnd; end of the FLTK panel section
FLrun ; run FLTK
seed 0; random seed different each time
instr 1
idur random .5, 3; recalculate instrument duration
p3 = idur; reset instrument duration
ioct random 8, 11; random values between 8th and 11th octave
idb random -18, -6; random values between -6 and -18 dB
aSig poscil ampdb(idb), cpsoct(ioct)
aEnv transeg 1, p3, -10, 0
outs aSig*aEnv, aSig*aEnv
endin
instr 2
exitnow
endin
</CsInstruments>
<CsScore>
f 0 36000
e
</CsScore>
</CsoundSynthesizer>
Note that in this example the duration of an instrument event is recalculated when the instrument is initialised. This is done using the statement "p3 = i...". This can be a useful technique if you want the duration that an instrument plays for to be different each time it is called. In this example duration is the result of a random function'. The duration defined by the FLTK button will be overwritten by any other calculation within the instrument itself at i-time.
Tenga en cuenta que en este ejemplo la duración de un evento de instrumento se recalcula cuando se inicializa el instrumento. Esto se hace usando la instrucción p3 = i .... Esta puede ser una técnica útil si desea que la duración que un instrumento juega para ser diferente cada vez que se llama. En este ejemplo la duración es el resultado de una función aleatoria. La duración definida por el botón FLTK se sobrescribirá por cualquier otro cálculo dentro del propio instrumento en i-time.
CsoundQt Button
In CsoundQt, a button can be created easily from the submenu in a widget panel:
En CsoundQt, se puede crear fácilmente un botón desde el submenú en un panel de widgets:
In the Properties Dialog of the button widget, make sure you have selected "event" as Type. Insert a Channel name, and at the bottom type in the event you want to trigger - as you would if writing a line in the score.
En el cuadro de diálogo Propiedades del widget de botón, asegúrese de haber seleccionado el evento como Tipo. Inserte un nombre de canal y, en la parte inferior, escriba el evento que desee activar, como si escribiera una línea en la partitura.
In your Csound code, you need nothing more than the instrument you want to trigger:
En su código Csound, no necesita nada más que el instrumento que desea activar:
For more information about CsoundQt, read the CsoundQt chapter in the 'Frontends' section of this manual.
Para obtener más información acerca de CsoundQt, lea el capítulo CsoundQt en la sección de Frontends de este manual.
Using A Realtime Score
Command Line With The -L stdin Option
If you use any .csd with the option "-L stdin" (and the -odac option for realtime output), you can type any score line in realtime (sorry, this does not work for Windows). For instance, save this .csd anywhere and run it from the command line:
Si utiliza cualquier .csd con la opción -L stdin (y la opción -odac para la salida en tiempo real), puede escribir cualquier línea de puntuación en tiempo real (lo siento, esto no funciona para Windows). Por ejemplo, guarde este .csd en cualquier lugar y ejecútelo desde la línea de comandos:
EXAMPLE 03F06_Commandline_rt_events.csd
<CsoundSynthesizer>
<CsOptions>
-L stdin -odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
seed 0; random seed different each time
instr 1
idur random .5, 3; calculate instrument duration
p3 = idur; reset instrument duration
ioct random 8, 11; random values between 8th and 11th octave
idb random -18, -6; random values between -6 and -18 dB
aSig oscils ampdb(idb), cpsoct(ioct), 0
aEnv transeg 1, p3, -10, 0
outs aSig*aEnv, aSig*aEnv
endin
</CsInstruments>
<CsScore>
f 0 36000
e
</CsScore>
</CsoundSynthesizer>
If you run it by typing and returning a command line like this ...
Si lo ejecuta escribiendo y devolviendo una línea de comandos como esta ...
... you should get a prompt at the end of the Csound messages:
... debe recibir un mensaje al final de los mensajes Csound:
If you now type the line "i 1 0 1" and press return, you should hear that instrument 1 has been executed. After three times your messages may look like this:
Si ahora escribe la línea i 1 0 1 y pulsa return, debería escuchar que el instrumento 1 ha sido ejecutado. Después de tres veces sus mensajes pueden verse así:
CsoundQt's Live Event Sheet
In general, this is the method that CsoundQt uses and it is made available to the user in a flexible environment called the Live Event Sheet. Have a look in the CsoundQt frontend to see more of the possibilities of "firing" live instrument events using the Live Event Sheet.2
En general, este es el método que utiliza CsoundQt y se pone a disposición del usuario en un entorno flexible denominado Live Event Sheet. Echa un vistazo en el frontend de CsoundQt para ver más de las posibilidades de disparar eventos de instrumentos en vivo usando la Live Event Sheet.2
By Conditions
We have discussed first the classical method of triggering instrument events from the score section of a .csd file, then we went on to look at different methods of triggering real time events using MIDI, by using widgets, and by using score lines inserted live. We will now look at the Csound orchestra itself and to some methods by which an instrument can internally trigger another instrument. The pattern of triggering could be governed by conditionals, or by different kinds of loops. As this "master" instrument can itself be triggered by a realtime event, you have unlimited options available for combining the different methods.
Hemos discutido primero el método clásico de desencadenar eventos de instrumentos de la sección de puntuación de un archivo .csd, luego pasamos a mirar diferentes métodos de desencadenar eventos en tiempo real usando MIDI, usando widgets y usando líneas de puntuación insertadas en vivo. Ahora examinaremos la propia orquesta de Csound y algunos métodos mediante los cuales un instrumento puede activar internamente otro instrumento. El patrón de activación podría ser gobernado por condicionales, o por diferentes tipos de bucles. Como este instrumento maestro puede ser activado por un evento en tiempo real, tiene opciones ilimitadas disponibles para combinar los diferentes métodos.
Let's start with conditionals. If we have a realtime input, we may want to define a threshold, and trigger an event
Comencemos con condicionales. Si tenemos una entrada en tiempo real, es posible que desee definir un umbral, y desencadenar un evento
if we cross the threshold from below to above;
Si cruzamos el umbral de abajo hacia arriba;
if we cross the threshold from above to below.
Si cruzamos el umbral de arriba a abajo.
In Csound, this could be implemented using an orchestra of three instruments. The first instrument is the master instrument. It receives the input signal and investigates whether that signal is crossing the threshold and if it does whether it is crossing from low to high or from high to low. If it crosses the threshold from low ot high the second instrument is triggered, if it crosses from high to low the third instrument is triggered.
En Csound, esto podría ser implementado usando una orquesta de tres instrumentos. El primer instrumento es el instrumento maestro. Recibe la señal de entrada e investiga si esa señal está cruzando el umbral y si lo hace si está cruzando de baja a alta o de alta a baja. Si cruza el umbral desde el punto más bajo o el segundo instrumento se dispara, si cruza de alto a bajo, se dispara el tercer instrumento.
EXAMPLE 03F07_Event_by_condition.csd
<CsoundSynthesizer>
<CsOptions>
-iadc -odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
seed 0; random seed different each time
instr 1; master instrument
ichoose = p4; 1 = real time audio, 2 = random amplitude movement
ithresh = -12; threshold in dB
kstat init 1; 1 = under the threshold, 2 = over the threshold
;;CHOOSE INPUT SIGNAL
if ichoose == 1 then
ain inch 1
else
kdB randomi -18, -6, 1
ain pinkish ampdb(kdB)
endif
;;MEASURE AMPLITUDE AND TRIGGER SUBINSTRUMENTS IF THRESHOLD IS CROSSED
afoll follow ain, .1; measure mean amplitude each 1/10 second
kfoll downsamp afoll
if kstat == 1 && dbamp(kfoll) > ithresh then; transition down->up
event "i", 2, 0, 1; call instr 2
printks "Amplitude = %.3f dB%n", 0, dbamp(kfoll)
kstat = 2; change status to "up"
elseif kstat == 2 && dbamp(kfoll) < ithresh then; transition up->down
event "i", 3, 0, 1; call instr 3
printks "Amplitude = %.3f dB%n", 0, dbamp(kfoll)
kstat = 1; change status to "down"
endif
endin
instr 2; triggered if threshold has been crossed from down to up
asig poscil .2, 500
aenv transeg 1, p3, -10, 0
outs asig*aenv, asig*aenv
endin
instr 3; triggered if threshold has been crossed from up to down
asig poscil .2, 400
aenv transeg 1, p3, -10, 0
outs asig*aenv, asig*aenv
endin
</CsInstruments>
<CsScore>
i 1 0 1000 2 ;change p4 to "1" for live input
e
</CsScore>
</CsoundSynthesizer>
Using i-Rate Loops For Calculating A Pool Of Instrument Events
You can perform a number of calculations at init-time which lead to a list of instrument events. In this way you are producing a score, but inside an instrument. The score events are then executed later.
Puede realizar una serie de cálculos a init-time que llevan a una lista de eventos de instrumentos. De esta manera usted está produciendo una puntuación, pero dentro de un instrumento. Los eventos de puntuación se ejecutan posteriormente.
Using this opportunity we can introduce the scoreline / scoreline_i opcode. It is quite similar to the event / event_i opcode but has two major benefits:
Utilizando esta oportunidad, podemos introducir el código de operación scoreline / scoreline_i. Es muy similar al evento / event_i opcode, pero tiene dos grandes beneficios:
You can write more than one scoreline by using "{{" at the beginning and "}}" at the end.
Puede escribir más de un marcador utilizando {{al principio y}} al final.
You can send a string to the subinstrument (which is not possible with the event opcode).
Puede enviar una cadena al subinstrumento (lo cual no es posible con el opcode de evento).
Let's look at a simple example for executing score events from an instrument using the scoreline opcode:
Veamos un ejemplo sencillo para ejecutar eventos de puntuación desde un instrumento usando el código de operación de scoreline:
EXAMPLE 03F08_Generate_event_pool.csd
<CsoundSynthesizer>
<CsOptions>
-odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
seed 0; random seed different each time
instr 1 ;master instrument with event pool
scoreline_i {{i 2 0 2 7.09
i 2 2 2 8.04
i 2 4 2 8.03
i 2 6 1 8.04}}
endin
instr 2 ;plays the notes
asig pluck .2, cpspch(p4), cpspch(p4), 0, 1
aenv transeg 1, p3, 0, 0
outs asig*aenv, asig*aenv
endin
</CsInstruments>
<CsScore>
i 1 0 7
e
</CsScore>
</CsoundSynthesizer>
With good right, you might say: "OK, that's nice, but I can also write scorelines in the score itself!" That's right, but the advantage with the scoreline_i method is that you can render the score events in an instrument, and then send them out to one or more instruments to execute them. This can be done with the sprintf opcode, which produces the string for scoreline in an i-time loop (see the chapter about control structures).
Con la buena derecha, usted puede ser que diga: ¡OK, eso es agradable, pero puedo también escribir los scorelines en la cuenta sí mismo! Eso es correcto, pero la ventaja con el método scoreline_i es que puedes renderizar los eventos de puntuación en un instrumento y luego enviarlos a uno o más instrumentos para ejecutarlos. Esto se puede hacer con el código de operación sprintf, que produce la cadena para el scoreline en un bucle i-time (ver el capítulo sobre estructuras de control).
EXAMPLE 03F09_Events_sprintf.csd
<CsoundSynthesizer>
<CsOptions>
-odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
giPch ftgen 0, 0, 4, -2, 7.09, 8.04, 8.03, 8.04
seed 0; random seed different each time
instr 1 ; master instrument with event pool
itimes = 7 ;number of events to produce
icnt = 0 ;counter
istart = 0
Slines = ""
loop: ;start of the i-time loop
idur random 1, 2.9999 ;duration of each note:
idur = int(idur) ;either 1 or 2
itabndx random 0, 3.9999 ;index for the giPch table:
itabndx = int(itabndx) ;0-3
ipch table itabndx, giPch ;random pitch value from the table
Sline sprintf "i 2 %d %d %.2f\n", istart, idur, ipch ;new scoreline
Slines strcat Slines, Sline ;append to previous scorelines
istart = istart + idur ;recalculate start for next scoreline
loop_lt icnt, 1, itimes, loop ;end of the i-time loop
puts Slines, 1 ;print the scorelines
scoreline_i Slines ;execute them
iend = istart + idur ;calculate the total duration
p3 = iend ;set p3 to the sum of all durations
print p3 ;print it
endin
instr 2 ;plays the notes
asig pluck .2, cpspch(p4), cpspch(p4), 0, 1
aenv transeg 1, p3, 0, 0
outs asig*aenv, asig*aenv
endin
</CsInstruments>
<CsScore>
i 1 0 1 ;p3 is automatically set to the total duration
e
</CsScore>
</CsoundSynthesizer>
In this example, seven events have been rendered in an i-time loop in instrument 1. The result is stored in the string variable Slines. This string is given at i-time to scoreline_i, which executes them then one by one according to their starting times (p2), durations (p3) and other parameters.
En este ejemplo, se han representado siete eventos en un bucle i-time del instrumento 1. El resultado se almacena en la variable de cadena Slines. Esta cadena se da en i-time a scoreline_i, que los ejecuta uno a uno de acuerdo a sus tiempos de inicio (p2), duraciones (p3) y otros parámetros.
Instead of collecting all score lines in a single string, you can also execute them inside the i-time loop. Also in this way all the single score lines are added to Csound's event pool. The next example shows an alternative version of the previous one by adding the instrument events one by one in the i-time loop, either with event_i (instr 1) or with scoreline_i (instr 2):
En lugar de recoger todas las líneas de puntuación en una sola cadena, también puede ejecutarlas dentro del bucle i-time. También de esta manera todas las líneas de puntuación individuales se agregan al grupo de eventos Csounds. El siguiente ejemplo muestra una versión alternativa de la anterior agregando los eventos del instrumento uno por uno en el bucle i-time, ya sea con event_i (instr 1) o con scoreline_i (instr 2):
EXAMPLE 03F10_Events_collected.csd
<CsoundSynthesizer>
<CsOptions>
-odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
giPch ftgen 0, 0, 4, -2, 7.09, 8.04, 8.03, 8.04
seed 0; random seed different each time
instr 1; master instrument with event_i
itimes = 7; number of events to produce
icnt = 0; counter
istart = 0
loop: ;start of the i-time loop
idur random 1, 2.9999; duration of each note:
idur = int(idur); either 1 or 2
itabndx random 0, 3.9999; index for the giPch table:
itabndx = int(itabndx); 0-3
ipch table itabndx, giPch; random pitch value from the table
event_i "i", 3, istart, idur, ipch; new instrument event
istart = istart + idur; recalculate start for next scoreline
loop_lt icnt, 1, itimes, loop; end of the i-time loop
iend = istart + idur; calculate the total duration
p3 = iend; set p3 to the sum of all durations
print p3; print it
endin
instr 2; master instrument with scoreline_i
itimes = 7; number of events to produce
icnt = 0; counter
istart = 0
loop: ;start of the i-time loop
idur random 1, 2.9999; duration of each note:
idur = int(idur); either 1 or 2
itabndx random 0, 3.9999; index for the giPch table:
itabndx = int(itabndx); 0-3
ipch table itabndx, giPch; random pitch value from the table
Sline sprintf "i 3 %d %d %.2f", istart, idur, ipch; new scoreline
scoreline_i Sline; execute it
puts Sline, 1; print it
istart = istart + idur; recalculate start for next scoreline
loop_lt icnt, 1, itimes, loop; end of the i-time loop
iend = istart + idur; calculate the total duration
p3 = iend; set p3 to the sum of all durations
print p3; print it
endin
instr 3; plays the notes
asig pluck .2, cpspch(p4), cpspch(p4), 0, 1
aenv transeg 1, p3, 0, 0
outs asig*aenv, asig*aenv
endin
</CsInstruments>
<CsScore>
i 1 0 1
i 2 14 1
e
</CsScore>
</CsoundSynthesizer>
Using Time Loops
As discussed above in the chapter about control structures, a time loop can be built in Csound either with the timout opcode or with the metro opcode. There were also simple examples for triggering instrument events using both methods. Here, a more complex example is given: A master instrument performs a time loop (choose either instr 1 for the timout method or instr 2 for the metro method) and triggers once in a loop a subinstrument. The subinstrument itself (instr 10) performs an i-time loop and triggers several instances of a sub-subinstrument (instr 100). Each instance performs a partial with an independent envelope for a bell-like additive synthesis.
Como se analizó anteriormente en el capítulo sobre estructuras de control, se puede construir un bucle de tiempo en Csound con el código de operación de temporización o con el opcode de metro. También hubo ejemplos sencillos para desencadenar eventos de instrumentos utilizando ambos métodos. Aquí se presenta un ejemplo más complejo: Un instrumento maestro realiza un bucle de tiempo (elija instr 1 para el método timout o instr 2 para el método metro) y desencadena una vez en un bucle un subinstrumento. El propio subinstrumento (instr 10) realiza un bucle i-time y activa varias instancias de un subinstrumento (instr 100). Cada instancia realiza una partición con una envolvente independiente para una síntesis de aditivo similar a una campana.
EXAMPLE 03F11_Events_time_loop.csd
<CsoundSynthesizer>
<CsOptions>
-odac
</CsOptions>
<CsInstruments>
;Example by Joachim Heintz
sr = 44100
ksmps = 32
nchnls = 2
0dbfs = 1
seed 0
instr 1; time loop with timout. events are triggered by event_i (i-rate)
loop:
idurloop random 1, 4; duration of each loop
timout 0, idurloop, play
reinit loop
play:
idurins random 1, 5; duration of the triggered instrument
event_i "i", 10, 0, idurins; triggers instrument 10
endin
instr 2; time loop with metro. events are triggered by event (k-rate)
kfreq init 1; give a start value for the trigger frequency
kTrig metro kfreq
if kTrig == 1 then ;if trigger impulse:
kdur random 1, 5; random duration for instr 10
event "i", 10, 0, kdur; call instr 10
kfreq random .25, 1; set new value for trigger frequency
endif
endin
instr 10; triggers 8-13 partials
inumparts random 8, 14
inumparts = int(inumparts); 8-13 as integer
ibasoct random 5, 10; base pitch in octave values
ibasfreq = cpsoct(ibasoct)
ipan random .2, .8; random panning between left (0) and right (1)
icnt = 0; counter
loop:
event_i "i", 100, 0, p3, ibasfreq, icnt+1, inumparts, ipan
loop_lt icnt, 1, inumparts, loop
endin
instr 100; plays one partial
ibasfreq = p4; base frequency of sound mixture
ipartnum = p5; which partial is this (1 - N)
inumparts = p6; total number of partials
ipan = p7; panning
ifreqgen = ibasfreq * ipartnum; general frequency of this partial
ifreqdev random -10, 10; frequency deviation between -10% and +10%
; -- real frequency regarding deviation
ifreq = ifreqgen + (ifreqdev*ifreqgen)/100
ixtratim random 0, p3; calculate additional time for this partial
p3 = p3 + ixtratim; new duration of this partial
imaxamp = 1/inumparts; maximum amplitude
idbdev random -6, 0; random deviation in dB for this partial
iamp = imaxamp * ampdb(idbdev-ipartnum); higher partials are softer
ipandev random -.1, .1; panning deviation
ipan = ipan + ipandev
aEnv transeg 0, .005, 0, iamp, p3-.005, -10, 0
aSine poscil aEnv, ifreq
aL, aR pan2 aSine, ipan
outs aL, aR
prints "ibasfreq = %d, ipartial = %d, ifreq = %d%n",\
ibasfreq, ipartnum, ifreq
endin
</CsInstruments>
<CsScore>
i 1 0 300 ;try this, or the next line (or both)
;i 2 0 300
</CsScore>
</CsoundSynthesizer>
Which Opcode Should I Use?
Csound users are often confused about the variety of opcodes available to trigger instrument events. Should I use event, scoreline, schedule or schedkwhen? Should I use event or event_i?
Los usuarios de Csound suelen confundirse acerca de la variedad de opcodes disponibles para activar eventos de instrumentos. ¿Debo usar evento, scoreline, schedule o schedkwhen? ¿Debo usar event o event_i?
Let us start with the latter, which actually leads to the general question about "i-rate" and "k-rate" opcodes.3 In short: Using event_i (the i-rate version) will only trigger an event once, when the instrument in which this opcode works is initiated. Using event (the k-rate version) will trigger an event potentially again and again, as long as the instrument runs, in each control cycle. This is a very simple example:
Empezaremos por este último, que en realidad conduce a la pregunta general sobre los opcodes de tasa i y k-rate.3 En resumen: el uso de event_i (la versión i-rate) sólo activará un evento una vez, cuando el instrumento en el que Opcode funciona. El uso de evento (la versión k-rate) activará un evento potencialmente una y otra vez, mientras el instrumento funcione, en cada ciclo de control. Este es un ejemplo muy simple:
EXAMPLE 03F12_event_i_vs_event.csd
<CsoundSynthesizer> <CsOptions> -nm0 </CsOptions> <CsInstruments> sr=44100 ksmps = 32 ;set counters for the instances of Called_i and Called_k giInstCi init 1 giInstCk init 1 instr Call_i ;call another instrument at i-rate event_i "i", "Called_i", 0, 1 endin instr Call_k ;call another instrument at k-rate event "i", "Called_k", 0, 1 endin instr Called_i ;report that instrument starts and which instance prints "Instance #%d of Called_i is starting!\n", giInstCi ;increment number of instance for next instance giInstCi += 1 endin instr Called_k ;report that instrument starts and which instance prints " Instance #%d of Called_k is starting!\n", giInstCk ;increment number of instance for next instance giInstCk += 1 endin </CsInstruments> <CsScore> ;run "Call_i" for one second i "Call_i" 0 1 ;run "Call_k" for 1/100 seconds i "Call_k" 0 0.01 </CsScore> </CsoundSynthesizer> ;example by joachim heintz
Although instrument "Call_i" runs for one second, the call to instrument "Called_i" is only performed once, because it is done with event_i: at initialization only. But instrument "Call_k" calls one instance of "Called_k" in each control cycle; so for the duration of 0.01 seconds of running instrument "Call_k", fourteen instances of instrument "Called_k" are being started.4 So this is the output:
Aunque el instrumento Call_i se ejecuta durante un segundo, la llamada al instrumento Called_i sólo se realiza una vez, porque se realiza con event_i: sólo en la inicialización. Sin embargo, el instrumento Call_k llama a una instancia de Called_k en cada ciclo de control; Por lo que durante la duración de 0,01 segundos de ejecución del instrumento Call_k, se están iniciando catorce instancias del instrumento Called_k. Así que esta es la salida:
Instance #1 of Called_i is starting!
Instance #1 of Called_k is starting!
Instance #2 of Called_k is starting!
Instance #3 of Called_k is starting!
Instance #4 of Called_k is starting!
Instance #5 of Called_k is starting!
Instance #6 of Called_k is starting!
Instance #7 of Called_k is starting!
Instance #8 of Called_k is starting!
Instance #9 of Called_k is starting!
Instance #10 of Called_k is starting!
Instance #11 of Called_k is starting!
Instance #12 of Called_k is starting!
Instance #13 of Called_k is starting!
Instance #14 of Called_k is starting!
So the first (and probably most important) decision in asking "which opcode should I use", is the answer to the question: "Do I need an i-rate or a k-rate opcode?"
Así que la primera (y probablemente la más importante) decisión al preguntar qué opcode debo usar, es la respuesta a la pregunta: ¿Necesito un código de operación i-rate o k-rate?
i-rate Versions: schedule, event_i, scoreline_i
If you need an i-rate opcode to trigger an instrument event, schedule is the most basic choice. You use it actually exactly the same as writing any score event; just separting the parameter fields by commas rather by spaces:
Si necesita un opcode i-rate para activar un evento de instrumento, el programa es la opción más básica. Usted lo utiliza en realidad exactamente lo mismo que escribir cualquier evento de puntuación; Sólo separar los campos de parámetro por comas más bien por espacios:
schedule iInstrNum (or "InstrName"), iStart, iDur [, ip4] [, ip5] [...]
event_i is very similar:
event_i es muy similar:
event_i "i", iInstrNum (or "InstrName"), iStart, iDur [, ip4] [, ip5] [...]
The only difference between schedule and event_i is this: schedule can only trigger instruments, whereas event_i can also trigger "f" events (= build function tables).
La única diferencia entre schedule y event_i es la siguiente: schedule sólo puede activar instrumentos, mientras que event_i también puede desencadenar f events (= build function tables).
Both, schedule and event_i have a restriction: they are not able to send strings in the parameter fields p4, p5, ... So, if you execute this code ...
Ambos, schedule y event_i tienen una restricción: no son capaces de enviar cadenas en los campos de parámetros p4, p5, ... Por lo tanto, si ejecuta este código ...
schedule "bla", 0, 1, "blu"
... you will get this error message in the console:
... obtendrá este mensaje de error en la consola:
ERROR: Unable to find opcode entry for 'schedule' with matching argument types:
Found: (null) schedule SccS
scoreline_i is designed to make this possible. It takes one or more lines of score statements which follow the same conventions as if written in the score section itself.5 If you enclose the line(s) by {{ and }}, you can include as many strings in it as you wish:
Scoreline_i está diseñado para hacer esto posible. Requiere una o más líneas de partituras que siguen las mismas convenciones que si estuvieran escritas en la sección de puntuación misma.5 Si encierra la línea (s) por {{y}}, puede incluir tantas cuerdas como desee :
scoreline_i {{
i "bla" 0 1 "blu" "sound"
i "bla" 1 1 "brown" "earth"
}}
k-rate versions: event, scoreline, schedkwhen
If you need a k-rate opcode to trigger an instrument event, event is the basic choice. Its syntax is very similar to event_i, but as described above, it works at k-rate and you can also change all its arguments at k-rate:
Si necesita un opcode k-rate para activar un evento de instrumento, el evento es la opción básica. Su sintaxis es muy similar a event_i, pero como se describió anteriormente, funciona a k-rate y también puede cambiar todos sus argumentos en k-rate:
event "i", kInstrNum (or "InstrName"), kStart, kDur [, kp4] [, kp5] [...]
Usually, you will not want to trigger another instrument each control cycle, but based on certain conditions. A very common case is a "ticking" periodic signal, whichs ticks are being used as trigger impulses. The typical code snippel using a metro and the event opcode would be:
Por lo general, no querrá activar otro instrumento en cada ciclo de control, sino en función de ciertas condiciones. Un caso muy común es una señal periódica de tictac, cuyas garrapatas se utilizan como impulsos de disparo. El típico código snippel usando un metro y el opcode de evento sería:
kTrigger metro 1 ;"ticks" once a second
if kTrigger == 1 then ;if it ticks event "i", "my_instr", 0, 1 ;call the instrument endif
In other words: This code would only use one control-cycle per second to call my_instr, and would do nothing in the other control cycles. The schedkwhen opcode simplifies such typical use cases, and adds some other useful arguments. This is the syntax:
En otras palabras: Este código sólo usaría un ciclo de control por segundo para llamar a my_instr, y no haría nada en los otros ciclos de control. El código de operación schedkwhen simplifica estos casos de uso típicos y añade algunos otros argumentos útiles. Esta es la sintaxis:
schedkwhen kTrigger, kMinTim, kMaxNum, kInsrNum (or "InstrName"), kStart, kDur [, kp4] [, kp5] [...]
The kMinTim parameter specifies the time which has to be spent between two subsequent calls of the subinstrument. This is often quite useful as you may want to state: "Do not call the next instance of the subinstrument unless 0.1 seconds have been passed." If you set this parameter to zero, there will be no time limit for calling the subinstrument.
El parámetro kMinTim especifica el tiempo que debe pasar entre dos llamadas subsiguientes del subinstrumento. Esto es a menudo bastante útil, ya que es posible que desee declarar: No llame a la siguiente instancia del subinstrumento a menos que se hayan pasado 0,1 segundos. Si establece este parámetro en cero, no habrá límite de tiempo para llamar al subinstrumento.
The kMaxNum parameter specifies the maximum number of instances which run simultaneously. Say, kMaxNum = 2 and there are indeed two instances of the subinstrument running, no other instance will be initiated. if you set this parameter to zero, there will be no limit for calling new instances.
El parámetro kMaxNum especifica el número máximo de instancias que se ejecutan simultáneamente. Digamos, kMaxNum = 2 y de hecho hay dos instancias del subinstrumento en ejecución, ninguna otra instancia se iniciará. Si establece este parámetro en cero, no habrá límite para llamar a nuevas instancias.
So, with schedkwhen, we can write the above code snippet in two lines instead of four:
Por lo tanto, con schedkwhen, podemos escribir el fragmento de código anterior en dos líneas en lugar de cuatro:
kTrigger metro 1 ;"ticks" once a second
schedkwhen kTrigger, 0, 0, "my_instr", 0, 1
Only, you cannot pass strings as p-fields via schedkwhen (and event). So, very much similar as described above for i-rate opcodes, scoreline fills this gap. Usually we will use it with a condition, as we did for the event opcode:
Sólo, no puede pasar cadenas como campos p a través de schedkwhen (y event). Por lo tanto, muy similar a la descrita anteriormente para opcodes de tasa i, el scoreline llena esta brecha. Por lo general lo usaremos con una condición, como lo hicimos con el código de operación del evento:
kTrigger metro 1 ;"ticks" once a second
if kTrigger == 1 then
;if it ticks, call two instruments and pass strings as p-fields
scoreline {{
i "bla" 0 1 "blu" "sound"
i "bla" 1 1 "brown" "earth"
}}
endif
Recompilation
As it has been mentioned at the start of this chapter, since Csound6 you can re-compile any code in an already running Csound instance. Let us first see some simple examples for the general use, and then a more practical approach in CsoundQt.
Como se ha mencionado al comienzo de este capítulo, desde Csound6 puede volver a compilar cualquier código en una instancia de Csound ya en ejecución. Veamos primero algunos ejemplos simples para el uso general, y luego un enfoque más práctico en CsoundQt.
compileorc / compilestr
The opcode compileorc refers to a definition of instruments which has been saved as an .orc ("orchestra") file. To see how it works, save this text in a simple text (ASCII) format as "to_recompile.orc":
El opcode compileorc se refiere a una definición de instrumentos que se ha guardado como un archivo .orc (orquesta). Para ver cómo funciona, guarde este texto en un formato de texto simple (ASCII) como to_recompile.orc:
instr 1
iAmp = .2 iFreq = 465 aSig oscils iAmp, iFreq, 0 outs aSig, aSig endin
Then save this csd in the same directory:
EXAMPLE 03F13_compileorc.csd
<CsoundSynthesizer> <CsOptions> -o dac -d -L stdin -Ma </CsOptions> <CsInstruments> sr = 44100 nchnls = 2 ksmps = 32 0dbfs = 1 massign 0, 9999 instr 9999 ires compileorc "to_recompile.orc" print ires ; 0 if compiled successfully event_i "i", 1, 0, 3 ;send event endin </CsInstruments> <CsScore> i 9999 0 1 </CsScore> </CsoundSynthesizer>
If you run this csd in the terminal, you should hear a three seconds beep, and the output should be like this:
Si ejecuta este csd en el terminal, debe escuchar un pitido de tres segundos, y la salida debe ser así:
SECTION 1:
new alloc for instr 9999:
instr 9999: ires = 0.000
new alloc for instr 1:
B 0.000 .. 1.000 T 1.000 TT 1.000 M: 0.20000 0.20000
B 1.000 .. 3.000 T 3.000 TT 3.000 M: 0.20000 0.20000
Score finished in csoundPerform().
inactive allocs returned to freespace
end of score. overall amps: 0.20000 0.20000
overall samples out of range: 0 0
0 errors in performance
Having understood this, it is easy to do the next step. Remove (or comment out) the score line "i 9999 0 1" so that the score is empty. If you start the csd now, Csound will run indefinitely. Now call instr 9999 by typing "i 9999 0 1" in the terminal window (if the option -L stdin works for your setup), or by pressing any MIDI key (if you have connected a keyboard). You should hear the same beep as before. But as the recompile.csd keeps running, you can change now the to_recompile.orc instrument. Try, for instance, another value for kFreq. Whenever this is done (do not forget to save the file) and you call again instr 9999 in recompile.csd, the new version of this instrument is compiled and then called immediately.
Habiendo entendido esto, es fácil hacer el siguiente paso. Quitar (o comentar) la línea de puntuación i 9999 0 1 para que la partitura esté vacía. Si inicia el csd ahora, Csound se ejecutará indefinidamente. Ahora llame al ins 9999 escribiendo i 9999 0 1 en la ventana de terminal (si la opción -L stdin funciona para su configuración), o presionando cualquier tecla MIDI (si ha conectado un teclado). Usted debe escuchar el mismo pitido que antes. Pero a medida que el recompile.csd sigue funcionando, puede cambiar ahora el instrumento to_recompile.orc. Pruebe, por ejemplo, otro valor para kFreq. Siempre que esto se haga (no olvide guardar el archivo) y vuelve a llamar a instr 9999 en recompile.csd, la nueva versión de este instrumento se compila y luego se llama inmediatamente.
The other possibility to recompile code by using an opcode is compilestr. It will compile any instrument definition which is contained in a string. As this will be a string with several lines, you will usually use the '{{' delimiter for the start and '}}' for the end of the string. This is a basic example:
La otra posibilidad de recompilar código mediante un opcode es compilestr. Compilará cualquier definición de instrumento que esté contenida en una cadena. Como esta será una cadena con varias líneas, normalmente usas el {{delimitador para el inicio y} para el final de la cadena. Este es un ejemplo básico:
EXAMPLE 03F14_compilestr.csd
<CsoundSynthesizer>
<CsOptions>
-o dac -d
</CsOptions>
<CsInstruments>
sr = 44100
nchnls = 1
ksmps = 32
0dbfs = 1
instr 1
;will fail because of wrong code
ires compilestr {{
instr 2
a1 oscilb p4, p5, 0
out a1
endin
}}
print ires ; returns -1 because not successfull
;will compile ...
ires compilestr {{
instr 2
a1 oscils p4, p5, 0
out a1
endin
}}
print ires ; ... and returns 0
;call the new instrument
;(note that the overall performance is extended)
scoreline_i "i 2 0 3 .2 415"
endin
</CsInstruments>
<CsScore>
i1 0 1
</CsScore>
</CsoundSynthesizer>
As you see, instrument 2 is defined inside instrument 1, and compiled via compilestr. in case you can change this string in real-time (for instance in receiving it via OSC), you can add any new definition of instruments on the fly. But much more elegant is to use the related method of the Csound API, as CsoundQt does.
Como usted ve, el instrumento 2 se define dentro del instrumento 1, y se compila vía compilestr. En caso de que pueda cambiar esta cadena en tiempo real (por ejemplo al recibirla a través de OSC), puede agregar cualquier nueva definición de instrumentos sobre la marcha. Pero mucho más elegante es utilizar el método relacionado de la API Csound, como lo hace CsoundQt.
Re-Compilation in CsoundQt
(The following description is only valid if you have CsoundQt with PythonQt support. If so, your CsoundQt application should be called CsoundQt-d-py-cs6 or similar. If the "-py" is missing, you will probably not have PythonQt support.)
(La siguiente descripción sólo es válida si tienes CsoundQt con soporte para PythonQt.) Si es así, tu aplicación CsoundQt debería llamarse CsoundQt-d-py-cs6 o similar.
To see how easy it is to re-compile code of a running Csound instance, load this csd in CsoundQt:
Para ver lo fácil que es volver a compilar código de una instancia de Csound en ejecución, cargue este csd en CsoundQt:
EXAMPLE 03F15_Recompile_in_CsoundQt.csd
<CsoundSynthesizer> <CsInstruments> sr = 44100 nchnls = 1 ksmps = 32 0dbfs = 1 instr 1 a1 poscil .2, 500 out a1 endin </CsInstruments> <CsScore> r 1000 i 1 0 1 </CsScore> </CsoundSynthesizer>
The r-statement repeats the call to instr 1 for 1000 times. Now change the frequency of 500 in instr 1 to say 800. You will hear no change, because this has not been compiled yet. But when you now select the instrument definition (including the instr ... endin) and then choose Edit -> Evaluate selection, you will hear that in the next call of instrument 1 the frequency has changed. (Instead of selecting code and evaluation the selection, you can also place the cursor inside an instrument and then choose Edit -> Evaluate section.)
La instrucción r repite la llamada a instr 1 por 1000 veces. Ahora cambia la frecuencia de 500 en instr 1 para decir 800. No escucharás ningún cambio, porque aún no se ha compilado. Pero cuando ahora seleccione la definición del instrumento (incluyendo la instrucción ... endin) y luego elija Edit - Evaluate selection, oirá que en la siguiente llamada del instrumento 1 la frecuencia ha cambiado. (En lugar de seleccionar el código y evaluar la selección, también puede colocar el cursor dentro de un instrumento y luego seleccionar la sección Editar - Evaluar).
You can also insert new instrument definitions, and then call it with CsoundQt's Live event sheet. You even need not save it - instead you can save several results of your live coding without stopping Csound. Have fun ...
También puede insertar nuevas definiciones de instrumento y, a continuación, llamarla con la hoja de eventos CsoundQts Live. Incluso no es necesario guardarlo - en su lugar puede guardar varios resultados de su codificación en vivo sin detener Csound. Que te diviertas ...
Links And Related Opcodes
Links
A great collection of interactive examples with FLTK widgets by Iain McCurdy can be found here. See particularily the "Realtime Score Generation" section. Recently, the collection has been ported to QuteCsound by René Jopi, and is part of QuteCsound's example menu.
Una gran colección de ejemplos interactivos con widgets FLTK de Iain McCurdy se puede encontrar aquí. Vea en particular la sección Generación de Puntajes en Tiempo Real. Recientemente, la colección ha sido portada a QuteCsound por René Jopi, y es parte del menú de ejemplo de QuteCsounds.
An extended example for calculating score events at i-time can be found in the Re-Generation of Stockhausen's "Studie II" by Joachim Heintz (also included in the QuteCsound Examples menu).
Un ejemplo extendido para calcular los eventos de puntuación en i-time se puede encontrar en la Re-Generación de Stockhausens Studie II de Joachim Heintz (también incluido en el menú QuteCsound Ejemplos).
Related Opcodes
event_i / event: Generate an instrument event at i-time (event_i) or at k-time (event). Easy to use, but you cannot send a string to the subinstrument.
scoreline_i / scoreline: Generate an instrument at i-time (scoreline_i) or at k-time (scoreline). Like event_i/event, but you can send to more than one instrument but unlike event_i/event you can send strings. On the other hand, you must usually preformat your scoreline-string using sprintf.
sprintf / sprintfk: Generate a formatted string at i-time (sprintf) or k-time (sprintfk), and store it as a string-variable.
-+max_str_len=10000: Option in the "CsOptions" tag of a .csd file which extend the maximum string length to 9999 characters.
massign: Assigns the incoming MIDI events to a particular instrument. It is also possible to prevent any assigment by this opcode.
cpsmidi / ampmidi: Returns the frequency / velocity of a pressed MIDI key.
release: Returns "1" if the last k-cycle of an instrument has begun.
xtratim: Adds an additional time to the duration (p3) of an instrument.
turnoff / turnoff2: Turns an instrument off; either by the instrument itself (turnoff), or from another instrument and with several options (turnoff2).
-p3 / -p1: A negative duration (p3) turns an instrument on "indefinitely"; a negative instrument number (p1) turns this instrument off. See the examples at the beginning of this chapter.
-L stdin: Option in the "CsOptions" tag of a .csd file which lets you type in realtime score events.
timout: Allows you to perform time loops at i-time with reinitalization passes.
metro: Outputs momentary 1s with a definable (and variable) frequency. Can be used to perform a time loop at k-rate.
follow: Envelope follower.
- This has been described incorrectly in the first two issues of this manual.^
- There are also some video tutorials: http://www.youtube.com/watch?v=O9WU7DzdUmE http://www.youtube.com/watch?v=Hs3eO7o349k http://www.youtube.com/watch?v=yUMzp6556Kw^
- See chapter 03A about Initialization and Performance Pass for a detailed discussion.^
- As for a sample rate of 44100 Hz (sr=44100) and a control period od 32 samples (ksmps=32), we have 1378 control periods in one second. So 0.01 seconds will perform 14 control cycles.^
- This means that score parameter fields are separated by spaces, not by commas.^