I'm using Cabbage synth plugins to output synth data to text files so
they can be imported into a 3d modeling program and I'm at the point
now where I need to get an accurate depiction of the volume envelope
to match an existing piano synth. The attack and release are no
problem because they're very short and can be modeled with a straight
line, but the decay and lack of sustain make a typical ADSR envelope
unusable. What's the best way to depict the long and logarithmic decay
phase of a piano in Csound?

~ Andy Fillebrown

------------------------------------------------------------------------------
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

You could probably use follow (a-rate) or rms (k-rate) envelope 
followers and store the results in a table.
Ideal if this is an existing synth..

Richard

On 06/06/15 18:32, andy fillebrown wrote:
> I'm using Cabbage synth plugins to output synth data to text files so
> they can be imported into a 3d modeling program and I'm at the point
> now where I need to get an accurate depiction of the volume envelope
> to match an existing piano synth. The attack and release are no
> problem because they're very short and can be modeled with a straight
> line, but the decay and lack of sustain make a typical ADSR envelope
> unusable. What's the best way to depict the long and logarithmic decay
> phase of a piano in Csound?
>
> ~ Andy Fillebrown
>
> ------------------------------------------------------------------------------
> _______________________________________________
> Csound-users mailing list
> Csound-users@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/csound-users
> Send bugs reports to
>          https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here


------------------------------------------------------------------------------
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

You could play with transeg or its variats.

==John ff

On Sat, 6 Jun 2015, andy fillebrown wrote:

> I'm using Cabbage synth plugins to output synth data to text files so
> they can be imported into a 3d modeling program and I'm at the point
> now where I need to get an accurate depiction of the volume envelope
> to match an existing piano synth. The attack and release are no
> problem because they're very short and can be modeled with a straight
> line, but the decay and lack of sustain make a typical ADSR envelope
> unusable. What's the best way to depict the long and logarithmic decay
> phase of a piano in Csound?
>
> ~ Andy Fillebrown
>
> ------------------------------------------------------------------------------
> _______________________________________________
> Csound-users mailing list
> Csound-users@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/csound-users
> Send bugs reports to
>        https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here
>

------------------------------------------------------------------------------
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

el 2015-06-06 a las 12:32 andy fillebrown escribió:

> What's the best way to depict the long and logarithmic decay phase of a
> piano in Csound?

to this end i normally combine two envelopes: one with a short attack and
an approximately exponential decay (for example, with transeg or even
expseg). the rate of the decay depends on the pitch of the note, and is
independent of the duration (p3). to emulate the natural decay, i try to
measure the decay times for different registers of the instrument.

then i combine this envelope with a second one that has a value of 1 for
(p3 - release time) seconds, and then a short linear release to 0.

multiplying the two i get a fair approximation to the envelope pf the
piano/guitar/etc. 

alternatively, you could try your hand at the (mostly forgotten?) envlpx
opcode. with a negative attenuation factor (iatss) you can get similar
results. personally i find the other approach much simpler.

i trust my explanations have not been very clear...


------------------------------------------------------------------------------
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

Transeg

Hi Andy,

I tried working on this a bit the other day but got not quite
satisfying results.  I tried again today with a basic start using
transegr:



/*-o test.wav -W*/



sr      =       48000
ksmps   =      64
nchnls  =       2
0dbfs  =      1.0

instr 1
ipch = cps2pch(p4, 12)
a1  = moogladder(vco2(0.5,ipch), 4000, 0.2)
aenv = transegr:a(0.0, 0.02, 0, 1.0,
                4.0, -2, 0.0,
                0.1, 0, 0.0)
aout = a1 * aenv
outs aout, aout
endin



i1 0 3.0 7.00
i1 0 7.0 9.00
i1 0 2.0 8.05
e



This does have a linear start, convex curve to 0 over 4.0 seconds, and
if p3 is less than 4.0, then the linear release segment kicks in.

However, this doesn't take into account two things: the amplitude of
the note, nor the decay time of the string. I think that:

