Hi all,

I've spent quite a bit of time with Iain Mccurdy's RT examples, including the BasicMonosynth, etc.

With MIDI, it doesn't seem right, the envelopes don't behave like an old monophonic modular or minimoog. Even with fast attack times, the McCurdy examples are sluggish, and the triggering isn't like one expects.

The idea is to use schedulekwhen to trigger and instrument, limit the instances of a sounding synth instrument to 1, etc. but how can I do this magic with MIDI envelopes: I want and instrument that will play a sustained legato envelope if there are two or more MIDI notes playing (in effect, a legato keyboard touch, sensed with the 'active' opcode)....AND---when the number of instruments jumps from 0 to 1, there should be a trigger of the attack of an envelope, and if the number of instruments goes from 1 to 0, there should be a release envelope. However, if the release is long, there should be a global variable that holds a current global envelope level so that if I restrike before release hits 0, the attack takes it from there, just like an old MiniMoog....

Complex to implement, and Mccurdy is a god at RT instruments, but doesn't quite get it right like some Linux softsynths do (whysynth, xsynth, etc. in monophonic mode and 'non-legato' only re-triggers) -- Mccurdy uses two instruments, one for sensing MIDI, one to play. I'm thinking to do this right, we'd need at least 3 if not 4 instruments: one to sense MIDI, one to trigger global envelopes, and another always on instrument that

To my mind/ear, a HUGE part of what makes some synth sounds ultra-fat is the mono-line and portamento/legato element. Being able to do this trouble-free in CSound would be awesome, b/c the generality and flexibility to go beyond subtractive synthesis yet keep the monosynth ideal are very appealing.

--
Best,

Aaron Krister Johnson
http://www.akjmusic.com
http://www.untwelve.org

Hi all,

I've spent quite a bit of time with Iain Mccurdy's RT examples, including the BasicMonosynth, etc.

With MIDI, it doesn't seem right, the envelopes don't behave like an old monophonic modular or minimoog. Even with fast attack times, the McCurdy examples are sluggish, and the triggering isn't like one expects.

The idea is to use schedulekwhen to trigger and instrument, limit the instances of a sounding synth instrument to 1, etc. but how can I do this magic with MIDI envelopes: I want and instrument that will play a sustained legato envelope if there are two or more MIDI notes playing (in effect, a legato keyboard touch, sensed with the 'active' opcode)....AND---when the number of instruments jumps from 0 to 1, there should be a trigger of the attack of an envelope, and if the number of instruments goes from 1 to 0, there should be a release envelope. However, if the release is long, there should be a global variable that holds a current global envelope level so that if I restrike before release hits 0, the attack takes it from there, just like an old MiniMoog....

Complex to implement, and Mccurdy is a god at RT instruments, but doesn't quite get it right like some Linux softsynths do (whysynth, xsynth, etc. in monophonic mode and 'non-legato' only re-triggers) -- Mccurdy uses two instruments, one for sensing MIDI, one to play. I'm thinking to do this right, we'd need at least 3 if not 4 instruments: one to sense MIDI, one to trigger global envelopes, and another always on instrument that

To my mind/ear, a HUGE part of what makes some synth sounds ultra-fat is the mono-line and portamento/legato element. Being able to do this trouble-free in CSound would be awesome, b/c the generality and flexibility to go beyond subtractive synthesis yet keep the monosynth ideal are very appealing.

--
Best,

Aaron Krister Johnson
http://www.akjmusic.com
http://www.untwelve.org

It might be nice eventually to have some opcodes or architecture that simplify two issues:

1) polyphony limits without clicks (so I can say, only 8 voices please, of this thing, and it doesn't just stop at 8, but figures out what the oldest instance was and turns it off, sort of like a 'turnoff2' on steroids, although I suppose an UDO can be wipped up combining 'turnoff2' and 'active'

2) easy setup of monosynth situations for legato/portamento. related to above but extremel easy to use, no re-inventing the wheel...

AKJ

On Fri, Jun 11, 2010 at 1:53 AM, Aaron Krister Johnson <aaron@akjmusic.com> wrote:

Hi all,

I've spent quite a bit of time with Iain Mccurdy's RT examples, including the BasicMonosynth, etc.

With MIDI, it doesn't seem right, the envelopes don't behave like an old monophonic modular or minimoog. Even with fast attack times, the McCurdy examples are sluggish, and the triggering isn't like one expects.

