Concurrent Constraint Conditional-Branching Timed Interactive Scores

TL;DR

This paper introduces a formal model for multimedia interactive scenarios with conditional branching, using ntcc calculus, enabling real-time interaction with declarative constraints.

Contribution

It extends Interactive Scores to include conditional branching within a timed framework using ntcc, and demonstrates real-time prototype implementation.

Findings

Prototype in Ntccrt achieved acceptable real-time response.

Declarative representation of conditions and constraints.

Enhanced expressiveness for multimedia scenario modeling.

Abstract

Multimedia scenarios have multimedia content and interactive events associated with computer programs. Interactive Scores (IS) is a formalism to represent such scenarios by temporal objects, temporal relations (TRs) and interactive events. IS describe TRs, but IS cannot represent TRs together with conditional branching. We propose a model for conditional branching timed IS in the Non-deterministic Timed Concurrent Constraint (ntcc) calculus. We ran a prototype of our model in Ntccrt (a real-time capable interpreter for ntcc) and the response time was acceptable for real-time interaction. An advantage of ntcc over Max/MSP or Petri Nets is that conditions and global constraints are represented declaratively.

Tables

Table 1. Table 1: Semantics of ntcc agents.

Agent	Meaning
tell $\left(c\right)$	Adds $c$ to the current store
when $\left(c\right)$ do $A$	If $c$ holds now run $A$
local $\left(x\right)$ in $P$	Runs $P$ with local variable $x$
$A$ $\parallel$ $B$	Parallel composition
next $A$	Runs $A$ at the next time-unit
unless $\left(c\right)$ next $A$	Unless $c$ holds, next run $A$
${\sum }_{i\in I}$ when $\left(c_i\right)$ do $P_i$	Chooses $P_i$ s.t. $\left(c_i\right)$ holds
$P$	Delays P indefinitely
!$P$	Executes P each time-unit

Full text

1 Introduction

Interactive multimedia deals with the design of scenarios where multimedia content and interactive events can be associated with computer programs. Designers usually create multimedia for their scenarios, then they bind them to external interactive events or programs. Max/MSP and Pure Data (Pd) [21] are often used to program interactive scenarios. However, we claim for the need of a general model to (i) control synthesis based on human gestures and to (ii) declare relations among multimedia objects (e.g., partial-order relations for their execution).

Interactive Scores (IS) is a formalism for the design of scenarios represented by temporal objects (TOs), temporal relations (TRs) and interactive events. Examples of TOs are videos and sounds. TOs can be triggered by interactive events (usually launched by the user) and several TOs can be active simultaneously. A TO can contain other TOs. The hierarchy allows us to control the start or end of a TO by controlling the start or end of its parent. Moreover, TRs provide a partial order for the execution of the TOs: TRs can be used to express precedence between objects.

IS have been subject of study since the beginning of the century [9], [12]. IS were originally developed for interactive music scores. Recently, the model was extended by Allombert, Desainte-Catherine, Larralde and Assayag in [5]. Hence IS can describe any kind of TOs, Allombert et al.’s model has inspired two applications: iScore [2] to compose and perform Electroacoustic music and Virage [4] to control live spectacles and interactive museums.

IS are successful to describe TRs, but IS have not been used to represent TRs together with conditional branching. Conditional branching is used in programming to describe control structures such as if/else and switch/case. It provides a mechanism to choose the state of a program depending on a condition and its current state.

Using conditional branching, a designer can create scenarios with loops and choices (as in programming). The user and the system can take decisions during performance with the degree of freedom described by the designer –while the system maintains the TRs of the scenario.

The designer can express under which conditions a loop ends; for instance, when the user changes the value of a certain variable, the loop stops; or the system non-deter- ministically chooses to stop.

Unfortunately, there is neither a theoretical model nor a special-purpose application to support conditional branching in interactive multimedia. In this work, we propose a model for conditional-branching timed IS in the Non-deterministic Timed Concurrent Constraint (ntcc) [14] calculus. In our model we combine TRs, conditional branching and discrete interactive events in a single model. We ran a prototype of the model over Ntccrt [34], a real-time capable interpreter for ntcc.