1. The decay *rate* should be the same no matter how loud you hit the
note.  If you hit the note at max volume, it should take longer to get
to 0.0 than if you hit the note at less than max.
2. The max decay time should dependent on frequency.  Higher notes
decay more quickly than lower notes.

With transegr, rate of decay is dependent upon the itype and the
duration of the segment.  However, in my own way of thinking, I want
really to define the rate of decay and release, and let duration be
worked out from there.  I'm trying out an idea now with a UDO and will
post that once that's done.

steven

On Sat, Jun 6, 2015 at 12:32 PM, andy fillebrown
 wrote:
> I'm using Cabbage synth plugins to output synth data to text files so
> they can be imported into a 3d modeling program and I'm at the point
> now where I need to get an accurate depiction of the volume envelope
> to match an existing piano synth. The attack and release are no
> problem because they're very short and can be modeled with a straight
> line, but the decay and lack of sustain make a typical ADSR envelope
> unusable. What's the best way to depict the long and logarithmic decay
> phase of a piano in Csound?
>
> ~ Andy Fillebrown
>
> ------------------------------------------------------------------------------
> _______________________________________________
> Csound-users mailing list
> Csound-users@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/csound-users
> Send bugs reports to
>         https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here

------------------------------------------------------------------------------
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

Following up, I wrote a UDO called piano_env that takes in an attack
time, amplitude to go up to, then decay time and release time.  The
decay and release time give times for 1.0 to reach 0.0001 over given
time.  Those rates will be respected if you start at a smaller
amplitude such that the rate is constant.

In the instrument (instr 2) is the adjustment for decay and release
time dependent on frequency.  I'm using pow to give an exponential
curve to the adjustment.  I sort of fussed with the range of
frequency, so the curve is going from about 20-3000 hz.  The result is
that lower notes will ring longer than higher notes given the same
amplitude.

The amplitude envelope sounds good to my ear, though you'll probably
want to change out the synthesis method.

The code is pasted below, and I've also attached a copy of the CSD.

Hope others find this useful; any suggestions for improvement appreciated!
steven





/*-o test.wav -W*/



sr      =       48000
ksmps   =      64
nchnls  =       2
0dbfs  =      1.0

opcode piano_env, a, iiii
iattack_time, iamp, idecay_time, irelease_time xin

/*idecay_rate = exp(-1.0 / (idecay_time * sr))*/
/*irelease_rate = exp(-1.0 / (irelease_time * sr))*/
idecay_rate = pow(0.001, 1.0 / (idecay_time * sr))
irelease_rate = pow(0.001, 1.0 / (irelease_time * sr))

/*print idecay_time*/
/*print idecay_rate*/
/*print irelease_time*/
/*print irelease_rate*/

asig init 0
kindx = 0
klastval init 0
kstate init 0 ; 0,1,2 - attack, decay, release
kreleasing release

ktotal_indx init 0
iattack_samples = int(iattack_time * sr)
iattack_incr = iamp / iattack_samples

xtratim irelease_time
/*printk2 kstate*/
until (kindx >= ksmps) do
  if(kreleasing == 1) then
    asig[kindx] = klastval
    klastval *= irelease_rate
  elseif(kstate == 0) then
    asig[kindx] = klastval
    klastval += iattack_incr
    ktotal_indx += 1
    if(ktotal_indx >= iattack_samples) then
      kstate = 1
    endif
  elseif(kstate == 1) then
    asig[kindx] = klastval
    klastval *= idecay_rate
    if(klastval <= 0.0001) then
      kstate = 2
    endif
  else
    asig[kindx] = 0.0
  endif
  kindx += 1
od

xout asig
endop

instr 1
ipch = cps2pch(p4, 12)
a1  = moogladder(vco2(0.5,ipch), 4000, 0.2)
aenv = transegr:a(0.0, 0.02, 0, 1.0,
                4.0, -2, 0.0,
                0.1, 0, 0.0)
