Antescofo A not-so-short introduction to version 0.5x

Jean-Louis Giavitto

visibility

…

description

157 pages

link

2 files

Abstract

Antescofo is a coupling of a real-time listening machine with a reactive synchronous and timed scripting language. The language is used for authoring of music pieces involving live musicians and computer processes, and the real-time system assures its correct performance and synchronization despite listening or performance errors. See the project Home Page: http://repmus.ircam.fr/antescofo and the dedicated forum at IRCAM: http://forumnet.ircam.fr/product/antescofo/

Figures (48)

Figure 1.1 Antescofo Score Excerpt showing basic events and actions

Figure 1.3 Example of score attribute affectation (top-down parsing) in Antescofo text User defined score elements including Macros, processus and functions can only be em- ployed after their definition in the score. We suggest to put them at the beginning of the file or to put them in a separate file using the @insert command. They will be discussed in proceeding chapters.

1.5 ¢-identifiers: Variables

Figure 1.6 Rewrite of Figure 1.6 using a Macro and expressions 1.7 Comments and Indentation Bloc comments are in the C-style and cannot be nested:

Each event keyword in Antescofo in the above listing can be seen as containers with specific behavior and given nominal durations. A NOTE is a container of one pitch. A chord contains a vector of pitches. Figure 2.1 shows an example including simple notes and chords written in Antescofo:

Figure 3.1 The Antescofo system architecture. An action is spanned because the recognition of a musical event, a notification of the external environment (7.e., external assignment of a variable or an OSC message), internal variable assignment by the functioning of the program itself, or the expiration of a delay. Actions are launched after a delay which can be expressed in various time frame.

Figure 3.2 Logical instant, physical time frame and relative time frame corresponding to computed tempo. Notice that the (vertical) height of a box is used to represent the logice dependencies while the (horizontal) length of a box represents a duration in time. Computations are supposed to take no time and thus, atomic actions are performed inside one logical instant of zero duration. This abstraction is a useful simplification to understand the scheduling of actions in a score. In the real world, computations take time but this time can be usually ignored and do not disturb the scheduling planned at the score level. In figure 3.2, the sequence of synchronous actions appears in the vertical axis. So this axis corresponds to the dependency between simultaneous computations. Note for example that even if d; and deg are both zero, the execution order of actions ap, a; and az is the same as the appearance order in the score.

Stopping a Loop. The optional until or while clause is evaluated at each iteration an eventually stops the loop. For instance, the declarations on the left produce the timing « the action’s firing figured in the right: The loop construction is similar to group where actions in the loop body are iterated de- pending on a period specification. Each iteration takes the same amount of time, a period. 5.3 Loop: Sequential iterations

Figure 5.2 Simplified Curve chain call The simplified curve is thus very similar to line object in Max or PD. This said, it is important (and vital) that the first call to Simplified Curve has an initial value otherwise the departing point is unknown and you risk receiving NaN value until the first destination point!

Figure 5.1 Simplified Curve syntax and its realisation in Ascograph above you can make sure that the first curve does not continue while the second is running. This is because of the way Stmplified Curves are hard-coded. A new call on the same receiver /action will cancel the previous one before taking over.

In the above example, the curve is defined over variable $y. This value is updated at a time- rate defined by attribute @grain (can be absolute time or relative). Each time $y is updated, the @action block is triggered which can make use of $y. The example below shows a simple non-linear curve. The Curve has the name “C” and starts at a value of 0. Two beats later, the curve reaches 2 and ends on 4 after 8 additional beats. Between the breakpoints, the interpolation is linear, as indicated by the keyword @linear. Linear interpolation is the default behaviour of a curve (hence it can be dismissed).

In the above example, all values in the three-dimensional vector share the same break- point. It is also possible to split the curve to multiple parameter clauses as below:

It is easy to apply curves on multi-dimensional vectors as shown in the following example

