Mixing with Airwindows Console post-fader in Waveform

[unholyeyebrows]

Hi all

Posting this here in case it helps anyone in relation to setting-up a DAW-based mixing template using Airwindows Console plugins. The reason for this is the Airwindows Console plugins benefit greatly when run in a DAW where you can insert them post-fader. You can do this with ease in Waveform and so in case anyone is looking for a DAW in which to mix using Airwindows Console in particular, then Waveform is a good choice.

I'm a fan of the plugins made by Chris at Airwindows (airwindows.com) and in particular the Console set of plugins. My understanding of how Airwindows Console works is that it enhances the way audio is mixed in your DAW via distortion and un-distortion when the tracks are summed together digitally. The result is a more 'analogue-like' mix, similar to how Harrison Mixbus provides their Harrison and SSL console sound.

An example signal path for Airwindows console in Waveform is as follows:

Imagine we have 3 synths each on their own channel. Set-up each channel as follows::
1. Audio -> Plugin inserts -> Fader -> Meter -> AIRWINDOWS CONSOLE CHANNEL
2. Audio -> Plugin inserts -> Fader -> Meter -> AIRWINDOWS CONSOLE CHANNEL
3. Audio -> Plugin inserts -> Fader -> Meter -> AIRWINDOWS CONSOLE CHANNEL

Place these all in a submix folder set-up as follows:
Output from channels -> AIRWINDOWS CONSOLE BUSS -> Plugin inserts -> AIRWINDOWS CONSOLE CHANNEL

Finally imagine you have multiple submixes routing to the master, then the master set-up is as follows:

Output from submixes-> AIRWINDOWS CONSOLE BUSS -> Plugin inserts -> Audio device

The key is that the output from the Airwindows Console plugins (which distort the signal) arrives untouched into the Airwindows Buss plugins (which un-distort the mixed sound). This is also why you need another pair of Channel and Buss plugins when combining submixes into the master.

By placing the Airwindows Console plugin after the Fader and Meter in Waveform's signal path, you can adjust the volume of each track or bus without disturbing the unity gain between the Airwindows Console and Buss plugins. In other DAWs which do not support post-fader plugins, you cannot mix using the DAW's faders and instead have to use the fader built-in to the Airwindows Console plugin, which is not as neat as using the actual mixer in this case.

Attached is a screenshot for an example with 5 submixes, each with 2 channels, and a couple of effects sends also using the Airwindows Console & Bus plugins.

I hope this is helpful for anyone curious about these plugins, and more importantly, I hope I've not made any major mistakes here with my description!

Thanks

[EDIT] Also set your project audio rate to 96Khz or above to get the best out of the Airwindows Console plugins.

[Maarid]

I have tested it, I will leave my feedback.
First of all, it is very confusing that after inserting the console and bus, the signal volume changes dramatically, creating a sense of duality in evaluating the effectiveness of the plug-ins used, but when you fully assemble all submix to the master output, questions disappear.
In my opinion, the simplification of the mixing and the way of the final sound filled me with the sound received in Magix programs, only in this case on steroids, given the capabilities of Waveform. And the way to differentiate several buses by collecting several submix, I was reminded of the masterconsole send in Orion from Synapse.
To be honest, I could only dream of such a bundle. Now, instead of 20 Equalizers, I use 5\6 and do not feel any losses in the process.
My score is 8 out of 10, the volume jumps make it difficult to understand what is happening, this is a fat minus in the work.

I will add from myself - onlyclip is an incredibly convenient, simple and effective thing, the rest, what I saw in the package (while sorting and putting in order), is very similar to a large set of parts from which you can assemble almost any commercial plugin using rack =), you will need to experiment, I have a lot of monsters that I I use it for the sake of one function and a couple of monsters that do not support oversampling, we will watch.
Thank you very much, I've downloaded this package before, but I didn't know where to start, you gave me an entrance ticket.

[fde101]

similar to how Harrison Mixbus provides their Harrison and SSL console sound.

Studio One Pro and UA LUNA both have special types of plugins which integrate a similar capability into their mixers (Studio One calls this "Mix FX" for example); it would be nice if perhaps the CLAP team would standardize a "summing plugin" variety that other DAWs could adopt to provide this option.

[Maarid]