aout = a1 * aenv
outs aout, aout
endin


instr 2
ipch = cps2pch(p4, 12)
iamp = ampdbfs(p5)
a1  = moogladder(
        (vco2(0.5,ipch) + vco2(0.5, ipch - 0.02) + vco2(0.5, ipch + .017)),
        2000, 0.2)

/*idur_adjust = (ipch - 20)  ((ipch - 20) / 10000)*/
idur_adjust = pow(0.05, min:i((ipch - 20), 3000)/3000)


print ipch
print idur_adjust

aenv = piano_env(0.02, iamp, 8.0 * idur_adjust, 0.3 * idur_adjust)
aout = a1 * aenv * 0.333
outs aout, aout
endin






;; decay time should be frequency dependent
i2 0.0 8.0 7.00 -12
i2 0.0 .   8.00 .
i2 0.0 .   9.00 .
i2 0.0 .   10.00 .

s
;; rate should be same even if starting from lower amplitude
;; so lower amp = shorter duration of decay time
i2 0.0 2.0 7.00 -12
i2 1.0 .   7.00 -14
i2 2.0 .   7.00 -16
i2 3.0 .   7.00 -18


s
i2 0.0 2.0 7.00 -12
i2 0.5 1.5 8.00 -12
i2 1.0 1.0 8.07 -12
i2 1.5 0.5 9.00 -12


i2 2.0 6.0 7.00 -12
i2 2.5 6.5 8.00 -12
i2 3.0 5.0 8.07 -12
i2 3.5 5.5 9.00 -12


e



On Sun, Jun 7, 2015 at 7:04 PM, Steven Yi  wrote:
> Hi Andy,
>
> I tried working on this a bit the other day but got not quite
> satisfying results.  I tried again today with a basic start using
> transegr:
>
> 
> 
> /*-o test.wav -W*/
> 
>
> 
> sr      =       48000
> ksmps   =      64
> nchnls  =       2
> 0dbfs  =      1.0
>
> instr 1
> ipch = cps2pch(p4, 12)
> a1  = moogladder(vco2(0.5,ipch), 4000, 0.2)
> aenv = transegr:a(0.0, 0.02, 0, 1.0,
>                 4.0, -2, 0.0,
>                 0.1, 0, 0.0)
> aout = a1 * aenv
> outs aout, aout
> endin
>
> 
> 
> i1 0 3.0 7.00
> i1 0 7.0 9.00
> i1 0 2.0 8.05
> e
> 
> 
>
> This does have a linear start, convex curve to 0 over 4.0 seconds, and
> if p3 is less than 4.0, then the linear release segment kicks in.
>
> However, this doesn't take into account two things: the amplitude of
> the note, nor the decay time of the string. I think that:
>
> 1. The decay *rate* should be the same no matter how loud you hit the
> note.  If you hit the note at max volume, it should take longer to get
> to 0.0 than if you hit the note at less than max.
> 2. The max decay time should dependent on frequency.  Higher notes
> decay more quickly than lower notes.
>
> With transegr, rate of decay is dependent upon the itype and the
> duration of the segment.  However, in my own way of thinking, I want
> really to define the rate of decay and release, and let duration be
> worked out from there.  I'm trying out an idea now with a UDO and will
> post that once that's done.
>
> steven
>
> On Sat, Jun 6, 2015 at 12:32 PM, andy fillebrown
>  wrote:
>> I'm using Cabbage synth plugins to output synth data to text files so
>> they can be imported into a 3d modeling program and I'm at the point
>> now where I need to get an accurate depiction of the volume envelope
>> to match an existing piano synth. The attack and release are no
>> problem because they're very short and can be modeled with a straight
>> line, but the decay and lack of sustain make a typical ADSR envelope
>> unusable. What's the best way to depict the long and logarithmic decay
>> phase of a piano in Csound?
>>
>> ~ Andy Fillebrown
>>
>> ------------------------------------------------------------------------------
>> _______________________________________________
>> Csound-users mailing list
>> Csound-users@lists.sourceforge.net
>> https://lists.sourceforge.net/lists/listinfo/csound-users
>> Send bugs reports to
>>         https://github.com/csound/csound/issues
>> Discussions of bugs and features can be posted here