In a previous work [36], we showed how we can represent a multimedia installation with loops and choice111http://www.gmea.net/activite/creation/2007_2008/pPerez.htm, and the pure timed IS model [5] into our model.

1.1 Related work on interactive multimedia

A similar approach to ours was followed by Olarte and Rueda in [15]. They propose a model for IS in a calculus similar to ntcc; however, they only modeled TRs. They verified critical properties on the system. The key point of their model is that the user can change the hierarchical structure of the score during performance.

Another system dealing with a hierarchical structure is Maquettes of OpenMusic [10]. However, OpenMusic is a software for composition and not real-time interaction.

Another kind of systems capable of real-time interaction are score following systems (see [11]). Such systems track the performance of a real instrument and they may play multimedia associated to certain notes of the piece. However, to use these systems it is necessary to play a real instrument; whereas to use IS, the user only has to control some parameters of the piece, such as the start and end dates of the TOs.

A model for multimedia interaction that does not require a real instrument uses Hidden Markov Models to model probabilistic installations [8]. The system tracks human motion and it responds to human performance with chords and pitches depending on the knowledge of previous training. However, the system requires intensive training and it is not a tool for composition.

In the domain of composition of interactive music, there are applications such as Ableton Live222http://www.ableton.com/live/. Using Live, a composer can write loops and a musician can control different parameters of the piece during performance. Live is commonly used for Electronic and Electroacoustic music. Unfortunately, the means of interaction and the synchronization patterns provided by Live are limited.

1.1.1 Formalisms for Interactive Multimedia

To handle complex synchronization patterns and to predict the behavior of interactive scenarios, formalisms such as ntcc and Hierarchical Time Stream Petri Networks (HTSPN) [24] and have been used to model IS [3, 5].

In HTSPN we can express a variety of TRs, but it is not easy to represent global constraints (e.g., the number of TOs playing simultaneously). Instead, ntcc synchronizes processes through a common constraint store, thus global constraints are explicitly represented in such store. We chose ntcc because we can easily represent time, constraints, choice, and we can verify the model.

Another formalism for defining declaratively partial orders of musical processes and audio is Tempo [22]. However, Tempo does not allow us to express choice (when multiple conditions hold), simultaneity and weak time-outs (e.g., perform an action if the condition cannot be deduced). A key aspect is that there is a real-time capable interpreter and automatic verification for Tempo.

At present, there is not an automatic verifier for ntcc. In the declarative view, ntcc processes can be interpreted as linear temporal logic formulae. Ntcc includes an inference system in this logic to verify properties of ntcc models. This inference procedure was proved to be of exponential time complexity [46]. Nevertheless, we believe practical automatic verification could be envisioned for useful subsets of ntcc via model checking (see [13]).

Automated verification for IS will provide information about the correctness of the system to computer scientists. It will also provide important properties about the scenario to its designers and users. It will be possible to verify the absence of deadlocks, and also that certain TOs will be played during performance. This kind of properties cannot be verified in applications with no formal semantics.

1.2 Structure of the paper

The remainder of this paper is structured as follows. Section 2 explains ntcc and Ntccrt. Section 3 states our model for conditional-branching timed IS. Section 4 shows the ntcc definitions of our model. Section 5 explains our implementation using Pd and Ntccrt. Finally, section 6 gives some concluding remarks and future work.

2 The ntcc process calculus

A family of process calculi is Concurrent Constraint Programming (ccp) [23], where a system is modeled in terms of variables and constraints over some variables. The constraints are contained in a common store. There are also agents that reason about the system variables, based on partial information (by the means of constraints).

Formally, ccp is based upon the idea of a constraint system (CS). A constraint system includes a set of (basic) constraints and a relation (i.e., entailment relation $\models$) to deduce a constraint with the information supplied by other constraints.