It's been half a year since I fell in love with console 9, and I've been struggling for a long time trying to figure out how the cmajor language works, which is natively embedded directly into our favorite waveform. And after a long assault on all available AI, I can say I figured out how it works.
In my not very skillful opinion, I managed to make console 9 in the cmajor language.

Code: Select all

processor ConsoleGoldChannel
{
	input stream float In1, In2;
	output stream float Out1, Out2;

	std::random::RNG rng; ///Standart Library Random

	/// generating a huge integer for dithering
	int rd1 = int32 ( ( ( 1 + rng.getInt32() ) * 4294967295_L ) & 0xFFFFFFFFi64 ); 
	int rd2 = int32 ( ( ( 1 + rng.getInt32() ) * 4294967295_L ) & 0xFFFFFFFFi64 );

	int BS ( int b ) ///Bit Shuffle
	{
		int64 s = b;
		s = ( s ^ (s << 13 ) ) & 0xFFFFFFFFi64; 
		s = ( s ^ (s >> 17 ) ) & 0xFFFFFFFFi64;
		s = ( s ^ (s << 5 ) ) & 0xFFFFFFFFi64;
		return int32 ( s );
	}
	
	float Gold( float x, int z ) /// Calculations for all channel
	{ 
		float64 g = x;
		if ( abs ( g ) < 1.18e-23 ) g = z * 1.18e-17;

		g *= 0.3338505354221896; /// Gain & Pan Controls

		if ( g > 1.0 ) g = 1.0;  /// Сoding of each channel by the golden ratio
		else if ( g > 0.0 )
			g = - ( exp (  log ( 1.0 - g ) * 1.6180339887498949 ) - 1.0 );
		if ( g < - 1.0 ) g = - 1.0;
		else if ( g < 0.0 )
			g = exp ( log ( 1.0 + g ) * 1.6180339887498949 ) - 1.0;

		/// Dithering for 32bit
		int ex = ( int32 ( ( reinterpretFloatToInt ( float32( g ) ) >> 23 ) ) & 0xFF ) - 127;
		z = BS ( z );
		g += ( ( float64 ( z ) - 0x7fffffff ) * 5.5e-36 * pow ( 2.0 , ex + 62.0 ) );

		return float32 ( g );
	}
	
	void init()
    {
        rng.seed ( 401L + processor.id );
    }

	void main()
	{	
		loop 
		{	
			///we process and return the value of each channel in order
			Out1 <- Gold ( In1, rd1 ); 
			Out2 <- Gold ( In2, rd2 );

			/// Bit Shuffle for channel's
			rd1 = BS ( rd1 );
			rd2 = BS ( rd2 );
			
			advance();
		}				
	}	
}

Code: Select all

processor ConsoleGoldBuss
{
	input stream float In1, In2;
	output stream float Out1, Out2;

	std::random::RNG rng; ///Standart Library Random

	/// generating a huge integer for dithering
	int rd1 = int32 ( ( ( 1 + rng.getInt32() ) * 4294967295_L ) & 0xFFFFFFFFi64 ); 
	int rd2 = int32 ( ( ( 1 + rng.getInt32() ) * 4294967295_L ) & 0xFFFFFFFFi64 );

	int BS ( int b ) ///Bit Shuffle
	{
		int64 s = b;
		s = ( s ^ (s << 13 ) ) & 0xFFFFFFFFi64; 
		s = ( s ^ (s >> 17 ) ) & 0xFFFFFFFFi64;
		s = ( s ^ (s << 5 ) ) & 0xFFFFFFFFi64;
		return int32 ( s );
	}
	
	float Gold( float x, int z ) /// Calculations for all channel
	{ 
		float64 g = x;
		if ( abs ( g ) < 1.18e-23 ) g = z * 1.18e-17;

		if ( g > 1.0 ) g = 1.0;  /// Сoding of each channel by the golden ratio
		else if ( g > 0.0 )
			g = - ( exp (  log ( 1.0 - g ) * 0.6180339887498949 ) - 1.0 );
		if ( g < - 1.0 ) g = - 1.0;
		else if ( g < 0.0 )
			g = exp ( log ( 1.0 + g ) * 0.6180339887498949 ) - 1.0;
		
		g *= 1.414213562373095; /// Gain & Pan Controls

		/// Dithering for 32bit
		int ex = ( int32 ( ( reinterpretFloatToInt ( float32 ( g ) ) >> 23 ) ) & 0xFF ) - 127;
		z = BS ( z );
		g += ( ( float64 ( z ) - 0x7fffffff ) * 5.5e-36 * pow ( 2.0 , ex + 62.0 ) );

		return float32 ( g );
	}
	
	void init()
    {
        rng.seed ( 402L + processor.id );
    }

	void main()
	{	
		loop 
		{	
			///we process and return the value of each channel in order
			Out1 <- Gold ( In1, rd1 ); 
			Out2 <- Gold ( In2, rd2 );

			/// Bit Shuffle for channel's
			rd1 = BS ( rd1 );
			rd2 = BS ( rd2 );
			
			advance();
		}				
	}	
}