Hi Steven,

do you think trying to port this to Csound5 makes any sense?
...on my Windows machine I downgraded after some installation issues
with Csound6. Well, maybe they are gone now...

Best,
Wolf

Am 08.06.2015 um 03:49 schrieb Steven Yi:
> Following up, I wrote a UDO called piano_env that takes in an attack
> time, amplitude to go up to, then decay time and release time.  The
> decay and release time give times for 1.0 to reach 0.0001 over given
> time.  Those rates will be respected if you start at a smaller
> amplitude such that the rate is constant.
> 
> In the instrument (instr 2) is the adjustment for decay and release
> time dependent on frequency.  I'm using pow to give an exponential
> curve to the adjustment.  I sort of fussed with the range of
> frequency, so the curve is going from about 20-3000 hz.  The result is
> that lower notes will ring longer than higher notes given the same
> amplitude.
> 
> The amplitude envelope sounds good to my ear, though you'll probably
> want to change out the synthesis method.
> 
> The code is pasted below, and I've also attached a copy of the CSD.
> 
> Hope others find this useful; any suggestions for improvement appreciated!
> steven
> 
> 
> 
> 
> 
> /*-o test.wav -W*/
> 
> 
> 
> sr      =       48000
> ksmps   =      64
> nchnls  =       2
> 0dbfs  =      1.0
> 
> opcode piano_env, a, iiii
> iattack_time, iamp, idecay_time, irelease_time xin
> 
> /*idecay_rate = exp(-1.0 / (idecay_time * sr))*/
> /*irelease_rate = exp(-1.0 / (irelease_time * sr))*/
> idecay_rate = pow(0.001, 1.0 / (idecay_time * sr))
> irelease_rate = pow(0.001, 1.0 / (irelease_time * sr))
> 
> /*print idecay_time*/
> /*print idecay_rate*/
> /*print irelease_time*/
> /*print irelease_rate*/
> 
> asig init 0
> kindx = 0
> klastval init 0
> kstate init 0 ; 0,1,2 - attack, decay, release
> kreleasing release
> 
> ktotal_indx init 0
> iattack_samples = int(iattack_time * sr)
> iattack_incr = iamp / iattack_samples
> 
> xtratim irelease_time
> /*printk2 kstate*/
> until (kindx >= ksmps) do
>   if(kreleasing == 1) then
>     asig[kindx] = klastval
>     klastval *= irelease_rate
>   elseif(kstate == 0) then
>     asig[kindx] = klastval
>     klastval += iattack_incr
>     ktotal_indx += 1
>     if(ktotal_indx >= iattack_samples) then
>       kstate = 1
>     endif
>   elseif(kstate == 1) then
>     asig[kindx] = klastval
>     klastval *= idecay_rate
>     if(klastval <= 0.0001) then
>       kstate = 2
>     endif
>   else
>     asig[kindx] = 0.0
>   endif
>   kindx += 1
> od
> 
> xout asig
> endop
> 
> instr 1
> ipch = cps2pch(p4, 12)
> a1  = moogladder(vco2(0.5,ipch), 4000, 0.2)
> aenv = transegr:a(0.0, 0.02, 0, 1.0,
>                 4.0, -2, 0.0,
>                 0.1, 0, 0.0)
> aout = a1 * aenv
> outs aout, aout
> endin
> 
> 
> instr 2
> ipch = cps2pch(p4, 12)
> iamp = ampdbfs(p5)
> a1  = moogladder(
>         (vco2(0.5,ipch) + vco2(0.5, ipch - 0.02) + vco2(0.5, ipch + .017)),
>         2000, 0.2)
> 
> /*idur_adjust = (ipch - 20)  ((ipch - 20) / 10000)*/
> idur_adjust = pow(0.05, min:i((ipch - 20), 3000)/3000)
> 
> 
> print ipch
> print idur_adjust
> 
> aenv = piano_env(0.02, iamp, 8.0 * idur_adjust, 0.3 * idur_adjust)
> aout = a1 * aenv * 0.333
> outs aout, aout
> endin
> 
> 
> 
> 
> 
> 
> ;; decay time should be frequency dependent
> i2 0.0 8.0 7.00 -12
> i2 0.0 .   8.00 .
> i2 0.0 .   9.00 .
> i2 0.0 .   10.00 .
> 
> s
> ;; rate should be same even if starting from lower amplitude
> ;; so lower amp = shorter duration of decay time
> i2 0.0 2.0 7.00 -12
> i2 1.0 .   7.00 -14
> i2 2.0 .   7.00 -16
> i2 3.0 .   7.00 -18
> 
> 
> s
> i2 0.0 2.0 7.00 -12
> i2 0.5 1.5 8.00 -12
> i2 1.0 1.0 8.07 -12
> i2 1.5 0.5 9.00 -12
> 
> 
> i2 2.0 6.0 7.00 -12
> i2 2.5 6.5 8.00 -12
> i2 3.0 5.0 8.07 -12
> i2 3.5 5.5 9.00 -12
> 
> 
> e
> 
> 
> 