A ccp system usually includes several CSs for different variable types. There are CSs for variable types such as sets, trees, graphs and natural numbers. A CS providing arithmetic relations over natural numbers is known as Finite Domain (FD). As an example, using a FD CS, we can deduce $pitch\neq 60$ from the constraints $pitch>40$ and $pitch<59$.

Although we can choose an appropriate CS to model any problem, in ccp it is not possible to delete nor change information accumulated in the store. For that reason it is difficult to perceive a notion of discrete time, useful to model reactive systems communicating with an external environment (e.g., users, lights, sensors and speakers).

Ntcc introduces to ccp the notion of discrete time as a sequence of time units. Each time unit starts with a store (possibly empty) supplied by the environment, and ntcc executes all the processes scheduled for that time unit. In contrast to ccp, in ntcc we can model variables changing values over time. A variable $x$ can take different values at each time unit. To model that in ccp, we have to create a new variable $x_{i}$ each time we change the value of $x$.

Process calculi has been applied to the modeling of interactive music systems [39, 45, 33, 44, 6, 40, 34, 16, 31, 27, 29, 32, 7, 38, 28, 35, 37, 26] and ecological systems [41, 19, 43, 20, 42].

2.1 Ntcc in multimedia interaction

In this section we give some examples on how the computational agents of ntcc can be used with a FD CS. A summary of the agents semantics can be found in Table 1.

• •

Using tell it is possible to add constraints to the store such as $\textbf{tell}(60<pitch_{2}<100)$, which means that $pitch_{2}$ is an integer between 60 and 100.

• •

When can be used to describe how the system reacts to different events; for instance, when $pitch_{1}=C4\wedge pitch_{2}=E4\wedge pitch_{3}=G4$ do $\textbf{tell}(CMayor=true)$ adds the constraint $CMayor=true$ to the current store as soon as the pitch sequence C, E, G has been played.

• •

Parallel composition ($\|$) makes it possible to represent concurrent processes; for instance, tell $(pitch_{1}=52)$ $\|$ when $48<pitch_{1}<59$ do tell $(Instrument=1)$ tells the store that $pitch_{1}$ is 52 and concurrently assigns the instrument to one, since $pitch_{1}$ is in the desired interval (see fig. 1).

• •

Next is useful when we want to model variables changing over time; for instance, when $(pitch_{1}=60)$ do next tell $(pitch_{1}<>60)$ means that if $pitch_{1}$ is equal to 60 in the current time unit, it will be different from 60 in the next time unit.

• •

Unless is useful to model systems reacting when a condition is not satisfied or when the condition cannot be deduced from the store; for instance, unless $(pitch_{1}=60)$ next tell $(lastPitch<>60)$ reacts when $pitch_{1}=60$ is false or when $pitch_{1}=60$ cannot be deduced from the store (e.g., $pitch_{1}$ was not played in the current time unit).

• •

Star (*****) can be used to delay the end of a process indefinitely, but not forever; for instance, $*\textbf{tell}$ $(End=true)$. Note that to model Interactive Scores we do not use the star agent.

• •

Bang (!) executes a certain process every time unit after its execution; for instance, $!$tell $(C_{4}=60)$.

• •

Sum ($\sum$) is used to model non-deterministic choices; for instance, $\sum_{i\in\{48,52,55\}}$ when $i\in PlayedPitches$ do tell $(pitch=i)$ chooses a note among those played previously that belongs to the C major chord.

In ntcc, recursion can be defined (see [46]) with the form $q(x)=^{def}P_{q}$, where $q$ is the process name and $P_{q}$ is restricted to call $q$ at most once and such call must be within the scope of a next. The reason of using next is that ntcc does not allow recursion within a time unit.

The reader should not confuse a simple definition with a recursive definition; for instance, $Before_{i,j}$ $=^{def}\textbf{tell}(i\in Predecessor_{j})$ is a simple definition where the values of $i$ and $j$ are replaced statically, like a macro in a programming language. Instead, a recursive definition such as $Clock(v)$ $=^{def}\textbf{tell}(clock=v)\|\textbf{next}\ Clock(v+1)$ is like a function in a programming language.

