ReactiveML has been used to implement a sequencer for mixed music. Here, we present a simple library that takes advantage of the expressiveness of ReactiveML to program the classic French musical round "Frère Jacques".
Traditionally, in western music, a melody is a sequence of notes, where a note is a sound event characterized by a pitch and a duration. Notes can be defined with the following types using a syntax similar to the one of OCaml.
(** Pitch class of a note (Af = A flat, As = A sharp, ...). *) type pitch_class = | A | Af | As | B | Bf | Bs | C | Cf | Cs | D | Df | Ds | E | Ef | Es | F | Ff | Fs | G | Gf | Gs (** Octave *) type octave = int (** Pitch *) type pitch = pitch_class * octave (** Duration *) type dur = float (** Note*) type note = dur * pitch
The pitch is represented by a pair
pitch_class denotes one of the
twelve semi-tones, e.g., A, A#, A♭, B, B#..., and octave is an
integer. For instance
(A,4) denotes the famous A 440Hz.
Using these data types, we can define the score of Frère Jacques as list of notes:
let jacques = [1.0, (F,4); 1.0, (G,4); 1.0, (A,4); 1.0, (F,4); 1.0, (F,4); 1.0, (G,4); 1.0, (A,4); 1.0, (F,4); 1.0, (A,4); 1.0, (Bf,4); 2.0, (C,5); 1.0, (A,4); 1.0, (Bf,4); 2.0, (C,5); 0.5, (C,5); 0.5, (D,5); 0.5, (C,5); 0.5, (Bf,4); 1.0, (A,4); 1.0, (F,4); 0.5, (C,5); 0.5, (D,5); 0.5, (C,5); 0.5, (Bf,4); 1.0, (A,4); 1.0, (F,4); 1.0, (F,4); 1.0, (C,4); 2.0, (F,4); 1.0, (F,4); 1.0, (C,4); 2.0, (F,4);]
In order to play the score, we have to build a link between the
logical time and the physical time. Let us define a
clock which will be emitted
signal clock let period = 0.01
emit_clock emits the
clock. The function
Unix module gives access to the physical time:
let process emit_clock = (* set the next deadline *) let next = ref (Unix.gettimeofday () +. period) in loop let current = Unix.gettimeofday () in (* check if the deadline has been reached *) if (current >= !next) then begin emit clock (); next := !next +. period; (* update the next deadline *) end; pause end
Now, to wait a duration of
dur seconds, we only have to
count the occurrences of the signal
let process wait dur = let d = int_of_float (dur /. period) in for i = 1 to d do await clock done
A performance is represented by a signal on which notes to play are sent.
signal perf default  gather (fun x y -> x::y)
The execution of a score is the traversal of the list of notes at the right speed.
let rec process play sequence = match sequence with |  -> () | ((dur, pitch) as note) :: s -> emit perf note; run (wait dur); run (play s)
In order to produce actual sounds, notes are converted into UDP messages and sent to an audio environment. This is done by the process
sender. This process awaits notes produced on the signal
perf and sends UDP messages.
let send_to_audio sock note = let m = Music.string_of_note note in Network.sendUDP m sock 7400 () let process sender = let sock = Network.init_client () in print_endline ("playing on port : "^(string_of_int 7400)); loop await perf (notes) in List.iter (fun n -> send_to_audio sock n) notes end
To test our implementation, we can play the theme as an infinite repetition of the score:
let process theme = loop run (play jacques) end
Finally, the main process is the parallel composition of the metronome (the
emit_clock process), the theme and the
let process main = run emit_clock || run theme || run sender
Now to perform a round, we first define a process
delayed which delays the execution of a process:
let process delayed p dur = run (wait dur); run p
Then, we can execute the theme four times in parallel, each time delayed by 8 seconds:
let process round_basic = run theme || run (delayed theme 8.0) || run (delayed theme 16.0) || run (delayed theme 24.0)
Finally, we can redefine the round using parallel iterations or recursive processes:
let process round_for = for i = 0 to 3 dopar run (delayed theme (float (i * 8))) done let rec process round nb_voices = if nb_voices <= 0 then () else begin run theme || run (delayed (round (nb_voices - 1)) 8.0) end
Here is the result of the round:
The complete implementation is available in the
examples/reactive_asco of the ReactiveML