------------------------------------------------------------------------------
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

Thanks! This should be useful for the kind of sounds I make.

Best,
Mike

Wow! Thank you!

On Sun, Jun 7, 2015 at 9:49 PM, Steven Yi  wrote:
> Following up, I wrote a UDO called piano_env that takes in an attack
> time, amplitude to go up to, then decay time and release time.  The
> decay and release time give times for 1.0 to reach 0.0001 over given
> time.  Those rates will be respected if you start at a smaller
> amplitude such that the rate is constant.
>
> In the instrument (instr 2) is the adjustment for decay and release
> time dependent on frequency.  I'm using pow to give an exponential
> curve to the adjustment.  I sort of fussed with the range of
> frequency, so the curve is going from about 20-3000 hz.  The result is
> that lower notes will ring longer than higher notes given the same
> amplitude.
>
> The amplitude envelope sounds good to my ear, though you'll probably
> want to change out the synthesis method.
>
> The code is pasted below, and I've also attached a copy of the CSD.
>
> Hope others find this useful; any suggestions for improvement appreciated!
> steven
>
>
>
> 
> 
> /*-o test.wav -W*/
> 
>
> 
> sr      =       48000
> ksmps   =      64
> nchnls  =       2
> 0dbfs  =      1.0
>
> opcode piano_env, a, iiii
> iattack_time, iamp, idecay_time, irelease_time xin
>
> /*idecay_rate = exp(-1.0 / (idecay_time * sr))*/
> /*irelease_rate = exp(-1.0 / (irelease_time * sr))*/
> idecay_rate = pow(0.001, 1.0 / (idecay_time * sr))
> irelease_rate = pow(0.001, 1.0 / (irelease_time * sr))
>
> /*print idecay_time*/
> /*print idecay_rate*/
> /*print irelease_time*/
> /*print irelease_rate*/
>
> asig init 0
> kindx = 0
> klastval init 0
> kstate init 0 ; 0,1,2 - attack, decay, release
> kreleasing release
>
> ktotal_indx init 0
> iattack_samples = int(iattack_time * sr)
> iattack_incr = iamp / iattack_samples
>
> xtratim irelease_time
> /*printk2 kstate*/
> until (kindx >= ksmps) do
>   if(kreleasing == 1) then
>     asig[kindx] = klastval
>     klastval *= irelease_rate
>   elseif(kstate == 0) then
>     asig[kindx] = klastval
>     klastval += iattack_incr
>     ktotal_indx += 1
>     if(ktotal_indx >= iattack_samples) then
>       kstate = 1
>     endif
>   elseif(kstate == 1) then
>     asig[kindx] = klastval
>     klastval *= idecay_rate
>     if(klastval <= 0.0001) then
>       kstate = 2
>     endif
>   else
>     asig[kindx] = 0.0
>   endif
>   kindx += 1
> od
>
> xout asig
> endop
>
> instr 1
> ipch = cps2pch(p4, 12)
> a1  = moogladder(vco2(0.5,ipch), 4000, 0.2)
> aenv = transegr:a(0.0, 0.02, 0, 1.0,
>                 4.0, -2, 0.0,
>                 0.1, 0, 0.0)
> aout = a1 * aenv
> outs aout, aout
> endin
>
>
> instr 2
> ipch = cps2pch(p4, 12)
> iamp = ampdbfs(p5)
> a1  = moogladder(
>         (vco2(0.5,ipch) + vco2(0.5, ipch - 0.02) + vco2(0.5, ipch + .017)),
>         2000, 0.2)
>
> /*idur_adjust = (ipch - 20)  ((ipch - 20) / 10000)*/
> idur_adjust = pow(0.05, min:i((ipch - 20), 3000)/3000)
>
>
> print ipch
> print idur_adjust
>
> aenv = piano_env(0.02, iamp, 8.0 * idur_adjust, 0.3 * idur_adjust)
> aout = a1 * aenv * 0.333
> outs aout, aout
> endin
>
>
>
> 
> 
>
> ;; decay time should be frequency dependent
> i2 0.0 8.0 7.00 -12
> i2 0.0 .   8.00 .
> i2 0.0 .   9.00 .
> i2 0.0 .   10.00 .
>
> s
> ;; rate should be same even if starting from lower amplitude
> ;; so lower amp = shorter duration of decay time
> i2 0.0 2.0 7.00 -12
> i2 1.0 .   7.00 -14
> i2 2.0 .   7.00 -16
> i2 3.0 .   7.00 -18
>
>
> s
> i2 0.0 2.0 7.00 -12
> i2 0.5 1.5 8.00 -12
> i2 1.0 1.0 8.07 -12
> i2 1.5 0.5 9.00 -12
>
>
> i2 2.0 6.0 7.00 -12
> i2 2.5 6.5 8.00 -12
> i2 3.0 5.0 8.07 -12
> i2 3.5 5.5 9.00 -12
>
>
> e
> 
> 
>
> On Sun, Jun 7, 2015 at 7:04 PM, Steven Yi  wrote:
>> Hi Andy,
>>
>> I tried working on this a bit the other day but got not quite
>> satisfying results.  I tried again today with a basic start using
>> transegr:
>>
>> 
>> 
>> /*-o test.wav -W*/
>> 
>>
>> 
>> sr      =       48000
>> ksmps   =      64
>> nchnls  =       2
>> 0dbfs  =      1.0
>>
>> instr 1
>> ipch = cps2pch(p4, 12)
>> a1  = moogladder(vco2(0.5,ipch), 4000, 0.2)
>> aenv = transegr:a(0.0, 0.02, 0, 1.0,
>>                 4.0, -2, 0.0,
>>                 0.1, 0, 0.0)
>> aout = a1 * aenv
>> outs aout, aout
>> endin
>>
>> 
>> 
>> i1 0 3.0 7.00
>> i1 0 7.0 9.00
>> i1 0 2.0 8.05
>> e
>> 
>> 
>>
>> This does have a linear start, convex curve to 0 over 4.0 seconds, and
>> if p3 is less than 4.0, then the linear release segment kicks in.
>>
>> However, this doesn't take into account two things: the amplitude of
>> the note, nor the decay time of the string. I think that:
>>
>> 1. The decay *rate* should be the same no matter how loud you hit the
>> note.  If you hit the note at max volume, it should take longer to get
>> to 0.0 than if you hit the note at less than max.
>> 2. The max decay time should dependent on frequency.  Higher notes
>> decay more quickly than lower notes.
>>
>> With transegr, rate of decay is dependent upon the itype and the
>> duration of the segment.  However, in my own way of thinking, I want
>> really to define the rate of decay and release, and let duration be
>> worked out from there.  I'm trying out an idea now with a UDO and will
>> post that once that's done.
>>
>> steven
>>
>> On Sat, Jun 6, 2015 at 12:32 PM, andy fillebrown
>>  wrote:
>>> I'm using Cabbage synth plugins to output synth data to text files so
>>> they can be imported into a 3d modeling program and I'm at the point
>>> now where I need to get an accurate depiction of the volume envelope
>>> to match an existing piano synth. The attack and release are no
>>> problem because they're very short and can be modeled with a straight
>>> line, but the decay and lack of sustain make a typical ADSR envelope
>>> unusable. What's the best way to depict the long and logarithmic decay
>>> phase of a piano in Csound?
>>>
>>> ~ Andy Fillebrown
>>>
>>> ------------------------------------------------------------------------------
>>> _______________________________________________
>>> Csound-users mailing list
>>> Csound-users@lists.sourceforge.net
>>> https://lists.sourceforge.net/lists/listinfo/csound-users
>>> Send bugs reports to
>>>         https://github.com/csound/csound/issues
>>> Discussions of bugs and features can be posted here
>
> ------------------------------------------------------------------------------
>
> _______________________________________________
> Csound-users mailing list
> Csound-users@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/csound-users
> Send bugs reports to
>         https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here
>