The idea is to use schedulekwhen to trigger and instrument, limit the instances of a sounding synth instrument to 1, etc. but how can I do this magic with MIDI envelopes: I want and instrument that will play a sustained legato envelope if there are two or more MIDI notes playing (in effect, a legato keyboard touch, sensed with the 'active' opcode)....AND---when the number of instruments jumps from 0 to 1, there should be a trigger of the attack of an envelope, and if the number of instruments goes from 1 to 0, there should be a release envelope. However, if the release is long, there should be a global variable that holds a current global envelope level so that if I restrike before release hits 0, the attack takes it from there, just like an old MiniMoog....

Complex to implement, and Mccurdy is a god at RT instruments, but doesn't quite get it right like some Linux softsynths do (whysynth, xsynth, etc. in monophonic mode and 'non-legato' only re-triggers) -- Mccurdy uses two instruments, one for sensing MIDI, one to play. I'm thinking to do this right, we'd need at least 3 if not 4 instruments: one to sense MIDI, one to trigger global envelopes, and another always on instrument that

To my mind/ear, a HUGE part of what makes some synth sounds ultra-fat is the mono-line and portamento/legato element. Being able to do this trouble-free in CSound would be awesome, b/c the generality and flexibility to go beyond subtractive synthesis yet keep the monosynth ideal are very appealing.

--
Best,

Aaron Krister Johnson
http://www.akjmusic.com
http://www.untwelve.org

--
Best,

Aaron Krister Johnson
http://www.akjmusic.com
http://www.untwelve.org

Hi,

May be this can be use...

The midi-mono part is from "Midi controlled monosynth. Iain Duncan, Nov 30, 2002" found in csound list a long time ago.

Best,
René

2010/6/11 Aaron Krister Johnson <aaron@akjmusic.com>

It might be nice eventually to have some opcodes or architecture that simplify two issues:

1) polyphony limits without clicks (so I can say, only 8 voices please, of this thing, and it doesn't just stop at 8, but figures out what the oldest instance was and turns it off, sort of like a 'turnoff2' on steroids, although I suppose an UDO can be wipped up combining 'turnoff2' and 'active'

2) easy setup of monosynth situations for legato/portamento. related to above but extremel easy to use, no re-inventing the wheel...

AKJ

On Fri, Jun 11, 2010 at 1:53 AM, Aaron Krister Johnson <aaron@akjmusic.com> wrote:

Hi all,

I've spent quite a bit of time with Iain Mccurdy's RT examples, including the BasicMonosynth, etc.

With MIDI, it doesn't seem right, the envelopes don't behave like an old monophonic modular or minimoog. Even with fast attack times, the McCurdy examples are sluggish, and the triggering isn't like one expects.

The idea is to use schedulekwhen to trigger and instrument, limit the instances of a sounding synth instrument to 1, etc. but how can I do this magic with MIDI envelopes: I want and instrument that will play a sustained legato envelope if there are two or more MIDI notes playing (in effect, a legato keyboard touch, sensed with the 'active' opcode)....AND---when the number of instruments jumps from 0 to 1, there should be a trigger of the attack of an envelope, and if the number of instruments goes from 1 to 0, there should be a release envelope. However, if the release is long, there should be a global variable that holds a current global envelope level so that if I restrike before release hits 0, the attack takes it from there, just like an old MiniMoog....

Complex to implement, and Mccurdy is a god at RT instruments, but doesn't quite get it right like some Linux softsynths do (whysynth, xsynth, etc. in monophonic mode and 'non-legato' only re-triggers) -- Mccurdy uses two instruments, one for sensing MIDI, one to play. I'm thinking to do this right, we'd need at least 3 if not 4 instruments: one to sense MIDI, one to trigger global envelopes, and another always on instrument that

To my mind/ear, a HUGE part of what makes some synth sounds ultra-fat is the mono-line and portamento/legato element. Being able to do this trouble-free in CSound would be awesome, b/c the generality and flexibility to go beyond subtractive synthesis yet keep the monosynth ideal are very appealing.

--
Best,

Aaron Krister Johnson
http://www.akjmusic.com
http://www.untwelve.org

--
Best,

Aaron Krister Johnson
http://www.akjmusic.com
http://www.untwelve.org

Hi Aaron,

