|
Greetings to all,
I'm a PhD student under Barry Vercoe at the Media Lab and a long-time
lurker on this list. I'd like to give some details on recent developments
from MIT regarding structured audio and music composition languages.
Some of you have read and given feedback on our ICMC paper from last
year regarding Netsound, which was a "wrapper" allowing Csound orchestras
and scores to be transmitted via the Internet as a MIME type. There
has been great interest in this idea, if not the particular Csound
implementation, by many of the correspondants.
I have been working very hard for the last few months designing, with
Prof. Vercoe's help, a completely new "Music N" language which I imagine to
be the logical successor in this illustrious line of sound tools.
We have proposed this language to the MPEG consortium and have had it
written into the current draft of the upcoming MPEG-4 standard,
which now has a large "synthetic object coding" section. That is,
as well as using MPEG to transmit "natural audio" sounds like
speech, the speech can be accompanied by, synchronized with, and/or
post-processed by synthetic sound and music objects written in this new
language and delivered as part of the MPEG bitstream.
Previous versions of MPEG have been widely accepted in industry,
not just on the Internet, but especially in satellite broadcast
and other wide-casting applications, and we see no reason for
MPEG-4 to be any different.
We feel that this move -- including a well-designed, high-capability music
language in a widely-used international standard -- is a very good one for
the long-term "Csound community" for several reasons:
* as numerous recent discussions on this list have indicated, the
code base and language design of Csound could use an overhaul
* having the language standardized independantly from any particular
implementation means improvements and new implementations can
aim at a fixed target
* if content providers start wanting to ship sound content in
synthetic formats, the sound design skills of Csound experts become
a high-demand commodity
* those people who have donated their time for free over the years
to understanding and modifying the innards of Csound may become a
valuable resource to companies implementing the new language
* an open, fixed standard means many competing implementations on
many different architectures, which should result in higher-
performance implementations for everyone to use
On the other hand, development and support for Csound will, at least
in the near-term, continue as it always has.
The new language system as specified in the current MPEG-4 draft has
several components:
* A new orchestra syntax, called SAOL for "structured audio
orchestra language". This language is based on Music-N concepts,
but has been completely redesigned from the ground up, including:
- A block-structured C-like syntax built around names rather
than numbers
- User-defined opcodes built into the language
- A bus/send/return metaphor for complex effects processing
control and dynamic specification
- Some new opcodes, including FFT/IFFT
- Pruning of some old opcodes
A commented example of a SAOL orchestra follows at the end
of the message.
* A score file syntax, which is more-or-less like the Csound score
* A JAVA interface for specification of real-time interactive applications
in a platform-independent way, including MIDI control and interaction
API interfaces. You will be able to write "interactive music
applications" in JAVA, bundle them with an SAOL orchestra and score files,
and distribute the whole package on the web for platform-independant
use.
The draft language standard is available from my web site at
http://sound.media.mit.edu/~eds/mpeg4/ in Microsoft Word
for Windows and plain-ASCII formats. If you don't have web
access and would like a plain-ASCII version, I can email it to
you, but it's very long (nearly 100 pages in Word format).
We are very interested in comments and feedback from the Csound
community on the language while the standard is still being revised.
There are still many "bugs" in the language I'm aware of, and I
know how to patch some of them, but I'd like to have as many opinions
as possible. There are relatively few experts in musical sound
synthesis within the MPEG community, so they won't be providing
very much feedback to us, and we hope that interested people from
the Csound community will take the time to help us instead.
Feedback on the draft standard can be sent to me at eds@media.mit.edu;
please right now only make comments on the current draft. I probably
won't respond to questions like "is feature X included?"; that's what
the document is for. However, if you've read the draft and think
some other feature should be included, or especially if you think
something is broken as it's included now, I'd be happy to hear your
thoughts. The current draft won't become the standard for another
year and a half, so there's plenty of time to make your opinion
heard.
As of right now, there are no running implementations of the MPEG
Structured Audio system. I'm working very hard on building a "test
implementation" for Unix boxes, and it may be done in a few weeks, but
it likely won't be optimized enough to be suitable for doing much
in real-time; this implementation is only to test the language as
part of the drafting process. This source code will be released
into the public domain when it's ready.
I'm also starting up a mailing list for people who are interested in
discussing "how to implement" SAOL and the MPEG Structured Audio
system, or related tasks like building authoring tools; please send
email to saol-dev-request@media.mit.edu to be added.
Thanks for your time, and best music-making!
-- Eric
--------------- example orchestra: testbus.saol ------------
// this orchestra implements a simple enveloped oscillator, and
// uses the "bus/send" mechanism of SAOL to make the overall
// output clip when it crosses a certain threshhold.
global {
// define global parameters
srate 22050;
krate 441;
// specify a global wavetable
table t(harm,2048,1,1,1,0,1,0,1,0,1,0,.5,0,.5,0,.2);
// route all the output from the 'test_instr' notes onto the
// bus called "clip_bus". This means 'test_instr' output doesn't
// make sound, but gets routed onto the bus for further processing.
route(clip_bus, test_instr);
// send the "clip_bus" to the instrument called "clip"
send(clip; 0.25 ;clip_bus);
}
instr test_instr(cfreq,amp,p3) {
// define variables
asig vibfreq,a;
ksig env;
// use a global wavetable
imports table t;
// and also a local one
table vib(harm,128,1);
// note that signal variables are typed by rate
ivar foo;
// call a user-defined opcode
foo = scale_table(t,0.9);
// opcodes embed in expressions
vibfreq = cpsmidi(cfreq) * (oscil(vib,5,-1)*0.01 + 1);
// two more UDOs
a = my_osc(t,vibfreq,amp);
// "dur" is a _standard name_ -- it's always available
env = kadsr(dur * 0.05, 1, dur * 0.15, .6, dur * 0.2, dur * 0.6);
// make sound
// but doesn't really make sound since the instrument has been
// globally rerouted
output(a * env);
}
aopcode my_osc(table t,xsig freq, ivar amp) {
// this is a user-declared opcode; it implements
// an oscillator which runs forever at a given amplitude
asig res;
// use the core opcode "oscil"
res = oscil(t,freq,-1) * amp;
return(res);
}
kopcode kadsr(ivar at,ivar height,ivar dt, ivar sus, ivar st, ivar rt) {
// note that UDOs are also typed by rate
ksig env;
// use the core opcode "kline"
env = kline(0,at,height,dt,sus,st,sus,rt,0);
return(env);
}
instr clip(clippoint) {
// this instrument is used for the global send.
// its output really goes to make sound
asig a;
// another local wavetable -- built on pfield expressions.
table cliptable(lineseg,2048,0,-clippoint,1024 - clippoint*1024,
-clippoint,1024+clippoint*1024,clippoint,2047,clippoint);
// if-then-else constructions
if (abs(input) >= 1) {
a = 2047;
}
else {
// 'input' is a standard name.
a = input * 1024 + 1024;
}
// tableread is a core opcode
output(tableread(cliptable,a));
}
iopcode scale_table(table t, ivar scale) {
// this opcode modifies its 't' parameter (all parameters are
// call-by-reference whenever possible), to scale the table to
// a specific height.
// note that it runs only in i-time since it's an 'iopcode'
ivar i,max,foo;
i=0; max = 0;
// while construction //
while (i < ftlen(t)) {
if (tableread(t,i) > max) {
max = tableread(t,i);
}
i = i+1;
}
if (max != scale) {
i=0;
while (i
| 617 253 0112 | Dmaj7 | Ab-7 Db7 | Gbmaj7 | G-7 C7 |
+-------------------+ |