2.2 Ntccrt: A real-time capable interpreter for ntcc

In the current version of Ntccrt, we can write a ntcc model on either Lisp, Openmusic or C++. For a complete implementation of Interactive Scores, it will be necessary to produce automatically the corresponding ntcc model based on a graphical interface similar to Virage.

To execute a ntcc model it is not necessary to develop an interface because Ntccrt programs can be compiled into stand-alone programs or as external objects (i.e., a binary plugins) for Pd or Max (see fig. 2).

We can use the message passing API provided by Pd and Max to communicate any object with the Ntccrt external. We can also control all the available objects for audio and video processing defined in those languages using Ntccrt. To synchronize those objects, Ntccrt provides an important part of Gecode’s constraints [25].

Ntccrt uses Gecode as its constraint solving library. Contraint solving libraries can be used to solve combinatory problems such as planning systems optimal delivery of packages [1]; however, they can also be used for constriant propagation. Gecode was carefully designed to support efficiently the Finite Domain (FD) constraint system. Ntccrt relies on propagation of FD constraints.

3 Conditional branching timed IS

Points and intervals build up Interactive Scores (IS), thus a score333We still use the term score for historical reasons. (i.e., the specification of a scenario) is defined by a tuple $s=\langle P,I\rangle$, where $P$ is a set of points and $I$ is a set of intervals. A temporal object is just a type of interval.

3.1 Points

Intuitively, a point $p$ is a predecessor of $q$ if there is a relation $p$ before $q$. Analogically, a point $p$ is a successor of $r$ if there is a relation $r$ before $p$.

A Point is defined by $p=\langle b_{p},b_{s}\rangle$, where $b_{p}$ and $b_{s}$ represent the behavior of the point. Behavior $b_{p}$ defines whether the point waits until all its predecessors transfer the control to it –Wait for All (WA)– or it only waits for the first of them –Wait for the First (WF)–. Behavior $b_{s}$ defines whether the point transfers the control to all its successors which conditions hold –No CHoice (NCH)– or it chooses one of them –CHoice (CH)–.

Note that we do not include the set of dates of the point in previous definition. Beurivé et al. argued in [9] that the edition of a hierarchical representation of music using a relative time model requires less variable updates than using an absolute time model. We argue that it is also true during the performance of Interactive Scores. Moreover, in our model it is not easy to know the set of all possible dates a priori because they depend on the choices that the user makes during performance.

3.2 Intervals: TCRs and TOs