Thanks for the suggestions with regard to these examples - I admit they are a bit old and perhaps in need of updating. I am no expert in monosynth design and have experience with just a few hardware examples but the way I saw it there were two ways to implement envelopes in a monophonic synth: 1. an envelope that is re-triggered with each new note played, whether a tied note or not and 2. an envelope that is triggered only at the beginning of a stream of tied notes i.e. by an un-tied note. In the Basic Monosynth example the first envelope method is used by the vibrato envelope and the second envelope method is used for the filter. The filter envelope is a MIDI envelope in that it uses linsegr and has a release stage, the other does not but could be modified.
Your fourth suggestion I haven't implemented (perhaps this is where the sense of 'sluggishness' comes in?) but this could perhaps be done by using the global variable value of an envelope as the initial value of the envelope itself so it would effectively 'pick up where it left off'.
I suspected at the time that there was a certain flakiness introduced by the interaction between the release stages of the 'r' envelopes and the 'active' sensing but haven't delved further into this. The other area where I felt further work was needed was in the rule used to govern monophonic behaviour when notes are released. In my example the most recent note pressed takes precedence (I think this would be the most common mode), but other rules are possible.
I am not really working in this area at the moment but have thought about trying to create a implementation of a Minimoog as an exercise some time. I would first have to research the Minimoog a bit more though!
I will file your suggestions and have a another look at this some time. Please let us know of any successes you have.

Bye,
Iain
  

________________________________
> Date: Fri, 11 Jun 2010 02:28:23 -0500
> From: aaron@akjmusic.com
> To: csound@lists.bath.ac.uk
> Subject: [Csnd] Re: monosynth puzzler

>
> More thinking about this:
>
> Here's my idea---4 instruments to do one meta-instrument:
>
> 1) a midi instrument that will trigger, once (it will stay on and only be one instance, due to schedkwhen) a
>
> 2) basic vco instrument w/o any envelopes. This instrument is always on, but the envelopes are actually going to be globally referenced from instrument 4, making it appear to reinit.
>
> 3) a third instrument, also triggered by instr1 and limited to one instance, watches instr1 for active counts, and triggers a 4th instrument with certain p-filed options based on logic: if the active count goes from 0 to 1, trigger an attack envelope. If it goes from 1 to 0, trigger a release segment. Anything else is legato, so trigger a legato (level) signal, using if neccessary a global 'current level of the envelope' variable.
>
> 4) the envelope instrument which creates a global envelope to control instrument 2. The envelope can save its state at k-rate into a 'feedback' holding variable, which can be used if instr3 retriggers instr4. So, if there is a long release happening, interrupted by an attack, the attack will start where the release left off, for smooth 'clickless' performance.
>
> I have a feeling this will work, but I'm wondering if it actually will, and/or if there isn't a more elegant way.....
>
> AKJ
>

> On Fri, Jun 11, 2010 at 1:53 AM, Aaron Krister Johnson> wrote:
> Hi all,
>
> I've spent quite a bit of time with Iain Mccurdy's RT examples, including the BasicMonosynth, etc.
>
> With MIDI, it doesn't seem right, the envelopes don't behave like an old monophonic modular or minimoog. Even with fast attack times, the McCurdy examples are sluggish, and the triggering isn't like one expects.
>
> The idea is to use schedulekwhen to trigger and instrument, limit the instances of a sounding synth instrument to 1, etc. but how can I do this magic with MIDI envelopes: I want and instrument that will play a sustained legato envelope if there are two or more MIDI notes playing (in effect, a legato keyboard touch, sensed with the 'active' opcode)....AND---when the number of instruments jumps from 0 to 1, there should be a trigger of the attack of an envelope, and if the number of instruments goes from 1 to 0, there should be a release envelope. However, if the release is long, there should be a global variable that holds a current global envelope level so that if I restrike before release hits 0, the attack takes it from there, just like an old MiniMoog....
>
> Complex to implement, and Mccurdy is a god at RT instruments, but doesn't quite get it right like some Linux softsynths do (whysynth, xsynth, etc. in monophonic mode and 'non-legato' only re-triggers) -- Mccurdy uses two instruments, one for sensing MIDI, one to play. I'm thinking to do this right, we'd need at least 3 if not 4 instruments: one to sense MIDI, one to trigger global envelopes, and another always on instrument that
>
> To my mind/ear, a HUGE part of what makes some synth sounds ultra-fat is the mono-line and portamento/legato element. Being able to do this trouble-free in CSound would be awesome, b/c the generality and flexibility to go beyond subtractive synthesis yet keep the monosynth ideal are very appealing.
>
> --
> Best,
>
> Aaron Krister Johnson
> http://www.akjmusic.com
> http://www.untwelve.org
>
>
>
>
> --
> Best,
>
> Aaron Krister Johnson
> http://www.akjmusic.com
> http://www.untwelve.org
>

_________________________________________________________________
http://clk.atdmt.com/UKM/go/195013117/direct/01/
We want to hear all your funny, exciting and crazy Hotmail stories. Tell us now

Send bugs reports to the Sourceforge bug tracker
           https://sourceforge.net/tracker/?group_id=81968&atid=564599
Discussions of bugs and features can be posted here
To unsubscribe, send email sympa@lists.bath.ac.uk with body "unsubscribe csound"