Subject: Re: [linux-audio-dev] News about sequencers (not my own though!)
From: Eli Brandt (eli_AT_gong.music.cs.cmu.edu)
Date: ke helmi 02 2000 - 14:56:35 EST
Paul Barton-Davis wrote:
> >Impossibility. :-) I can't even imagine writing FOF in Csound.
> >It may be theoretically possible, I'd have to think about that, but
> >surely it would be a disaster.
>
> If it would be a disaster for performance reasons, I suspect that this
> would be true of any interpreted language that wasn't written
> explicitly to support FOF. Thats why there is a "fof" opcode :)
No, a disaster because it would be totally and utterly unreadable,
unwritable, and undebuggable. It's hard even to think about. It
would have to look like the C code (which is pretty damn scary itself)
with all of the data structures smashed into some unstructured Csound
representation, if that can even be done. Whereas in the sort of
language I'm envisioning, FOF is under fifty lines of code, and clean.
And yeah, it would be slow.
> >> However, there were other issues too,
> >> and in the end, I don't consider Quasimodo to be that connected to
> >> Csound in any conceptual sense at all anymore.
> >
> >They're both unit-generator languages (scalar static dataflow), with a
> >score/orchestra division, so for my purposes they're in the same
> >family. Different from Lucid (lazy dataflow) or Sisal (first-order
> >functional with streams) or Fran (higher-order functional with type
> >constructors), for example.
>
> None of this is fundamentally true. Quasimodo has no particular
> connection to any unit-generator language, because at its core is not
> an intepreter, but a DSP simulator. The interpreter/compiler layer,
> which can be replaced, takes a given language and translates it into a
> series of DSP instructions.
Okay, when I was talking about Quasimodo as a language, I meant the
set of languages that are only a lex/yacc away, since that's how I
thought you meant to implement new languages. That set is, I believe,
scalar static dataflow.
Quasimodo as an engine is a different matter. If this interface is
documented and held stable, it may be an interesting target machine
for compilation. It's probably about as much work overall as
compiling to native code, but it's more flexible.
Is the "DSP simulator" something like Csound's interpreter loop? I'm
thinking about compiling Lucid into the latter, and it's feeling
awkward. Are you familiar with a particular one of the classes of
`other languages' I mentioned? I'm wondering what range of languages
the Q engine forms a reasonably natural processor for.
> As for the score/orc division, well, yes, to a certain extent. But
> scores in Quasimodo are reduced in importance, because its primary
> purpose is as a real-time device, not a playback engine.
Yeah, different goals. I want a composition tool, so I want the
score as data within the real language, where I can manipulate it.
My scores are mostly signals anyway.
> Right, but the question is: can the instruments patch themselves ?
(In Aura)
Instruments can; ugens can't. Repatching can happen while audio is
running because repatching and computation are both serialized through
the audio zone.
--
Eli Brandt | eli+@cs.cmu.edu | http://www.cs.cmu.edu/~eli/
fun (fof: float ivec)
(hzfund: float ivec) // fundamental freq
(octavi: float ivec) // downward octaviation (octaves)
(hzform: float ivec) // formant freq
(bw: float ivec) // bandwidth
(rise: float ivec) // rise time
(dur: float ivec) // duration
(fall: float ivec) // fall time
(sinetab: float vec) = // table holding one cycle of a sine
let
val (times: float ivec) = phasorwrap hzfund // burst times
val (bursts: float vec event ivec) =
{ (take (peek t dur) (osci sinetab (peek t hzform) (frac t))) @ t
: t in times } // BUG: tweak phase0 for subsample
val (envelopes: float vec ivec) = // BUG: tweak for subsample
{ let
val (bdur: float) = (peek t rise) - (peek t dur) - (peek t fall)
val (decayto: float) = (bw_to_decay (peek t bw)/AR) ^ bdur
in
join (linstage 0 (peek t rise) 1)
join (expstage 1 bdur decayto)
(linstage decayto (peek t fall) 0)
end
: t in times }
val (octmul: int ivec) = // i.e. loop [1 0^(2^i) 1-f 0^(2^i)]
{ let val (octi: int) = float_to_int (peek t octavi)
val (octf: float) = frac (peek t octavi)
val (p2: int) = 1<<octi
in
if (bitand i (p2-1)) then 0.0
else 1.0 - if (bitand i p2) then octf else 0.0
end
: t in times, i in (icount 0 1) }
val (unflattened: float vec event ivec) = // shape and place bursts
{ (octmul * {b*e: b in bursts, e in envelopes}) @ times
: in times, in bursts, in envelopes }
in
vfold op+ 0.0 unflattened // mix down
end
This archive was generated by hypermail 2b28 : pe maalis 10 2000 - 07:23:27 EST