An interval $p$ before $q$ intuitively means that the system waits a certain time to transfer the control from $p$ to $q$ if the condition in the interval holds. In addition, it executes a process throughout its duration. An interval also has a nominal duration that may change during the performance. The nominal duration is computed during the edition of the scenario using constraint programming (see [3]. Formally, an interval is a tuple composed by {itemize*}

a start point $(p_{1})$

an end point $(p_{2})$

a condition $(c)$

a duration $(d)$

an interpretation for the condition $(b)$

a local constraint $(l)$

a process $(proc)$

parameters for the process $(param)$

children $(N)$

local variables $(vars)$

It is not practical to include all those elements explicitly; thus, we have identified two types of intervals. timed conditional relations (TCRs) have a condition $c$ and an interpretation $b$, but they do not have children, their local constraint is true, and their process is $silence$444$silence$ is a process that does nothing.. Temporal objects (TOs) may have children, local variables and a local constraint, but their condition is true, and their interpretation is $when$ (i.e., when the condition is true, it transfers the control from $p_{1}$ to $p_{2}$).

To have a coherent score, we must define a TCR between the start point of each father and the start point of at least one of its children. However, it is not required to connect a child to the end point of its father. Furthermore, in our model we may define multiple TCRs and TOs between two points. This does not introduce an incoherence in the model because the behavior of those intervals (as any interval) depends on the behavior of the points and the parameters of the interval.

3.2.1 Timed Conditional Relations (TCRs)

A timed conditional relation (TCR) is defined by $r=\langle p_{1},\\ p_{2},c,d,b\rangle$, where $p_{1}$ and $p_{2}$ are the points involved in the relation. The condition $c$ determines whether the control jumps from $p_{1}$ to $p_{2}$ (i.e., the control is transferred from $p_{1}$ to $p_{2}$). The interpretation of $c$ is $b$. There are two possible values for $b$: (i) when means that if $c$ holds, the control jumps to $p_{2}$; and (ii) unless means that if $c$ does not hold or its value cannot be deduced from the environment (e.g., $c=a>0$ and $-\infty<a<\infty$), the control jumps to $p_{2}$.

A duration is flexible if it can take any value, rigid if it takes values between two fixed integers and semi-rigid if it takes values greater than a fixed integer. In our model, we always respect flexible durations. Our model is based upon transferring the control from one point to another. For that reason, it is not always possible to respect rigid and semirigid durations; for instance, when a point waits for an event or when it is followed by a choice.

3.2.2 Temporal objects (TOs)

A temporal object (TO) is defined by $t=\langle p_{s},p_{e},l,d,proc,\\ param,N,vars\rangle$ where $p_{s}$ is a point that starts a new instance of $t$ and $p_{e}$ ends such instance. A constraint $l$ is attached to $t$, it contains local information for $t$ and its children. The duration is $d$. A process which executes throughout the duration of $t$ is $proc$. The list of parameters for the process is $param$. The set of TOs embedded in $t$ is $N$, which are called children of $t$. Finally, $vars$ represents the local variables defined for the TO that can be used by $t$’s children, process and local constraint.

3.3 Example: A loop controlled by a condition

The following example (see fig. 3) describes a score with a loop. During the execution, the system plays a silence of one second. After the silence, it plays the sound $B$ during three seconds and simultaneously it turns on the lights $D$ for one second. After the sound $B$, it plays a silence of one second, then it plays video $C$. If the variable $finish$ becomes true, it ends the scenario after playing the video $C$; otherwise, it jumps back to the beginning of the first silence after playing the video $C$.

To define the score of this scenario, we define a local boolean variable $finish$ in $A$, and we use it as the condition for some TCRs. Note that the silence between $D$ and $C$ lasts one second in the score, but during execution it is longer because of the behavior of the points.

The points have the following behavior. The end point of $C$ ($e_{c}$) is enabled for choice, and the other points transfer the control to all their successors. The start point of $C$ ($s_{c}$) waits for all its predecessors to transfer the control to it, and all the other points wait for the first predecessor that transfers the control to them.

Formally, the points are defined

$s_{a}=e_{a}=s_{b}=e_{b}=s_{d}=e_{d}=\langle\{WF,NCH\}\rangle$

$s_{c}=\langle\{WA,NCH\}\rangle$

$e_{c}=\langle\{WF,CH\}\rangle$

$P=\{s_{a},e_{a},s_{b},e_{b},s_{c},e_{c},s_{d},e_{d}\}$

As an example, $e_{c}$ Waits for the first predecessor (WF) and makes a choice (CH).

The TOs are defined by

$A=\langle s_{a},e_{a},d\in[0,\infty),d,sil.,\emptyset,\{B,C,D\},\{finish\}\rangle\\ B=\langle s_{b},e_{b},\texttt{true},3,playSoundB,\emptyset,\emptyset,\emptyset\rangle\\ C=\langle s_{c},e_{c},\texttt{true},2,PlayVideoC,\emptyset,\emptyset,\emptyset\rangle\\ D=\langle s_{d},e_{d},\texttt{true},1,TurnOnLightsD,\emptyset,\emptyset,\emptyset\rangle\\ T=\{A,B,C,D\}$

As an example, $A$ is composed by points $s_{a}$ and $e_{a}$, it has a flexible duration, its process is silence, its children are $B$, $C$ and $D$ and its local variable is $finish$.

In what follows we present the TCRs

$TCR=\\ \hskip 8.0pt\{\langle s_{a},s_{b},\texttt{true},1,when\rangle,\langle s_{a},s_{d},\texttt{true},1,when\rangle,\\ \hskip 12.0pt\langle e_{b},s_{c},\texttt{true},1,when\rangle,\langle e_{d},s_{c},\texttt{true},1,when\rangle,\\ \hskip 12.0pt\langle e_{c},s_{a},\neg finish,0,when\rangle,\langle e_{c},e_{a},finish,0,when\rangle\}$

As an example, the first one is a TCR between points $s_{a}$ and $s_{b}$, its condition is true, its interpretation is $when$ and its duration is one.

Finally, $I$ is the set of intervals composed by the TOs and the TCRs and $S$ is the score.

$I=T\bigcup TCR$         $S=\{P,I\}$

3.4 Limitations: Rigid durations and choice

In some cases (e.g., fig. 3), we can respect rigid durations of TOs during performance. Unfortunately, there is not a generic way to compute the value of a rigid duration in a score with conditional branching. The problem is that choices do not allow us to predict the duration of a TO’s successor; therefore, it is not possible to determinate a priori the duration of all the TOs.

Figure 4 shows a scenario where we cannot respect rigid durations. $T_{2}$, $T_{4}$ and $T_{5}$ have fixed durations, but $T_{1}$ can take different values between $\Delta_{min}$ and $\Delta_{max}$. Since there is no way to predict whether $T_{2}$ or $T_{5}$ will be chosen after the execution of $T_{1}$, we cannot compute a coherent duration for $T_{1}$ before the choice.

4 Our ntcc model of IS

In this section we define our ntcc model. We define processes for some combinations of the behaviors of a point. The definition of an interval can be used for both timed conditional relations and temporal objects. To represent intervals we create a graph with the predecessors and successors of each point using the variables $Predec$ and $Succ$. For simplicity, we do not include hierarchy, we only model the interpretation $when$, we can only declare a single interval between two points, and we can only execute a single instance of an interval at the same time.

4.1 Points: Three combinations of behaviors

We only include three type of points: points that choose among their successors ($ChoicePoint$), points that transfer the control to all their successors ($JumpToAllPoint$), and points that wait for all their predecessors to transfer the control to them ($WaitForAllPoint$). The first two types of points wait for the first predecessor that transfers the control to them to be active.

Points are modeled using Finite Domain constraints; for instance, to know if at least one point has transferred the control to the point $i$, we ask to the store if the boolean or ($\bigvee_{j\in P}$) constraint applied to the relation $Arrived(i,j)$ can be deduced from the store (where $P$ is the set of identifiers for each point).

When all the expected predecessors transfer the control to the point $i$, we say that the point is active (i.e., $ActivePoints_{i}$ holds). Analogaly, when a point $i$ transfers the control to a point $j$, we add the constraint

$ControlTranferred(j,i)$.

In order to represent the choice between points $a$ and $b$, we use the variable $finish$ in the $\Sigma$ process. Note that $\textbf{when}\ c_{1}\ \textbf{do}\ P_{1}+\textbf{when}\ c_{2}\ \textbf{do}\ P_{2}$ is equivalent to $\sum_{i\in\{1,2\}}\\ \textbf{when}\ c_{i}\ \textbf{do}\ P_{i}$, and $\textbf{whenever}\ c\ \textbf{do}\ P$ is equivalent to $\textbf{!when}\ c\ \textbf{do}\ P$.

$ChoicePoint_{i,a,b}$ $\overset{def}{=}$

    whenever $\bigvee\limits_{j\in P}Arrived(i,j)$ do (tell $(ActivePoints_{i})$

    $\|$ when $finish$ do tell ($ControlTransferred(a,i)$)

     +when $\neg finish$ do tell ($ControlTransferred(b,i)$))

The following definition uses the agent $\prod$ to transfer the control to all the successors of the point $i$. The agent $\prod$ represents the parallel composition in a compact way.

$ToAll_{i}$ $\overset{def}{=}$

   tell $(ActivePoints_{i})$

   \|$$\prod_{j\in P} when $Succs(i,j)$ do

                  tell ($ControlTransferred(j,i)$))

