Add fadeout

[mathstuf]

No description provided.

[mathstuf]

Updated. Now pins volume to 0. when the fadeout time has expired.

[OvermindDL1]

A fadeout seems exceptionally situation specific rather then generic.

Why not instead have something that just does standard audio envelope manipulation? I.E. it would be defined with an attack, a decay, a sustain, and a release in that order. When applied to a known-length source the attack adjust the beginning of it, trivial to do a fade-in (as well as more complex things), the decay then is the transition from the end of the attack to the sustain, the sustain is then the 'settled on' volume or other adjustments (this should work on a lot more than just volume depending on the callback passed in of course), then the release can either be done right before it ends, or potentially right after (to extend it, which is more traditional but both are often supported).

Fade-out and fade-in would both be trivially and efficiently built on that without requiring a specialized multitude of structs for each and every potential sound manipulation that could be done via normal audio envelope's. For example, a fade-out would just be a release (or some step before it, prerelease perhaps? would only work on sources with known lengths though all the others would work on sources with unknown lengths) with the rest set to 0 times and no-ops as is traditional. The code would execute just as efficiently and it would give significant power. You can then define fadein/fadeout functions on sinks as wrappers to the envelope (as well as a full envelope function, as well as other common envelope effects).

[mathstuf]

That seems beyond my knowledge of audio manipulation (in that I know what those words mean in general, but not in this context). As long as a method for fading out that takes a Duration exists (possibly with some Ramp::Linear argument for a little bit more fanciness, but even that seems a bit much for something that many other audio libraries also just have a simple duration parameter for), I'm OK with it. To that end, when such an API does exist, the implementation of this method can then call that API. But, I don't think it's something I would feel confident implementing at this time.

If you really want to go far, something built on splines seems possible as well and isn't restricted to a trapezoid shape (just going on my intuition here).

[OvermindDL1]

@mathstuf Actually it's all really simple things, much more so then most people think. I'd recommend going through this audio tutorial when you get a half hour or hour or so, it's all in-browser but teaches what they are and how they work. The envelope section is directly related here but adding all the traditional audio effects would be very useful: https://learningsynths.ableton.com/

Envelopes aren't fancy enough to use splines either (though it would make for more capabilities). ^.^

[mathstuf]

Finally got some time to go back and look at this :) . So looking at that, I think that's slightly different. Are you suggesting to have a source which applies some envelope to another source? That seems a bit different here where we don't know how long sustain is since the fadeout portion is triggered by an external event. I think another envelope source modifier makes sense (maybe this can then be rebased on top of that, but without linear types enforcing the attack to decay to sustain to release flow, the API feels like its going to be unweildy.

I also have no use case for such features, so I don't want to sink more time into it.

[dyc3]

I can clearly see the advantage of having an envelope based source, but I think it should be a separate source. The fade in/out sources should stay because they are easy to use (if anything, refactored to work on top of the envelope source).

Any chance we can get this merged in? I have a project that needs this feature badly.

[mathstuf]

My main use case is to fade out a looping piece of music at the end of a level. I suppose you could compute the length of the audio doing something like:

if let Some(duration) = source.total_duration() {
    let source = source.fadeout(fade_out_duration);
    source.periodic_access(duration - fade_out_duration, |s| s.start())
} else {
    // Probably Box<Source> to align with the above.
}