Jump to content
IGNORED

Learning DSP for music making purposes


zlemflolia

Recommended Posts

Is there any value in learning audio related DSP in and out for the purposes of making music in the end?  Or will you end up being the equivalent of one of those guys who spends $50k on modular synths then just plays around with them and makes nothing pleasant to listen to?

 

I have a CS background and have been getting into Max/MSP quite a bit, really loving it to bits it's so intuitive and easy to make whatever synth you want, modulate and envelope any parameter, it's just amazing, it's limitless unlike hardware synths I've bought.  Now I've been reading up on basic DSP stuff, filter implementation like biquads, fft, shit like that, wanting to get into writing externals to implement these filters and whatnot in C and creating my own replacements for some of the supposedly low quality objects that come with Max/MSP instead of using gen

 

Is this a rabbit hole with no reward at the end?  Has anyone else gone down this path despite not being able to make any good sounding music with already existing tools, and ended up having it help them?  

 

I just want to create my own workflow since I don't like any others.  Is this a waste of time?

Link to comment
Share on other sites

I have nothing of value to say here. But I misread the thread title not once but twice, as learning DP for music making purposes.

 

Thanks for your inadvertent contribution to my childish laugh. :datboi: 

Link to comment
Share on other sites

yes imo. Learning is always good... it's up to you what comes out of it...?

The cool thing is, you can turn DSP and programming skills into a profession. Maybe you get sidetracked and in the end be more interested in making instruments / effects rather than music - so what? Maybe it is more interesting. Maybe you can make some $$$ from software/hardware so you can then make more music...

Link to comment
Share on other sites

Learning about filters could definitely help making music - I learned some stuff when I was using Sync Modular a lot, and when you hear the difference between for example the Moog filter someone made in there and others, and see how they are implemented, if nothing else, it gives you more of an understanding of how to use filters - which in turn could help you to find interesting sounds

 

That's just one aspect of course - when you start taking apart effects and adjusting them to your own liking, you see how limited they are made to be and how many possibilities there are - a simple example might be linking a compressor envelope to a flange delay time. You can get cool sounds by modulating a delay with filtered noise as another example.

 

Does this count as DSP?

Link to comment
Share on other sites

when you start taking apart effects and adjusting them to your own liking, you see how limited they are made to be and how many possibilities there are

That's what I was hoping, I guess this is really the question I didn't realize I wanted to ask.  Thanks for answering it for me.  

Link to comment
Share on other sites

modulated delay lines are the basis behind so many effects like chorus, flange, vibrato. even filters technically use delay - just a single sample

 

Right - in Sync it has a z-1 module which is basically a 1 sample delay, which is the basis of the filters - just feeding back the previous sample to varying degrees is the simplest LP filter

Link to comment
Share on other sites

It depends on how much free time you have. If you regularly have 30+ hours of free time, and you tend to spend most or all of it working on music, then it could very well be worth it. However if you have limited free time, then I'd say just stick to focusing on the core aspect of music making... namely composition.

It might be easier to think of it as a different  yet related hobby. Do you have time for another hobby?

Also if your time is limited and you want a ton of control, you should look at the additive synth Harmor. Once you figure out how to use it... it's very easy to make complex pads/sounds and novel sounds since you can turn any audio sample into a patch.

This all matters if your end game is composition. You may like building synths MORE than making music.

Link to comment
Share on other sites

It's a rabbit hole

 

Is there any value in learning audio related DSP in and out for the purposes of making music in the end?  Or will you end up being the equivalent of one of those guys who spends $50k on modular synths then just plays around with them and makes nothing pleasant to listen to?

 

I have a CS background and have been getting into Max/MSP quite a bit, really loving it to bits it's so intuitive and easy to make whatever synth you want, modulate and envelope any parameter, it's just amazing, it's limitless unlike hardware synths I've bought.  Now I've been reading up on basic DSP stuff, filter implementation like biquads, fft, shit like that, wanting to get into writing externals to implement these filters and whatnot in C and creating my own replacements for some of the supposedly low quality objects that come with Max/MSP instead of using gen

 

Is this a rabbit hole with no reward at the end?  Has anyone else gone down this path despite not being able to make any good sounding music with already existing tools, and ended up having it help them?  

 

I just want to create my own workflow since I don't like any others.  Is this a waste of time?

 

Having gone down this path myself, it is definitely a rabbit hole.

 

You may not be going for MATLAB levels of education but I feel that it is important to have some understanding of the drawbacks and strengths of DSP and learning how to come up with solutions as you design and implement ideas. I find it a lot easier to implement equations from textbooks into transform functions and oversampling filters with Max, but it doesn't make my stuff sound clearer or thicker as a result. I also supplement Max with Renoise as a global sequencer because Max's transport sequencer is surprisingly not that good on its own. It is not a means to an end though because at the end of the day it is not going to make you a better musician or composer, so if you are wanting to improve production skills its not the program to do that.

 

Was it worth it? Absolutely

Link to comment
Share on other sites

I don't think it can hurt if you like working that way.

 

But I also have a friend who has been working on one Max For Live patch for 4 years and isn't done yet, so yes it can also be a rabbit hole if you let it, just like anything else if the tools become the focus.  At which point, you can jut become a tool maker instead, which is cool too.

Link to comment
Share on other sites

jesus christ, a max patch that takes 4 years to make?!

 

that end up being a daw? ...like ableton?

 

edit: zeffolia, just go for it! you never know what you'll find on the path or become. i hope i'll have more time in future for dsp, now i have zero time for it :(

Link to comment
Share on other sites

interesting job, lover ;)

i really like max but what i like about sc or any similar 'proper' :trollface:  programming langs is that you can easily control everything with anything in extreme scales. you can make an oscillator and just say let's multiply this osc with a million, define its own frequency or any other parameter that controls all of those other oscs or to disperse parameters over those million oscillators and all that in a few lines of code. 

Link to comment
Share on other sites

My god, supercollider.. Powerful in terms of sound, but that language comes across as really inelegant and unfriendly.

 

Thinking of messing around a little with JUCE. The fact that you code directly in C++ is a huge plus (no pun intended); and a generated GUI with not so much wire-pulling.

Link to comment
Share on other sites

My god, supercollider.. Powerful in terms of sound, but that language comes across as really inelegant and unfriendly.

 

 

i wouldn't know; it's my first language. i had plans to start with python first and to first learn about cs in general but i couldn't find time for it. maybe i should go straight to structure and interpretation of computer programs book or knuth's art of computer programming...  :cat:

Link to comment
Share on other sites

Nice one. Don't get me wrong, if you enjoy using SC, that's awesome.

 

If you take a look at this presentation segment by Stroustrup (starting at 19:10) where he talks about "type-rich, meaningful interfaces", this is exactly what I think SC is doing badly. Didn't want to bloat the thread with coding examples, but let me know if you wanted me to elaborate.

Link to comment
Share on other sites

Nice one. Don't get me wrong, if you enjoy using SC, that's awesome.

 

If you take a look at

(starting at 19:10) where he talks about "type-rich, meaningful interfaces", this is exactly what I think SC is doing badly. Didn't want to bloat the thread with coding examples, but let me know if you wanted me to elaborate.

Please do bloat the thread with coding examples

 

I agree with Stroustrup in this video for sure on using the type system to enforce semantic correctness at compile time.  That being said, it's really easy to over-specify and make interfaces which are cumbersome to use due to the API having way too many types which are abstracted far away from the language's standard library.  Nothing I hate more than having to convert an object through 3 helper methods and the constructor for some weird library specific type to do simple stuff like set a goddamn text field from a std::string instead of an API::Bojangle::Bungle::ShitlickInterfaceAbstractHelperBaseFactoryImpl::typeSpec::genericCharacterArray<container_type::vector>

 

Well designed APIs are underrated when it comes to weird programming languages that don't follow typical OOP or procedural structure.  

 

For instance, in Max/MSP it's ridiculously easy to make shit too complex.  To have too many things interacting in too many weird ways, when in reality with hindsight it would be really easy to refactor that patch into a beautiful one with all sorts of submodules and reusable patches and have it be real pretty and easier to maintain/  But lots of people who only know languages like Max/MSP or other stuff idk, and don't have a "real" (so to speak, no offense) background in languages like C, C++ or even Java.  This affects performance and therefore sound quality of patches as well I'd assume, not realizing how expensive certain operations are

Link to comment
Share on other sites

Nice one. Don't get me wrong, if you enjoy using SC, that's awesome.

 

If you take a look at

(starting at 19:10) where he talks about "type-rich, meaningful interfaces", this is exactly what I think SC is doing badly. Didn't want to bloat the thread with coding examples, but let me know if you wanted me to elaborate.

 

Heh not so fast... i hate using sc but i like the results. I'd be the happiest man on planet if i could just use Reason or elektron's machines. :)

 

Regarding the presentation, sorry but i'm not that proficient in programming to understand everything but something i did + zeffolia's respond cleared it up for me a bit. but yes, pls elaborate.

imo things could alwasy be better, of course. it's easy for a programmer to play with sc or such but let's not forget about us, the little people, who knows shit about programming. how to make it easier for us...and to have deeper levels for initiated in depths of the art. todays max is great example how it can be done imo. i'd say it's the balance that matters the most. the first time i openned sc i didn't know what a function or variable was. what's an arrey?! :) i knew some max and i thought i knew what's an object...i mean :facepalm 

Link to comment
Share on other sites

For the rec, I'm not that knowledgeable in CS.

 

Good coding practice: "Declare a variable and initialise it immediately." [*] Here's a bad example, typical in Supercollider code

var mod_env, mod_freq, env_attack, env_sustain // etc etc
// 3 more lines with uninitialised vars

mod_env = EnvGen.ar(Env.perc(0.005, sustain), 1.0, doneAction: 2);
// does the same for the remaining 10 vars...

it can be written much better, by declaring and initialising on the same line:

var mod_env = EnvGen.ar(Env.perc(0.005, sustain), 1.0, doneAction: 2);
var mod_freq = /*..*/

This may be just a pedantic issue, but from what I gather, pretty much every SC code example follows the former coding style (then the SC users copy that style etc etc). If you take a look at https://github.com/supercollider/supercollider/blob/master/examples/demonstrations/DrumSynths.scd - in each of those SynthDefs, there's 3-4 unnecessary lines of var declarations. I would have written it like this:

(
SynthDef(\SOSkick, {
        arg out = 0, freq = 50, mod_freq = 5, mod_index = 5, sustain = 0.4, amp = 0.8, beater_noise_level = 0.025;

    var pitch_contour = Line.kr( freq * 2, freq, 0.02 );
    var drum_osc = PMOsc.ar( pitch_contour,    mod_freq, mod_index / 1.3, mul: 1, add: 0 );
    var drum_lpf = LPF.ar(in: drum_osc, freq: 1000, mul: 1, add: 0 );
    var drum_env = drum_lpf * EnvGen.ar(Env.perc(0.005, sustain), 1.0, doneAction: 2);
        
    var beater_source = WhiteNoise.ar(beater_noise_level);
    var beater_hpf = HPF.ar(in: beater_source, freq: 500, mul: 1, add: 0);
    var lpf_cutoff_contour = Line.kr(6000, 500, 0.03);
    var beater_lpf = LPF.ar(in: beater_hpf, freq: lpf_cutoff_contour, mul: 1, add: 0);
    var beater_env = beater_lpf * EnvGen.ar(Env.perc, 1.0, doneAction: 2);
    
    var kick_mix = Mix.new([drum_env, beater_env]) * 2 * amp;
        
    Out.ar(out, [kick_mix, kick_mix])
    }
    ).add
)
Synth(\SOSkick);

But a more realistic issue is (and I'll use the same coding example): what if I wanted to have the same bass drum osc, but use a different "beater"? Do I really need to copy/paste the entire synth, give it another name, and make the changes I need? LIke this?

(
SynthDef(\SOSkickWhite, {
// Bass drum with a white noise beater
        arg out = 0, freq = 50, mod_freq = 5, mod_index = 5, sustain = 0.4, amp = 0.8, beater_noise_level = 0.025;

    var pitch_contour = Line.kr( freq * 2, freq, 0.02 );
    var drum_osc = PMOsc.ar( pitch_contour,    mod_freq, mod_index / 1.3, mul: 1, add: 0 );
    var drum_lpf = LPF.ar(in: drum_osc, freq: 1000, mul: 1, add: 0 );
    var drum_env = drum_lpf * EnvGen.ar(Env.perc(0.005, sustain), 1.0, doneAction: 2);
        
    var beater_source = WhiteNoise.ar(beater_noise_level);
    var beater_hpf = HPF.ar(in: beater_source, freq: 500, mul: 1, add: 0);
    var lpf_cutoff_contour = Line.kr(6000, 500, 0.03);
    var beater_lpf = LPF.ar(in: beater_hpf, freq: lpf_cutoff_contour, mul: 1, add: 0);
    var beater_env = beater_lpf * EnvGen.ar(Env.perc, 1.0, doneAction: 2);
    
    var kick_mix = Mix.new([drum_env, beater_env]) * 2 * amp;
        
    Out.ar(out, [kick_mix, kick_mix])
    }
    ).add
)

(
SynthDef(\SOSkickPink, {
// Bass drum with a pink noise beater lol
        arg out = 0, freq = 50, mod_freq = 5, mod_index = 5, sustain = 0.4, amp = 0.8, beater_noise_level = 0.025;

    var pitch_contour = Line.kr( freq * 2, freq, 0.02 );
    var drum_osc = PMOsc.ar( pitch_contour,    mod_freq, mod_index / 1.3, mul: 1, add: 0 );
    var drum_lpf = LPF.ar(in: drum_osc, freq: 1000, mul: 1, add: 0 );
    var drum_env = drum_lpf * EnvGen.ar(Env.perc(0.005, sustain), 1.0, doneAction: 2);
        
    var beater_source = PinkNoise.ar(beater_noise_level); // <<--------------- PinkNoise
    var beater_hpf = HPF.ar(in: beater_source, freq: 500, mul: 1, add: 0);
    var lpf_cutoff_contour = Line.kr(6000, 500, 0.03);
    var beater_lpf = LPF.ar(in: beater_hpf, freq: lpf_cutoff_contour, mul: 1, add: 0);
    var beater_env = beater_lpf * EnvGen.ar(Env.perc, 1.0, doneAction: 2);
    
    var kick_mix = Mix.new([drum_env, beater_env]) * 2 * amp;
        
    Out.ar(out, [kick_mix, kick_mix])
    }
    ).add
)

Synth(\SOSkickWhite);
Synth(\SOSkickPink);

I don't know, is this the only way? If so, that's a lot of duplicate code, that will become hard to manage after a while. Is there not a way to create a separate Beater object and pass it to my bass drum synth? Then I could switch beaters in real time (like a drummer would).

 

That's all for now, will post a couple more a bit later x

 

[*] https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines.html

Link to comment
Share on other sites

But a more realistic issue is (and I'll use the same coding example): what if I wanted to have the same bass drum osc, but use a different "beater"? Do I really need to copy/paste the entire synth, give it another name, and make the changes I need? LIke this?(

SynthDef(\SOSkick, {
// Bass drum with a white noise beater
        arg out = 0, freq = 50, mod_freq = 5, mod_index = 5, sustain = 0.4, amp = 0.8, beater_noise_level = 0.025, beater_choice = 0;

    var pitch_contour = Line.kr( freq * 2, freq, 0.02 );
    var drum_osc = PMOsc.ar( pitch_contour,    mod_freq, mod_index / 1.3, mul: 1, add: 0 );
    var drum_lpf = LPF.ar(in: drum_osc, freq: 1000, mul: 1, add: 0 );
    var drum_env = drum_lpf * EnvGen.ar(Env.perc(0.005, sustain), 1.0, doneAction: 2);
     
    var beater_source = Select.ar(beater_choice,[WhiteNoise.ar(beater_noise_level), PinkNoise.ar(beater_noise_level)]);
    var beater_hpf = HPF.ar(in: beater_source, freq: 500, mul: 1, add: 0);
    var lpf_cutoff_contour = Line.kr(6000, 500, 0.03);
    var beater_lpf = LPF.ar(in: beater_hpf, freq: lpf_cutoff_contour, mul: 1, add: 0);
    var beater_env = beater_lpf * EnvGen.ar(Env.perc, 1.0, doneAction: 2);
    
    var kick_mix = Mix.new([drum_env, beater_env]) * 2 * amp;
        
    Out.ar(out, [kick_mix, kick_mix])
    }
    ).add
)

Synth(\SOSkick,[\beater_choice, 0]);
Synth(\SOSkick,[\beater_choice, 1]);

I'm still pretty new to SC, but you could do something like this using Select.ar. 

Link to comment
Share on other sites

Is this a rabbit hole with no reward at the end?  Has anyone else gone down this path despite not being able to make any good sounding music with already existing tools, and ended up having it help them?  

 

I just want to create my own workflow since I don't like any others.  Is this a waste of time?

 

To respond to the OP - if you're having trouble making good sounding music with all the existing tools we have available nowadays, it seems like learning DSP wouldn't help much. But like others have said, it kind of depends on what kind of stuff you're making and what you're end goal is. 

 

For me, I've been playing with Supercollider but keep it pretty seperate from my "actual" music making... I'm just playing around basically. I don't really mind if it's a rabbit hole if I'm having fun and learning things since music is a just a hobby for me anyway. 

Link to comment
Share on other sites

Archived

This topic is now archived and is closed to further replies.

  • Recently Browsing   0 members

    • No registered users viewing this page.
×
×
  • Create New...

Important Information

We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.