I have uploaded the finished files to githab, from where they will always be available to you. If you're interested. Since I was able to barely understand how the plugin works, I have some ideas for deviating from authenticity...
https://github.com/EkimmuMaarid/Cmajor- ... Airwindows

[unholyeyebrows]

Hey thanks Maarid. Sounds like you’ve been busy! What are the main advantages of using the cmajor plugins in Waveform compared to using the standard Airwindows plugins?

Thanks
Nick.

[Maarid]

What are the main advantages of using the cmajor plugins in Waveform compared to using the standard Airwindows plugins?

First of all, the ability to edit the source code in real time, the .cmajor file is a simple text file that you can edit right while working inside waveform. Next, I wrote the original code so that you could easily edit the number of audio channels. By default, the original supports exclusively only the stereo signal, thanks to the panorama control, this has not been changed, I have eliminated all controls, now it is possible to use a console plug-in with five, seven or as many audio inputs and outputs as you like. For example, the code for 8 audio channels will look like this:

Code: Select all

processor ConsoleGoldChannel
{
	input stream float In1, In2, In3, In4, In5, In6, In7, In8;
	output stream float Out1, Out2, Out3, Out4, Out5, Out6, Out7, Out8;

	std::random::RNG rng; ///Standart Library Random

	/// generating a huge integer for dithering
	int rd1 = int32 ( ( ( 1 + rng.getInt32() ) * 4294967295_L ) & 0xFFFFFFFFi64 ); 
	int rd2 = int32 ( ( ( 1 + rng.getInt32() ) * 4294967295_L ) & 0xFFFFFFFFi64 );
	int rd3 = int32 ( ( ( 1 + rng.getInt32() ) * 4294967295_L ) & 0xFFFFFFFFi64 ); 
	int rd4 = int32 ( ( ( 1 + rng.getInt32() ) * 4294967295_L ) & 0xFFFFFFFFi64 );
	int rd5 = int32 ( ( ( 1 + rng.getInt32() ) * 4294967295_L ) & 0xFFFFFFFFi64 ); 
	int rd6 = int32 ( ( ( 1 + rng.getInt32() ) * 4294967295_L ) & 0xFFFFFFFFi64 );
	int rd7 = int32 ( ( ( 1 + rng.getInt32() ) * 4294967295_L ) & 0xFFFFFFFFi64 ); 
	int rd8 = int32 ( ( ( 1 + rng.getInt32() ) * 4294967295_L ) & 0xFFFFFFFFi64 );

	int BS ( int b ) ///Bit Shuffle
	{
		int64 s = b;
		s = ( s ^ (s << 13 ) ) & 0xFFFFFFFFi64; 
		s = ( s ^ (s >> 17 ) ) & 0xFFFFFFFFi64;
		s = ( s ^ (s << 5 ) ) & 0xFFFFFFFFi64;
		return int32 ( s );
	}
	
	float Gold( float x, int z ) /// Calculations for all channel
	{ 
		float64 g = x;
		if ( abs ( g ) < 1.18e-23 ) g = z * 1.18e-17;

		g *= 0.3338505354221896; /// Gain & Pan Controls

		if ( g > 1.0 ) g = 1.0;  /// Сoding of each channel by the golden ratio
		else if ( g > 0.0 )
			g = - ( exp (  log ( 1.0 - g ) * 1.6180339887498949 ) - 1.0 );
		if ( g < - 1.0 ) g = - 1.0;
		else if ( g < 0.0 )
			g = exp ( log ( 1.0 + g ) * 1.6180339887498949 ) - 1.0;

		/// Dithering for 32bit
		int ex = ( int32 ( ( reinterpretFloatToInt ( float32( g ) ) >> 23 ) ) & 0xFF ) - 127;
		z = BS ( z );
		g += ( ( float64 ( z ) - 0x7fffffff ) * 5.5e-36 * pow ( 2.0 , ex + 62.0 ) );

		return float32 ( g );
	}
	
	void init()
    {
        rng.seed ( 401L + processor.id );
    }

	void main()
	{	
		loop 
		{	
			///we process and return the value of each channel in order
			Out1 <- Gold ( In1, rd1 ); 
			Out2 <- Gold ( In2, rd2 );
			Out3 <- Gold ( In3, rd3 ); 
			Out4 <- Gold ( In4, rd4 );
			Out5 <- Gold ( In5, rd5 ); 
			Out6 <- Gold ( In6, rd6 );
			Out7 <- Gold ( In7, rd7 ); 
			Out8 <- Gold ( In8, rd8 );

			/// Bit Shuffle for channel's
			rd1 = BS ( rd1 );
			rd2 = BS ( rd2 );
			rd3 = BS ( rd3 );
			rd4 = BS ( rd4 );
			rd5 = BS ( rd5 );
			rd6 = BS ( rd6 );
			rd7 = BS ( rd7 );
			rd8 = BS ( rd8 );
			
			advance();
		}				
	}	
}

Pretty simple, isn't it?

[Maarid]

And yes, by the way, thanks to the fact that I was able to understand the original code, I learned the main feature of the console from airwindow. The process of working directly with mixing should be tried to be carried out within the average volume limits. The fact is that the presence of dithering depends directly on the exponent of the signal itself, as intended in the original, the louder the signal, the more dithering there will be in it, for cleaner work, try to lower the volume of each track before mixing and stay within the range of average volume values, if you, for example, press the bass or drums on the track with a clipper. reduce the output signal on the clipper to at least a third, so the sound will be much cleaner, as required in the original

[pough]

Hey, cmajor plugins are working in Waveform now. I wonder when that happened.

[imstre]

What folder do I need to upload the files to in order to use it?
Thanks

[Maarid]

What folder do I need to upload the files to in order to use it?

By default, in the waveform settings, the Cmajor folder is automatically checked for cmajor plugins, which should be located next to the VST3\LV2\AU folders in

Code: Select all

C:\Program Files\Common Files

, if the folder is missing (which is most likely initially), manually create a Cmajor folder and place plugins in it to automatically detect the presence or modification of new plugins.. To confirm changes to the source code, it is enough that the location itself does not change and the content will be updated and picked up automatically right during the operation of the daw itself.
The installation process and the method of use completely repeats the process of using VST3, if you have experience with manual installation of plugins, you can always figure it out for yourself.
By the way, just like vst3, cmajor is fully stable inside waveform and allows you to simply drag the plugin folder from any folder in the system to the plug-in page inside the daw and it registers freely.
The only stability error I received from cmajor was when I edited the code parameters and constantly resaved the plugin file opened inside the daw at that moment, about half an hour of such violence led to the crash of the plugin.

I have a rather different question, are there windows users who use LV2 plugins, I can't figure out, after restarting waveform, all lv2 plugins become automatically lost, although they are in their places, I haven't figured out how to use them, or are these glitches of the daw itself? I'm just really interested.

[Maarid]

optimize the airwindows Console 9 code for real-time. Controls and dithering have been eliminated, all calculations have been reduced to 32-bit values, and volume compensation has been calculated to change the golden ratio formula, thereby turning the accuracy of the golden formula into a medical gold formula. The speed of execution is now likely to be promising, and the absence of any background noise will allow you to fully focus on the main thing - the sound of your project. The sound no longer jumps when using plug-ins, the console does not make any noise at all, feel the surgeon's scalpel in your hands

Code: Select all

processor ConsoleAurupureBuss
{
	input stream float In1, In2;
	output stream float Out1, Out2;
	
	float Aurupure( float g ) /// Сoding of each channel by the golden ratio
	{ 

		if ( g > 1.0f ) g = 1.0f;
		else if ( g > 0.0f )
		{
			g = - ( exp (  log ( 1.0f - g ) * 0.61803399f ) - 1.0f );
			g *= 1.5782f;
		}

		if ( g < - 1.0f ) g = - 1.0f;
		else if ( g < 0.0f )
		{
			g = exp ( log ( 1.0f + g ) * 0.61803399f ) - 1.0f;
			g *= 1.5782f;
		}
			
		return  g;
	}

	void main()
	{	
		loop 
		{	
			///we process and return the value of each channel in order
			Out1 <- Aurupure ( In1 ); 
			Out2 <- Aurupure ( In2 );
			
			advance();
		}				
	}	
}

Code: Select all

processor ConsoleAurupureChannel
{
	input stream float In1, In2;
	output stream float Out1, Out2;
	
	float Aurupure( float g ) /// Сoding of each channel by the golden ratio
	{  
		if ( g > 1.0f ) g = 1.0f;  
		else if ( g > 0.0f )
		{
			g *= 0.63333333f;
			g = - ( exp (  log ( 1.0f - g ) * 1.61803399f ) - 1.0f );
		}
			
		if ( g < - 1.0f ) g = - 1.0f;
		else if ( g < 0.0f )
		{
			g *= 0.63333333f;
			g = exp ( log ( 1.0f + g ) * 1.61803399f ) - 1.0f;
		}
			
		return g;
	}

	void main()
	{	
		loop 
		{	
			///we process and return the value of each channel in order
			Out1 <- Aurupure ( In1 ); 
			Out2 <- Aurupure ( In2 );
			
			advance();
		}				
	}	
}

https://github.com/EkimmuMaarid/Cmajor-AuruPure-Console

[Maarid]

I made a project of a complex mixing console for myself, creative tasks, learning the cmajor language and of course the best challenge for myself.
Soviet-style mixing consoles, at the end of the 20th century, were famous for their ultra-low quality in terms of component base and durability, Quite famous among nerds of their time, they were redesigned countless times by the same nerds, replaced and modified components with varying degrees and the ability to overcome their inherent artifacts and glitches.
But, strangely enough, to this day there are serious arguments about that Soviet vibe, inherent in exactly the kind of noise that many people once heard in childhood and much less often in their youth.
I repeat that this project does not stand out to me as something even interesting, it was done for pleasure with pleasure, because I can. I asked ai to analyze the component database available on the Internet and the general reasoning of users, and then collect from all available variations of mixers from the Электроника company - ПМ-01, ПМ-02, ПМ-03 and ПМ-04, in order to create a fantasy version of a Soviet-style mixing console based on available knowledge.
Thus, we form a picture of the noise of a Soviet-style console without possible and/or harmful artifacts, a console that I named after my ancestors ПМ-014. PM stands for "Пульт Микшерный", which translates simply as a mixing console, in fact it is CM-014.

To the point. The presence of noise in the cascade version can vary, unlike the physical version of the mixer, which has one strict and even noise (which engineers always struggle with), so adding noise with plug-ins always puts us at a crossroads, quality versus uncontrolled dirt. Therefore, the idea is based on the fact that we don't just have two plug-ins, a channel and a bus as in the original, but we have three plug-ins, a channel and two buses. From the previous post, I recommend using the cleanest and most accurate AuruPure Channel plug-in, then, inside the project, following the logic of mixing individual parts of the mix, I suggest using the Aurus Buss plug-in.

Code: Select all

processor ConsoleAurusBuss
{
	input stream float In1, In2;
	output stream float Out1, Out2;

	std::random::RNG rng;

	struct ChannelState  ///saving the pink noise state for different channels
	{
    float[12] values;
    int32 sampleCount;
    float32 lastLevel;
	}

	ChannelState s1;
	ChannelState s2;

	///initializing equalizer filters
	std::filters (float)::simper::Implementation highPassFilter;
	std::filters (float)::simper::Implementation lowShelfFilter;
    std::filters (float)::simper::Implementation peakFilter1;
	std::filters (float)::simper::Implementation peakFilter2;
    std::filters (float)::simper::Implementation highShelfFilter;
    std::filters (float)::simper::Implementation lowPassFilter;

    void init()
    {
        rng.seed ( 407L + processor.id );
    }
	
	float Aurus ( float n, ChannelState& s ) 
	{ 
		float64 g = n;
		float   z = pink ( s );

		if ( abs ( g ) < 1.18e-23 ) g = z * 2.534e-8;

		z = highPassFilter.process  ( z ); ///applying equalizer filters
		z = lowShelfFilter.process  ( z ); 
		z = peakFilter1.process     ( z );
		z = peakFilter2.process     ( z );
		z = highShelfFilter.process ( z );
		z = lowPassFilter.process   ( z );

		if ( g > 1.0 ) g = 1.0; /// Сoding of each channel by the golden ratio
		else if ( g > 0.0 )
		{
			g = - ( exp (  log ( 1.0 - g ) * 0.6180339887498949 ) - 1.0 );
			g *= 1.5782f;
		}

		if ( g < - 1.0 ) g = - 1.0;
		else if ( g < 0.0 )
		{
			g = exp ( log ( 1.0 + g ) * 0.6180339887498949 ) - 1.0;
			g *= 1.5782f;
		}

		/// Pink for 32bit
		int ex = ( int32 ( ( reinterpretFloatToInt ( float32( g ) ) >> 23 ) ) & 0xFF ) - 127;
		g += z * 1.1811159814407334e-24 * pow(2.0, ex + 62.0); ///the scale of the noise is correlated
			
		return  float32 ( g );
	}

	float pink ( ChannelState& s ) ///The original pink noise code
	{
		let next  = rng.getBipolar();
        let count = ++s.sampleCount;
        var level = s.lastLevel;

        for (wrap<s.values.size> i)
        {
            if (((count >> i) & 1) != 0)
            {
                level      -= s.values[i];
                s.values[i] = next;
                level      += next;
                break;
            }
        }

        s.lastLevel = level;
        return (1.0f / float32 (s.values.size - 1)) * level;
	}

	void main()
	{	
		///Cascading initialization of filters inside the processor
		highPassFilter.setMode  ( std::filters (float)::simper::Mode::highPass  );
		lowShelfFilter.setMode  ( std::filters (float)::simper::Mode::lowShelf  );
		peakFilter1.setMode     ( std::filters (float)::simper::Mode::bell      );
		peakFilter2.setMode     ( std::filters (float)::simper::Mode::bell      );
		highShelfFilter.setMode ( std::filters (float)::simper::Mode::highShelf );
		lowPassFilter.setMode   ( std::filters (float)::simper::Mode::lowPass   );

		///The parameters are applied once, for maximum speed
		highPassFilter.setFrequency  ( processor.frequency, 14,   0.4,   0.0 );
		lowShelfFilter.setFrequency  ( processor.frequency, 200,  1.0,   6.5 );
		peakFilter1.setFrequency     ( processor.frequency, 140,  1.0,  -3.0 );
		peakFilter2.setFrequency     ( processor.frequency, 1800, 1.0,  -3.0 );
		highShelfFilter.setFrequency ( processor.frequency, 4000, 0.55, -8.0 );
		lowPassFilter.setFrequency   ( processor.frequency, 8000, 1.2,   0.0 );

		loop 
		{	
			///we process and return the value of each channel in order
			Out1 <- Aurus ( In1, s1 ); 
			Out2 <- Aurus ( In2, s2 );
			
			advance();
		}				
	}	
}

This buss variant adds very low noise to the signal, which is required by us, but is at the level of practical non-accumulation of ~ - 140 Db, it is also in the variant when the equalizer is announced only once and then statically generates a spectral noise form on each channel, but each channel has its own pink noise generator. from which we sculpt the shape we need, it turns out to be inexpensive enough and quiet enough that you don't have to worry too much about the noise itself.

Aurus.png

The second and most formidable in terms of absorbing your CPU is Master Buss. This plugin is used only once, at the beginning of the mastering chain for the final mixing of all the components of your track. This plugin can seriously harm your capabilities inside the daw, both operationally and phonically. Each task in it is completely individual with respect to each channel, its own pink noise generator for each channel, passes through its own set of equalizer filters for each channel, forming a spectral picture of the noise we need, but at the same time a random value is added to each parameter of each filter, creating mobility and a small floating of parameters, and not just randomly, but receiving From the daw, the tempo of your project, the parameters adjust to the rhythm so that every 16 steps get a new value., calculate the path from the old value to the new one and move carefully to the new value of 16 cycles, creating a small pump around the main values and updating the parameters of all filters on each sample individually for each channel.

Code: Select all

/// Электроника ПМ-014 =) Мастер Консоль
/// Фантазия на тему советской мастеринг консоли
///
processor ConsoleMasterBuss
{
    input  stream float In1,  In2;
    output stream float Out1, Out2;
    input  event  std::timeline::Tempo tin;

    std::random::RNG rng;  

    struct cs /// Состояние для генератора розового шума
    {
        float [ 12 ] values;
        int32 sampleCount;
        float32 lastLevel;
    }
	cs ns1, ns2; /// Состояния для каждого канала

    struct mp /// Состояние модулируемых параметров
    {
        float current, target, speed;
    }

    struct ms // Cостояние модулируемых состояний для каждого канала
    {
        mp bell1Freq, bell1Gain, bell2Freq, bell2Gain, lowHump, highHump;
    }

    ms ms1, ms2; /// Состояния для каждого канала

    /// Инициализация эквалайзерных фильтров
    std::filters ( float )::simper::Implementation highPass;
    std::filters ( float )::simper::Implementation lowShelf;
    std::filters ( float )::simper::Implementation peak1;
    std::filters ( float )::simper::Implementation peak2;
    std::filters ( float )::simper::Implementation highShelf;
    std::filters ( float )::simper::Implementation lowPass;

    void init() ///Зерно Рандома
    {
        rng.seed ( 414L + processor.id );
    }
    void sv ( ms& v ) 
    {
        v.bell1Freq.current = 140.0f; 
		v.bell1Gain.current = 1800.0f;
        v.bell2Freq.current = 50.0f; 
		v.bell2Gain.current = 3.0f;
        v.lowHump.current   = 0.0f;
		v.highHump.current  = 0.0f;
    }
	
	void upd ( ms& s, int l ) /// Обновляем состояние интерполяции
	{

    	s.bell1Freq.target = 140.0f  + rng.getBipolar()  * 5.0f;
        s.bell1Freq.speed  = abs ( ( s.bell1Freq.current - s.bell1Freq.target ) / l );

    	s.bell1Gain.target = 3.0f    - rng.getUnipolar() * 1.5f;
        s.bell1Gain.speed  = abs ( ( s.bell1Gain.current - s.bell1Gain.target ) / l ) ;

        s.bell2Freq.target = 1800.0f + rng.getBipolar()  * 100.0f;
        s.bell2Freq.speed  = abs ( ( s.bell2Freq.current - s.bell2Freq.target ) / l );

    	s.bell2Gain.target = 3.0f    - rng.getUnipolar() * 1.5f;
        s.bell2Gain.speed  = abs ( ( s.bell2Gain.current - s.bell2Gain.target ) / l ) ;

        s.lowHump.target   = rng.getUnipolar();
        s.lowHump.speed    = abs ( ( s.lowHump.current   - s.lowHump.target   ) / l );

    	s.highHump.target  = rng.getBipolar();
        s.highHump.speed   = abs ( ( s.highHump.current  - s.highHump.target  ) / l );
	}

    void ip ( ms& s ) /// Интерполируем значения
    {
        s.bell1Freq.current += ( s.bell1Freq.target - s.bell1Freq.current ) * s.bell1Freq.speed;
        s.bell1Gain.current += ( s.bell1Gain.target - s.bell1Gain.current ) * s.bell1Gain.speed;

        s.bell2Freq.current += ( s.bell2Freq.target - s.bell2Freq.current ) * s.bell2Freq.speed;
        s.bell2Gain.current += ( s.bell2Gain.target - s.bell2Gain.current ) * s.bell2Gain.speed;

        s.lowHump.current   += ( s.lowHump.target   - s.lowHump.current   ) * s.lowHump.speed;
        s.highHump.current  += ( s.highHump.target  - s.highHump.current  ) * s.highHump.speed;
    }

    float Master ( float a, cs& s, ms& m ) /// Комплексное обрабатывание канала
    {
        float64 g = a;
        float   z = pink ( s ); /// Розовый шум в данный момент

        if ( abs ( g ) < 1.18e-23 ) g = z * 2.534e-8; /// Звук никогда не бывает 0

        /// Обновление параметров эквалайзера, каждый семпл
        highPass.setFrequency  ( processor.frequency, 14.0f  + m.lowHump.current * 2.0f,      0.4f,  0.0f                 );
        lowShelf.setFrequency  ( processor.frequency, 200.0f - m.lowHump.current * 20.0f,     1.0f,  6.5f                 );
        peak1.setFrequency     ( processor.frequency, m.bell1Freq.current,                    1.0f, - m.bell1Gain.current );
        peak2.setFrequency     ( processor.frequency, m.bell2Freq.current,                    1.0f, - m.bell2Gain.current ); 
        highShelf.setFrequency ( processor.frequency, 4000.0f + m.highHump.current * 2000.0f, 0.5f, -8.0f                 ); 
        lowPass.setFrequency   ( processor.frequency, 8000.0f + m.highHump.current * 4000.0f, 1.2f,  0.0f                 );

        /// Применение эквалайзера к шуму
        z = highPass.process  ( z );
        z = lowShelf.process  ( z ); 
		z = peak1.process     ( z ); 
		z = peak2.process     ( z ); 
		z = highShelf.process ( z ); 
		z = lowPass.process   ( z );

        /// Смешивание каналов путём вычисления обратного Золотого Сечения
        if ( g > 1.0f ) g = 1.0f; 
		else if ( g > 0.0f ) 
		{ 
			g = - ( exp ( log ( 1.0f - g ) * 0.6180339887498949 ) - 1.0f ); 
			g *= 1.5782f; 
		}
        if ( g < -1.0f ) g = -1.0f; 
		else if ( g < 0.0f ) 
		{ 
			g =     exp ( log ( 1.0f + g ) * 0.6180339887498949 ) - 1.0f; 
			g *= 1.5782f; 
		}

        int ex = ( int32 ( ( reinterpretFloatToInt ( float32 ( g ) ) >> 23 ) ) & 0xFF ) - 127; /// Вычисление экспоненты сигнала
		g += z * 1.18111598e-22 * pow ( 2.0f, ex + 62.0f ); /// добавление шума к сигналу с масштабом, где максимум -100 Дб

        return float32 ( g );
    }

	float pink ( cs& s ) /// Стандартная библиотека Розового шума от Cmajor
	{
		let next  = rng.getBipolar();
        let count = ++s.sampleCount;
        var level = s.lastLevel;

        for ( wrap < s.values.size > i )
        {
            if ( ( ( count >> i ) & 1 ) != 0 )
            {
                level      -= s.values[i];
                s.values[i] = next;
                level      += next;
                break;
            }
        }

        s.lastLevel = level;
        return ( 1.0f / float32 ( s.values.size - 1 ) ) * level;
	}
    
    float tmp; /// Получаем Темп из ДАВ
    event tin ( std::timeline::Tempo t )
    {
          tmp = t.secondsPerBeat();
    }

    int bc;

    void main()
    {
        /// Устанавливаем режим каждого фильтра эквалайзера, один раз
        highPass.setMode ( std::filters ( float )::simper::Mode::highPass  );
        lowShelf.setMode ( std::filters ( float )::simper::Mode::lowShelf  ); 
		peak1.setMode    ( std::filters ( float )::simper::Mode::bell      ); 
		peak2.setMode    ( std::filters ( float )::simper::Mode::bell      ); 
		highShelf.setMode( std::filters ( float )::simper::Mode::highShelf ); 
		lowPass.setMode  ( std::filters ( float )::simper::Mode::lowPass   );

        sv ( ms1 ); // Устанавливаем начальные значения
        sv ( ms2 );

        upd ( ms1, 1 ); /// Генерируем первые значения для всех каналов
		upd ( ms2, 1 ); 

        loop
        {
            if ( bc <= 0 ) /// Меняем параметры в зависимости от темпа
            {
                bc = int ( tmp / 16.0f * processor.frequency ); /// количество семплов в 1\32 секунды
                upd ( ms1, bc ); /// Начинаем перебор семплов по одному
                upd ( ms2, bc );
            }

            ip ( ms1 ); /// Интерполяция значений
            ip ( ms2 );

            /// Вызываем обработку, передавая каждому вызову собственный набор состояний
            Out1 <- Master ( In1, ns1, ms1 );
            Out2 <- Master ( In2, ns2, ms2 );
			
            --bc; /// Отсчёт семплов до новых параметров
            advance(); /// Следующий семпл
        }
    }
}

Master.png

Thus, we get a general comparison of both Aurus and Master plug-ins, where Aurus is responsible for the easy accumulation of static, but correct-shaped noise inside the signal, and then the Master, summing up with everything, covers all the parameters dancing to your track with small movements.

The plugins are still designed so that you can physically add any number of input channels without complicated manipulations, the structure in the variable names is preserved for this, but in this case, I think at first glance you will immediately have to strain to figure it out, because there are many conditions for strict execution of the entire code.