------------------------------------------------------------------------------
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here

i think indeed it would be better for all if you report your install 
issues here.  mike has released many fixes thanks to these reports.  i 
installed most recent csound for windows for a friend's computer one 
week ago, and all went flawlessly, just carefully reading the install 
decisions.  when i launched csoundqt and tested Examples > Getting 
started > Basics > Hello World, it ran, but did not produce any sound, 
and did not terminate.  the reason was not in csound, but in csoundqt's 
default RT Audio configuration: "portaudio (blocking)" was selected; 
changing this to "portaudio (callback)" solved this issue.

best -
	joachim


Am 08.06.2015 um 09:48 schrieb Wolf Peuker:
> Hi Steven,
>
> do you think trying to port this to Csound5 makes any sense?
> ...on my Windows machine I downgraded after some installation issues
> with Csound6. Well, maybe they are gone now...
>
> Best,
> Wolf
>
> Am 08.06.2015 um 03:49 schrieb Steven Yi:
>> Following up, I wrote a UDO called piano_env that takes in an attack
>> time, amplitude to go up to, then decay time and release time.  The
>> decay and release time give times for 1.0 to reach 0.0001 over given
>> time.  Those rates will be respected if you start at a smaller
>> amplitude such that the rate is constant.
>>
>> In the instrument (instr 2) is the adjustment for decay and release
>> time dependent on frequency.  I'm using pow to give an exponential
>> curve to the adjustment.  I sort of fussed with the range of
>> frequency, so the curve is going from about 20-3000 hz.  The result is
>> that lower notes will ring longer than higher notes given the same
>> amplitude.
>>
>> The amplitude envelope sounds good to my ear, though you'll probably
>> want to change out the synthesis method.
>>
>> The code is pasted below, and I've also attached a copy of the CSD.
>>
>> Hope others find this useful; any suggestions for improvement appreciated!
>> steven
>>
>>
>>
>> 
>> 
>> /*-o test.wav -W*/
>> 
>>
>> 
>> sr      =       48000
>> ksmps   =      64
>> nchnls  =       2
>> 0dbfs  =      1.0
>>
>> opcode piano_env, a, iiii
>> iattack_time, iamp, idecay_time, irelease_time xin
>>
>> /*idecay_rate = exp(-1.0 / (idecay_time * sr))*/
>> /*irelease_rate = exp(-1.0 / (irelease_time * sr))*/
>> idecay_rate = pow(0.001, 1.0 / (idecay_time * sr))
>> irelease_rate = pow(0.001, 1.0 / (irelease_time * sr))
>>
>> /*print idecay_time*/
>> /*print idecay_rate*/
>> /*print irelease_time*/
>> /*print irelease_rate*/
>>
>> asig init 0
>> kindx = 0
>> klastval init 0
>> kstate init 0 ; 0,1,2 - attack, decay, release
>> kreleasing release
>>
>> ktotal_indx init 0
>> iattack_samples = int(iattack_time * sr)
>> iattack_incr = iamp / iattack_samples
>>
>> xtratim irelease_time
>> /*printk2 kstate*/
>> until (kindx >= ksmps) do
>>    if(kreleasing == 1) then
>>      asig[kindx] = klastval
>>      klastval *= irelease_rate
>>    elseif(kstate == 0) then
>>      asig[kindx] = klastval
>>      klastval += iattack_incr
>>      ktotal_indx += 1
>>      if(ktotal_indx >= iattack_samples) then
>>        kstate = 1
>>      endif
>>    elseif(kstate == 1) then
>>      asig[kindx] = klastval
>>      klastval *= idecay_rate
>>      if(klastval <= 0.0001) then
>>        kstate = 2
>>      endif
>>    else
>>      asig[kindx] = 0.0
>>    endif
>>    kindx += 1
>> od
>>
>> xout asig
>> endop
>>
>> instr 1
>> ipch = cps2pch(p4, 12)
>> a1  = moogladder(vco2(0.5,ipch), 4000, 0.2)
>> aenv = transegr:a(0.0, 0.02, 0, 1.0,
>>                  4.0, -2, 0.0,
>>                  0.1, 0, 0.0)
>> aout = a1 * aenv
>> outs aout, aout
>> endin
>>
>>
>> instr 2
>> ipch = cps2pch(p4, 12)
>> iamp = ampdbfs(p5)
>> a1  = moogladder(
>>          (vco2(0.5,ipch) + vco2(0.5, ipch - 0.02) + vco2(0.5, ipch + .017)),
>>          2000, 0.2)
>>
>> /*idur_adjust = (ipch - 20)  ((ipch - 20) / 10000)*/
>> idur_adjust = pow(0.05, min:i((ipch - 20), 3000)/3000)
>>
>>
>> print ipch
>> print idur_adjust
>>
>> aenv = piano_env(0.02, iamp, 8.0 * idur_adjust, 0.3 * idur_adjust)
>> aout = a1 * aenv * 0.333
>> outs aout, aout
>> endin
>>
>>
>>
>> 
>> 
>>
>> ;; decay time should be frequency dependent
>> i2 0.0 8.0 7.00 -12
>> i2 0.0 .   8.00 .
>> i2 0.0 .   9.00 .
>> i2 0.0 .   10.00 .
>>
>> s
>> ;; rate should be same even if starting from lower amplitude
>> ;; so lower amp = shorter duration of decay time
>> i2 0.0 2.0 7.00 -12
>> i2 1.0 .   7.00 -14
>> i2 2.0 .   7.00 -16
>> i2 3.0 .   7.00 -18
>>
>>
>> s
>> i2 0.0 2.0 7.00 -12
>> i2 0.5 1.5 8.00 -12
>> i2 1.0 1.0 8.07 -12
>> i2 1.5 0.5 9.00 -12
>>
>>
>> i2 2.0 6.0 7.00 -12
>> i2 2.5 6.5 8.00 -12
>> i2 3.0 5.0 8.07 -12
>> i2 3.5 5.5 9.00 -12
>>
>>
>> e
>> 
>> 
>>
>
>
> ------------------------------------------------------------------------------
> _______________________________________________
> Csound-users mailing list
> Csound-users@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/csound-users
> Send bugs reports to
>          https://github.com/csound/csound/issues
> Discussions of bugs and features can be posted here
>

------------------------------------------------------------------------------
_______________________________________________
Csound-users mailing list
Csound-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/csound-users
Send bugs reports to
        https://github.com/csound/csound/issues
Discussions of bugs and features can be posted here