Using the definition $ToAll_{i}$, we define the two points that transfer the control to all its successors.

$JumpToAllPoint_{i}$ $\overset{def}{=}$

  whenever $\bigvee_{j\in P}Arrived(i,j)$ do $ToAll_{i}$

To wait for all the predecessors, we ask the store if the constraint $Arrived=Predec$ holds.

$WaitForAllPoint_{i}$ $\overset{def}{=}$

  whenever $\forall j,Arrived(i,j)=Predec(i,j)$ do $ToAll_{i}$

4.2 Intervals: TCRs and TOs

Intervals are modeled by two recursive definitions. These definitions model both TOs and TCRs because intervals only change the value of an $ActivePoints$ variable, thus they only control the start and end of their processes.

Process $I$ waits until at least one point transfers the control to its start point $i$, and at least one point has been chosen by another point to transfer the control to its destination $j$. When such conditions hold, it waits until the duration of the interval is over555nextd is a process next nested $d$ times ($next(next(next...$)., then it transfers the control from point $i$ to $j$. It also adds a constraint on the corresponding set of predecessors and successors.

$I_{i,j,d}$ $\overset{def}{=}$ !(tell ($Predec(j,i)$) $\|$ tell ($Succ(i,j)$))

  $\|$whenever $\bigvee_{k\in P}ControlTransferred(j,k)$

              $\land\bigvee_{k\in P}Arrived(i,k)$ do(

     nextd(tell$(Arrived(j,i))$ $\|PredecessorsWait(i,j)$))

$PredecessorsWait$ adds the constraint $Arrived(j,i)$ until the time unit after the point $j$ becomes active. This definition maintains the coherence of $WaitForAll$ points.

$PredecessorsWait_{i,j}$ $\overset{def}{=}$ unless $ActivePoints_{j}$ next

            $(PredecessorsWait_{i,j}\|$ tell ($Arrived(j,i)$))

4.3 The example 3.3 on ntcc

The example presented on figure 3 can be easily modeled in ntcc. $User$ is a process representing a user that tells to the store that $finish$ is not true during the first $n$ time units, then it tells that $finish$ is true. Note that an advantage of ntcc is that the constraint $i\geq n$ can be easily replaced by more complex ones; for instance, it can be replaced by $i\geq n\land c$. Constraint $c$ can be, for instance, “there are only three active points at this moment in the score” (i.e., $|\{x\in ActivePoints\ |\ x=1\}|=3$).

$User_{n}(i)$ $\overset{def}{=}$ when $i\geq n$ do tell $(finish)$

                $\|$unless $i\geq n$ next tell $(\neg finish)$

                $\|$next $User_{n}(i+1)$

$TCRs$ $\overset{def}{=}I_{s_{d},e_{d},1}$

 $\|I_{s_{a},s_{b},1}\|I_{e_{d},s_{c},1}\|I_{s_{b},e_{b},3}\|I_{e_{b},s_{c},1}\|I_{s_{c},e_{c},2}\|I_{e_{c},s_{a},0}\\ \hskip 3.0pt\|I_{e_{c},e_{a},0}\|I_{null,s_{a},0}\|I_{s_{a},s_{d},1}\|$ tell ($Arrived(s_{a},start)$)

$Points$ $\overset{def}{=}$ $ChoicePoint_{e_{c},e_{a},s_{a}}\|WaitForAllPoint_{s_{c}}\\ \hskip 47.0pt\|\prod_{i\in\{s_{a},e_{a},s_{b},e_{b},s_{d},e_{d}\}}JumpToAllPoint_{i}$

$System_{n}$ $\overset{def}{=}$ $User_{n}(0)\|TCRs\|Points$

5 Implementation in Ntccrt and Pd

We implemented the previous example in Ntccrt and Pure Data (Pd) (fig. 5). We replaced the $User$ process with a user input for the variable $finish$. We generated a Ntccrt external (i.e., a binary plugin) for Pd with our ntcc model.

The external has two inputs: one for the clock ticks and one for the value of $finish$. The input for the clock ticks can be connected to a metronome object to have a fixed duration for every time unit during the performance. The reader can find a discussion of executing time units with fixed durations in [34].

The Ntccrt external outputs a boolean value for each point, indicating whether it is active or not. Using such values, we can control the start and end of $SoundB$, $VideoC$ and $lightsD$, which are processes defined in Pd.

5.1 Results: Performance and usability of Ntccrt

We built automatically Interactive Scores (IS) with a number of points666The exact number of points is $3.2^{n}-2$. and relations in the order of $2^{n}$, with $n$ from two to ten (see fig. 6). We ran each score 100 times as a stand-alone program. The duration of a time unit is determined by the time taken by Ntccrt to calculate the output, not by an external clock. The tests were performed on an iMac 2.6 GHz with 2 GB of RAM under Mac OS 10.5.7. It was compiled with GCC 4.2 and liked to Gecode 3.2.2.

The authors of the Continuator [18] argue that a multimedia interaction system with a response time less than 30 ms is able to interact in real-time with even a very fast guitar jazz player. Therefore, our results (fig. 7) are acceptable for real-time interaction with a guitarist for up to 1000 points (around 500 TOs). We conjecture that a response time of 20 ms is appropriate to interact with a very fast percussionist. In that case, we can have up to 400 TOs.

5.1.1 Usability of Ntccrt

We found out intuitive to write ntcc models in Ntccrt, to someone familiar with ntcc, because it provides a Lisp interface with a syntax similar to ntcc; for instance,

$PredecessorWait$ is written as

(defproc PredecessorsWait (i j) (unlessp (v=? (ActivePoint i) j) (||(call PredecessorsWait i j) (tell= (ArrivedPoint j i) 1))))

It is slightly harder to write the same definition in C++

class predecessorsWait:public proc{ public: AskBody* predecessorsWait::operator()( Space* h, vector<int> intparameters, vector<variable *> variableparameters) {return unless(eq(ActivePoint[i][j]), parallel(call(PredecessorWait,i,j), tellEqual(ArrivedPoint[i][j],1)));}};

6 Concluding remarks

We developed a model for multimedia interaction with con- ditional-branching and temporal relations based on points and intervals. We implemented it using Ntccrt and Pure Data (Pd). We conclude from performance results that our prototype is compatible with real-time interaction for a reasonable amount of points and relations. An existing implementation of Interactive Scores model is also capable of real-time and it can easy respect rigid durations, but such model does not support loops nor choice.

For simplicity, in our prototype we do not include hierarchy, we only model the interpretation $when$, we can only declare a single interval between two points, we can preserve rigid durations only in a few cases , and we can only execute a single instance of an interval at the same time.

An advantage of ntcc with respect to previous models of Interactive Scores, Pd, Max and Petri Nets is representing declarative conditions by the means of constraints. Complex conditions, in particular those with an unknown number of parameters, are difficult to model in Max or Pd. To model generic conditions in Max or Pd, we would have to define each condition either in a new patch or in a predefined library. In Petri nets, we would have to define a net for each condition.

6.1 Future work

Ntccrt is not yet an interface for composers and designers of multimedia scenarios. For them is much more intuitive an interface such as Virage [4]. A graphical interface for our model should provide the means to specify the score as done in Example 3.3

Once we have the graphical interface, we plan to model audio processes in ntcc and replace them in the implementation by Faust programs [17] which also have formal semantics. Using Faust, we can gain efficiency and preserve the formal properties of our model (see [30] for a description of this idea).

7 Acknowledgements

We want to acknowledge Joseph Larralde and Camilo Rueda for their valuable comments on this model, and Andrés Porras for his editing contributions.