Figure 5.3 shows a simple 2-dimensional vector curve on Ascograph. Here, two variable: $x and $y are passed to the action. They share the same breakpoints but can be split withir the same curve. The curve is also being aborted on “event2” by calling its name. Using Ascograph, you can graphically interact with curves: moving breakpoints vertically (changing their values) and horizontally (time position) by mouse, assigning new interpolation schemes graphically (control-click on break-point), splitting multi-dimensional curves and more. For many of these operations on multi-dimensional curves, each coordinate should be represented separately. This can be done by pressing the SPLIT button on the Curve box in Ascograph which will automatically generate the corresponding text in the score. Each time you make graphical modifications on a curve in Ascograph, you’d need to press APPLY to regenerate the corresponding text.

In the above example, curve parameters $x and $y have different breakpoints. The breakpoint definition on $x shows how to define a sudden change on step-function with a zero-delay value. Incidentally note that the result is not a continuous function on [0,5]. The parameter $y is defined by only one pair of breakpoints. The last breakpoint has its time coordinate equal to 3, which ends the function before the end of $x.

Figure 5.4 shows the curve of figure 5.3 embedded on the event score, split and in course of being modified by a user. 5.4.3 Actions Fired by a Curve Hach time the parameter $y is assigned, the action specified by the attribute @action is also fired. This action can be a simple message without attributes or any kind of action. In the latter case, a pair of braces must be used to delimit the action to perform. With this declaration:

Figure 5.5 Various interpolation type available in an Antescofo Curve and NIM. The label xxx[0] corresponds to the ease “in”, that is to the type "xxx_in" or equivalently "xxx"; the xxx[1] corresponds to the ease “out”, 2.e. type "xxx_out"; and the label xxx [2] corresponds to the ease “in out”, 2.e. type "xxx_in_out"5.

Watching Restrictions. The whenever watchs variable, not values. So the update of an element in a tab cannot trigger a whenever, see 8.3 page 83. A whenever cannot watch a local variable referred through the dot notation. A whenever cannot watch a special variable, that is $NOW and $MYSELF. These restrictions ensure that Antescofo score remain causal and efficiently implementable. This example will produce the following schedule:

As a matter of fact, a temporal shortcut indicates that some variable is updated multiple time synchronously (in the same logical instant). If these updates are specified in the same group, they are well ordered. But if they are issued from “parallel” groups, their order is undetermined, which lead to non-deterministic results.

Figure 8.1 The two forms a NIM definition. The diagram in the left illustrate the spec- ification of a continuous NIM{x0 yO, dO yi tO, di y1 t1} while the diagram in the right illustrates the specification of a discontinuous NIM{x0, yO dO YO tO, y1 di Y1 t1}. where f, is a cubic interpolation between 0 and 1 for x; going from —1 to 1 and fo is a linear interpolation between 10 and 20 for x2 going from 0 to 3. The arguments of a vectorized NIM may includes scalar s: in this case, the scalar is extended implicitly into a vector of the correct size whose elements are all equal to s. This is the case even for the specification of the interpolation type. The specification of the interpolation type can be omitted: in this case, teh interpolation type is linear. For example:

Here are some additional examples of tab comprehensions showing the syntax:

Figure 9.2 Action behavior in case of a missed event for four synchronization and error handling strategies. In this example, the score is assumed to specify four consecutive performer events (e) to e4) with associated actions gathered in a group. Hach action is aligned in the score with an event. The four groups correspond to the four possible combinations of two possible synchronization strategies with the two possible error handling attributes. This diagram illustrates the system behavior in case event e, is missed and the rest of events detected without tempo change. Note that e; is detected as missed (in real-time) once of course €» is reported. The signaling of the missing e; is denoted by é). in the score with an event. The four groups correspond to the four possible combinations

Figure 10.1 Example of a Macro and its realisation upon score load ‘The call to macro can be seen in the text window on the right, and its realisation on the The two lines inside the group are atomic actions (similar to cues in a glist object in Max/Pd with additional capabilities — see chapter 3) and the group puts them in a single unit and enables polyphony or concurrency (see chapter 5).

Figure B.1 State patterns with during, before and @refractory clauses. Two properties of the generated code must be kept in mind: