Don't know if this is the done thing really, but I wanted to show off:
https://youtu.be/1kMHloRQLcM

@Chazrox I might do a video or two on everything I've learned!

@d-healey I really like that UI. Very simple, accessible, and smooth looking - for lack of a better word!

Free mankini with every commercial license???

@Chazrox said in I wrote a reverb:

@Orvillain Please. I've been waiting for some dsp videos! I've been watching ADC's everyday on baby topics just to familiarize myself with the lingo and what nots. I think im ready to start diving in! There are some pretty wicked dsp guys in here for sure and I'd love to get some tutuorials for writing c++ nodes.

There's two guys who got me started in this. One is a dude called Geraint Luff aka SignalSmith. This is probably his most accessible video:
https://youtu.be/6ZK2Goiyotk

Then the other guy of course is Sean Costello of ValhallaDSP fame:
https://valhalladsp.com/2021/09/22/getting-started-with-reverb-design-part-2-the-foundations/
https://valhalladsp.com/2021/09/23/getting-started-with-reverb-design-part-3-online-resources/

In essence, here's the journey; assuming you know at least a little bit of C++

1. Learn how to create a ring buffer (aka my Ring Delay thread)
2. Learn how to create an all-pass filter using a ring buffer.
3. Understand how fractional delays work, and the various types of interpolation.
4. Learn how to manage feedback loops.

Loads of resources out there for sure!

Lesson 5 - SNEX code in a bit more detail.

So I'm by no means an expert in C or C++ - in fact I only just recently started learning it. But here's what I've sussed out in regards to the HISE template.... and template is exactly the right word, because the first line is:

template <int NV> struct audio_loader

Somewhere under the hood, HISE must be setup to send in an integer into any SNEX node, that integer corresponding to a voice. NV = new voice perhaps, or number of voices ????

The line above declares a template that takes this NV integer in, and creates a struct called audio_loader for each instance of NV. Indeed we can prove this by running the following code:

template <int NV> struct audio_loader
{
	SNEX_NODE(audio_loader);
	
	ExternalData data;
	double note = 0.0;
	
	// Initialise the processing specs here
	void prepare(PrepareSpecs ps)
	{

	}
	
	// Reset the processing pipeline here
	void reset()
	{
		
	}
	
	// Process the signal here
	template <typename ProcessDataType> void process(ProcessDataType& data)
	{

	}
	
	// Process the signal as frame here
	template <int C> void processFrame(span<float, C>& data)
	{

	}
	
	// Process the MIDI events here
	void handleHiseEvent(HiseEvent& e)
	{
		double note = e.getNoteNumber();
		Console.print(note);

	}
	
	// Use this function to setup the external data
	void setExternalData(const ExternalData& d, int index)
	{
		data = d;
	}
	
	// Set the parameters here
	template <int P> void setParameter(double v)
	{
		
	}
};

There are only three things happening here:

1. We set the ExternalData as in a previous post.
2. We establish a variable with the datatype of double called 'note' and we initialise it as 0.0. But this value will never hold because....
3. In the handleHiseEvent() method, we use e.getNoteNumber() and we assign this to the note variable. We then print the note variable out inside of the handleHiseEvent() method.

Now when we run this script, any time we play a midi note, the console will show us the note number that we pressed. This is even true if you play chords, or in a scenario where no note off events occur.

That's a long winded way of saying that a SNEX node is run for each active voice; at least when it is within a ScriptNode Synthesiser dsp network.

The next line in the script after the template is established is:

SNEX_NODE(audio_loader);

This is pretty straight forward. The text you pass here has to match the name of the script loaded inside your SNEX node - not the name of the SNEX node itself.

Here you can see my SNEX node is just called: snex_node.

But the script loaded into it is called audio_loader, and so the reference to SNEX_NODE inside the script has to also reference audio_loader.

@d-healey said in scriptAudioWaveForm and updating contents:

@Orvillain Did you try, AudioWaveform.set("processorId", value); ?

Yeah I did, and it does update it based on a follow up AudioWaveform.get('processorId') call - but the UI component doesn't seem to update, and still shows data from the previous processorId. When I compile the script, then the UI updates one time... but not on subsequent calls to the set method.

I figured I needed to call some kind of update() function after setting the processorId, but no such luck so far.

They're all crap quite honestly.

Here is a super contrived example. If you compile this as a node, and add it in your scriptnode layout... it will delay the right signal by 2 seconds.

#pragma once
#include <JuceHeader.h>

namespace project
{
using namespace juce;
using namespace hise;
using namespace scriptnode;

static inline float cubic4(float s0, float s1, float s2, float s3, float f)
{
    float a0 = -0.5f * s0 + 1.5f * s1 - 1.5f * s2 + 0.5f * s3;
    float a1 =  s0        - 2.5f * s1 + 2.0f * s2 - 0.5f * s3;
    float a2 = -0.5f * s0 + 0.5f * s2;
    float a3 =  s1;
    return ((a0 * f + a1) * f + a2) * f + a3;
}

struct RingDelay
{
	// holds all of the sample data
	std::vector<float> buf;

	// write position
	int w = 0;

	// bitmask for fast wrap-around (which is why the buffer must always be power-of-2)
	int mask = 0;

	// sets the size of the buffer according to requested size in samples
	// will set the buffer to a power-of-two size above the requested capacity
	// for example - minCapacitySamples==3000, n==4096
	void setSize(int minCapacitySamples)
	{
		// start off with n=1
		int n = 1;

		// keep doubling n until it is greater or equal to minCapacitySamples
		while (n < minCapacitySamples)
		{
			n <<= 1;
		}

		// set the size of the buffer to n, and fill with zeros
		buf.assign(n, 0.0f);

		// mask is now n-1; 4095 in the example
		mask = n - 1;
		
		// reset the write pointer to zero
		w = 0;
	}

	// push a sample value into the buffer at the write position
	// this will always wrap around the capacity length because of the mask value being set prior
	void push(float x)
	{
		buf[w] = x; // set the current write position to the sample value
		w = (w + 1) & mask; // increment w by 1. Use bitwise 'AND' operator to perform a wrap
	}

	// Performs a cubic interpolation read operation on the buffer at the specified sample position
	// This can be a fractional number
	float readCubic(float delaySamples) const
	{
		// w is the next write position. Read back from that according to delaySamples.
		float rp = static_cast<float>(w) - delaySamples;
		// wrap this read pointer into the range 0-size, where size=mask+1
		rp -= std::floor(rp / static_cast<float>(mask + 1)) * static_cast<float>(mask + 1);

		// the floor of rp - the integer part
		int i1 = static_cast<int>(rp);

		// the decimal part
		float f = rp - static_cast<float>(i1);

		// grab the neighbours around i1
		int i0 = (i1 - 1) & mask;
		int i2 = (i1 + 1) & mask;
		int i3 = (i1 + 2) & mask;

		// feed those numbers into the cubic interpolator
		return cubic4(buf[i0], buf[i1 & mask], buf[i2], buf[i3], f);
	}

	// returns the size of the buffer
	int size() const
	{
		return mask + 1;
	}

	// clear the buffer without changing the size and reset the write pointer
	void clear()
	{
		std::fill(buf.begin(), buf.end(), 0.0f);
		w = 0;
	}
};



// ==========================| The node class with all required callbacks |==========================

template <int NV> struct RingBufferExp: public data::base
{
	// Metadata Definitions ------------------------------------------------------------------------
	
	SNEX_NODE(RingBufferExp);
	
	struct MetadataClass
	{
		SN_NODE_ID("RingBufferExp");
	};
	
	// set to true if you want this node to have a modulation dragger
	static constexpr bool isModNode() { return false; };
	static constexpr bool isPolyphonic() { return NV > 1; };
	// set to true if your node produces a tail
	static constexpr bool hasTail() { return false; };
	// set to true if your doesn't generate sound from silence and can be suspended when the input signal is silent
	static constexpr bool isSuspendedOnSilence() { return false; };
	// Undefine this method if you want a dynamic channel count
	static constexpr int getFixChannelAmount() { return 2; };
	
	// Define the amount and types of external data slots you want to use
	static constexpr int NumTables = 0;
	static constexpr int NumSliderPacks = 0;
	static constexpr int NumAudioFiles = 0;
	static constexpr int NumFilters = 0;
	static constexpr int NumDisplayBuffers = 0;
	
	// components
	double sampleRate = 48000.0;
	RingDelay rd;
	
	// Helpers
	
	// Converts milliseconds to samples and returns as an integer
	static inline int msToSamplesInt(float ms, double fs)
	{
		return (int)std::ceil(ms * fs / 1000.0);
	}

	// Converts milliseconds to samples and returns as a float
	static inline float msToSamplesFloat(float ms, double fs)
	{
		return (float)(ms * fs / 1000.0);
	}
	
	// Scriptnode Callbacks ------------------------------------------------------------------------
	
	void prepare(PrepareSpecs specs)
	{
		// update the sampleRate constant to be the current sample rate
		sampleRate = specs.sampleRate;
		
		// we arbitrarily invent a pad guard number to add to the length of the ring delay
		const int guard = 128;
		
		// set the size using msToSamplesInt because setSize expects an integer
		rd.setSize(msToSamplesInt(10000.0f, sampleRate) + guard);
	}
	
	void reset()
	{
		
	}
	
	void handleHiseEvent(HiseEvent& e)
	{
		
	}
	
	template <typename T> void process(T& data)
	{
		
		static constexpr int NumChannels = getFixChannelAmount();
		// Cast the dynamic channel data to a fixed channel amount
		auto& fixData = data.template as<ProcessData<NumChannels>>();
		
		// Create a FrameProcessor object
		auto fd = fixData.toFrameData();
		
		while(fd.next())
		{
			// Forward to frame processing
			processFrame(fd.toSpan());
		}
		
	}
	
	template <typename T> void processFrame(T& data)
	{
		// Separate out the stereo input
		float L = data[0];
		float R = data[1];
		
		// Calculate the delay time we want in samples - expects float
		float dTime = msToSamplesFloat(2000.0f, sampleRate);
		
		// read the value according to the delay time we just setup
		float dR = rd.readCubic(dTime);
		
		// Push just the right channel into our ring delay
		// remember, this will auto-increment the write pointer
		rd.push(R);
		
		// left channel - Write the original audio back to the datastream
		data[0] = L;
		// Right channel - Write the delayed audio back to the datastream
		data[1] = dR;
	}
	
	int handleModulation(double& value)
	{
		
		return 0;
		
	}
	
	void setExternalData(const ExternalData& data, int index)
	{
		
	}
	// Parameter Functions -------------------------------------------------------------------------
	
	template <int P> void setParameter(double v)
	{
		if (P == 0)
		{
			// This will be executed for MyParameter (see below)
			jassertfalse;
		}
		
	}
	
	void createParameters(ParameterDataList& data)
	{
		{
			// Create a parameter like this
			parameter::data p("MyParameter", { 0.0, 1.0 });
			// The template parameter (<0>) will be forwarded to setParameter<P>()
			registerCallback<0>(p);
			p.setDefaultValue(0.5);
			data.add(std::move(p));
		}
	}
};
}

@griffinboy said in c++ function optimization using vectorization or SIMD???:

It's more popular nowadays to store waveforms in frequency domain using FFT, and to silence bins above Nyquist before inverse FFT. Either that or use filters to make mipmaps (multiple copies of your waveform at different pitches, with antialiasing filters applied, baked into the copies, play back the appropriate pre-antialiased file for the pitch) optionally doing so at 2x oversampling and using additional interpolation to remove aliasing that happens from extra processes that happen in Realtime.

Cheers dude! I was aware of this, but I wanted to see how far I could get with sinc. Turns out, quite far! I've got 22% CPU usage for about 30 voices now. Which isn't really super optimal, but it was a fun project.

That paper you linked me a while back - https://www.mp3-tech.org/programmer/docs/resampler.pdf - was what got me interested.

I think I understand the process you mean though, for the mipmapping approach. Something like:

• Oversample original audio x2 (juce::dsp::oversampling can handle this)
• Set up a root note
• For mip-maps below the root note - lowpass and downsample (dsp::FilterDesign::designFIRLowpassWindowMethod then keep every 2nd sample)
• For mip-maps above the root note - upsample and then lowpass (use the same oversampling approach here for the upsampling and then the same kind of FIR filter???)
• Store each level, and then move on to the playback engine

I think that'd be the approach??

Playback engine-wise, I'd still need to have an interpolation method to playback notes in between the mipmap levels I would guess. Can Hermite cover this, or do I need to go polyphase still?

Hey apologies for the bump. But I got this to work by putting:
JUCE_LOG_ASSERTIONS=1

into the preprocessor definitions and then rebuilding. I get data from my custom c++ node printing to the visual studio log:

It wasn't working until I did that.

@Orvillain

Lesson 4 - SNEX Node layout.

I'm still wrapping my head around how the SNEX node works.

The first thing to note is, SNEX code does not support strings. The documentation for HISE does make this clear, but if you haven't seen it yet... then I've told you again! Here's the docs link:
https://docs.hise.audio/scriptnode/manual/snex.html#getting-started

As the docs say:
The Scriptnode Expression Language (SNEX ) is a simplified subset of the C language family and is used throughout scriptnode for customization behaviour.

Which means that most of the syntax you're used to when writing interface scripts, is just not going to be the same. There are some overlaps however - Console.print() is still used in SNEX scripts. However, print messages only get logged to the console when you put the SNEX node into debug mode. Which you can do by clicking this button:

From what I can tell, by default we have the following methods:

• prepare
• reset
• process
• processFrame
• handleHiseEvent
• setExternalData
• setParameter

Each one of these methods has a purpose. I'm still experimenting to figure out what those are, but here's what I've come up with so far:

• prepare
  This is called when you compile or initialise your SNEX node, and it seems to run for each audio channel. I would guess this is meant to setup global parameters like sample rate and block size. Things that do not change from voice to voice.
• reset
  This is called when you trigger a voice, in my case from midi. When using a ScriptNode Synthesiser, the midi passes into the node automatically. This is where you would initialise variables that can hold different values from voice to voice, but that must start out with the same default value each time.
• process
  Haven't quite figured this one out yet.
• processFrame
  Haven't quite figured this one out yet.
• handleHiseEvent
  This is called when you trigger a HiseEvent - typically a midi event. This is where you would parse out your midi notes, velocities, controllers, and program changes; any midi data really.
• setExternalData
  This is called whenever there is a change to the external data. In our case, that would be the AudioFile we added in previous steps. So for example if you went to the complex data editor for the External AudioFile Slot (in the node editor) and loaded a new file, this method would get called. This is where you would resize any arrays that you're using to store the sample data, for example.
• setParameter
  This is called whenever a parameter inside the SNEX node is adjusted. You can parse the parameters out by using if statements and checking P against 0, 1, 2, 3, etc, depending on how many parameters you actually have.

SNEX has some hard-coded variable names, most of which I don't know yet. But a valuable one is "ExternalData". Consider this code:

template <int NV> struct audio_loader
{
	SNEX_NODE(audio_loader);
	
	ExternalData data;
	// Initialise the processing specs here
	void prepare(PrepareSpecs ps)
	{

	}
	
	// Reset the processing pipeline here
	void reset()
	{
	

	}
	
	// Process the signal here
	template <typename ProcessDataType> void process(ProcessDataType& data)
	{

	}
	
	// Process the signal as frame here
	template <int C> void processFrame(span<float, C>& data)
	{

	}
	
	// Process the MIDI events here
	void handleHiseEvent(HiseEvent& e)
	{
		
	}
	
	// Use this function to setup the external data
	void setExternalData(const ExternalData& d, int index)
	{
		data = d;
	}
	
	// Set the parameters here
	template <int P> void setParameter(double v)
	{
		
	}
};

Most of it doesn't do anything. But we have established that ExternalData is linked to a variable called data. We can also see this in the data table view:

Notice how ExternalData is a Data Type, and it is named data. Also notice how it has a variety of sub attributes - dataType, numSamples, numChannels, etc.

Let's swap out the file loaded in the AudioFile editor:

Notice how numSamples has updated, and also numChannels.

Back to the code:

// Use this function to setup the external data
	void setExternalData(const ExternalData& d, int index)
	{
		data = d;
	}
	
	// Set the parameters here
	template <int P> void setParameter(double v)
	{
		
	}

The data variable we established as ExternalData at the top of the script, is now actually having the data pushed into it by the setExternalData method - which has two inputs; "d" and "index".

This shows the very very basics of getting sample data into a SNEX script. But we're still not doing anything with it yet.

@d-healey I don't mean to be rude, but please don't distract from the purpose of this thread. Beautiful code and efficient code isn't the point here.

The point is to demonstrate how the API works, and for there to be a resource for people who come along in the future looking to do sample loading from their scripts, and looking to do advanced things in ScriptNode or SNEX.

I know full well that in a real world scenario, you wouldn't specify a bunch of files each as an individual const, and you'd put them in a key value pair inside of an array, or perhaps a function acting as a meta-object.

@Orvillain

Lesson 3 - using the SNEX node with sample content.

This one is something I'm still getting my head around. @Christoph-Hart kindly provided a one shot SNEX node demo, which you can find by going to the example snippet browser in the Help menu:

This will open a whole new window where you can experiment with snippets. Maybe I'll go over the specific snippet in another post, but for this one... we're starting fresh, and we're going to just do the basics.

So.... here we have a basic interface script that gives us some file const references, an AudioSampleProcessor retreiving the AudioSampleProcessor from a Scriptnode Synthesiser in our module tree. That synthesiser has a DspNetwork assigned to it:

Right now, if we run the code... it will fail to find the AudioSampleProcessor as explained above. Let's add a SNEX node:

When you do this, it will be blank. You will need to click the three dot menu icon and choose "create new file" - strangely enough, you have to do this even when creating an embedded network. But fine. Let's do it:

We need to give it a name:

At this point, the node becomes active, indicated by the green highlight text:

Now if you open the same menu, you get more options:

We're going to select 'Add AudioFile':

You can see that now there is an extra icon in the SNEX node, which opens the AudioFile "Complex Data Editor" panel.

We can add an External AudioFile Slot using the icon on the right hand side:

And now you can see that the data editor will display whatever sample you assign to that AudioSampleProcessor from your script:

So here we see that file_r has been loaded into the buffer, and if we wanted to do file_f instead we could change the code to do that:

Note - you will not be able to playback the audio at this stage, as your SNEX code will be completely empty. If you click the icon on the right side, it will open the code editor for this SNEX node:

So whilst the data is loaded, our code isn't doing anything with it.

@Orvillain

Lesson 2: loading samples.

Loading samples into an AudioSampleProcessor can be done by running a .setFile() call on the retrieved AudioSampleProcessor object.

However, on Windows, it is very easy to make this crash.

Consider the above image. The backslashes in files a-r, will cause HISE to crash to the desktop if you try to load any of those files into the AudioSampleProcessor.

file_s has double backslashes, and this does not seem to crash.

Another way to ensure the file loads, is to just use forward slashes:

I've gotta start documenting some of my experiments, tests, failures, and successes, when it comes to ScriptNode's and SNEX, and interfacing with the Hisescript interface side of things.

So I thought I'd start a thread on it, so hopefully people can learn from my idiocy, and I can have something to reflect back on when I'm stuck.

So.... lesson 1: Synth.getAudioSampleProcessor.

This is a useful method for accessing the sample slot of a module, and generally if you're using the built in sampler or audio player modules, you won't run into this issue. But I just did, and it stumped me for ages, because of a misleading error message.

So here it is - if you are trying to do this with a Scriptnode Synthesiser, you need to be sure that your Scriptnode Synthesiser meets these conditions:

1. It must have a node in it that contains some form of AudioFile: file_player, stretch_player, granulator, or the snex_node nodes.
2. Your node from this list must be set to use an External AudioFile Slot.

If these conditions aren't met, then when you try to make a call to Synth.getAudioSampleProcessor, the console will return the following error:

Interface:! Line 3, column 42: Scriptnode Synthesiser1 was not found.  {SW50ZXJmYWNlfG9uSW5pdCgpfDgwfDN8NDI=}
Master Chain:! Line 3, column 42: Scriptnode Synthesiser1 was not found.  {SW50ZXJmYWNlfG9uSW5pdCgpfDgwfDN8NDI=}

This error actually is not that useful. It really should say that the AudioSampleProcessor was not found in my opinion.

Here is a screenshot of a scenario where you could get this:

You'll notice that I have a Scriptnode Synthesiser in my module list, and it has a DspNetwork assigned to it. However the network is completely empty.

Now if I add a file_player node:

We still get the same error, because the file_player node does not have an external file slot added to it.

If we load a file to the embedded slot (bad practice imho) this also makes no difference:

We still cannot resolve the AudioSampleProcessor.

Finally... if we add an external slot, even when it is empty, we get the AudioSampleProcessor reference that we were looking for:

Something to watch out for.

@clevername27 said in How do I get started with Scriptnode and building synthesisers/samplers?:

@Orvillain Subscribe to @d-healey's Patreon. Also, read @Christoph-Hart's introductions/explanations of HISE, scripting and ScriptNode in the documentation. Learning the right way to do things will save you much trouble later on. His discussion is concise and thorough. Lastly, look at the Snippets and tutorial projects.

Yeah, have read all that. Been digging into the specifics in the documentation, but sometimes it is a little lacking. Have also dug out plenty of snippets and gone through the example projects too. HISE is pretty great!

So... this is all new to me, and the documentation is pretty scant unfortunately.

So I was imagining the first thing I could do as a Hello World would be to throw in a sine-ton oscillator, and then an envelope, and I'd be able to get a polyphonic sine-tone synth that would let me set the attack and decay.

So I did that, and I notice as soon as I release a midi key, the oscillator stops producing noise. Same story with using a file player.

I kinda wasn't expecting that. A helping/guiding hand would be appreciated - are there any videos specifically targeted at building synths rather than effects?

Just to report back, it worked perfectly. It even now picks up the lastest value properly, whereas I'm pretty sure it didn't before. Very nice!

So here's my take on how to do switchable LFO's:

You primarily rely on the built in modules monophonic/polyphonic flag for reset/retrigger behaviour. Don't bother even building it for your own network.

Do your sync this way:

A branch container, containing two chains. Each one has its own ramp source in it. Make one of them the regular ramp source, the other one the clock_ramp source.

You can even write a simple math expression to adjust the phase.

@xander You need to band limit the soft clipping circuit somehow. Not sure if this needs adding to your faust code, or if you can put a filter after it in the network, but essentially.... non-linear clipping/saturation/distortion can create harmonics that far exceed your sampling rate and nyquist; and they end up folding back into lower frequencies. You'll need to handle it by filtering.

Look into FIR filtering within faust, maybe it is something you can add inside the algorithm.