Public Member Functions | |
| virtual void | prepareToPlay (double sampleRate, int blockSize)=0 |
| virtual void | processBlock (float **data, int numChannels, int numSamples)=0 |
| virtual int | getNumParameters () const =0 |
| virtual float | getParameter (int index) const =0 |
| virtual void | setParameter (int index, float newValue)=0 |
| virtual const char * | getStringParameter (int index, size_t &textLength) |
| virtual void | setStringParameter (int index, const char *text, size_t textLength) |
| virtual int | getNumConstants () const |
| virtual void | getIdForConstant (int index, char *name, int &size) const noexcept |
| virtual bool | getConstant (int index, float &value) const noexcept |
| virtual bool | getConstant (int index, int &value) const noexcept |
| virtual bool | getConstant (int index, char *text, size_t &size) const noexcept |
| virtual bool | getConstant (int index, float **data, int &size) noexcept |
This interface class is the base class for all modules that can be loaded as plugin into the script FX processor.
A DspBaseObject is a extremely simple, C-API driven class that performs audio processing called from a Script Processor There are three main concepts for interaction with Javascript:
There are two functions that are called at specific events that perform the actual logic of the module:
There are corresponding callbacks in Script Processors (with even the same name), so using them in Javascript is pretty easy:
As you can see, the >> and << operators are overloaded and call processBlock for the left side with the right side as argument. It might be irritating at first that the two diametral operators do the same thing, but thinking LTR makes it better...
Parameters are floating point values that can be accessed by bracket subscription in Javascript:
Although standard Javascript is not typed, using an non-numerical value produces a runtime-error. It is important to know that the access is not thread safe by default, so considering using Atomics<float> in your implementation for read/write access (which would be the getParameter(), setParameter() methods. If you despise the "magic-numberness" of this system, there is something to help you with that:
Constants are constant values which can be accessed using the .dot Operator. They can hold integer numbers, floating point numbers, text (up to 512 characters) and float arrays.
If you're wondering about performance here, be aware that they are resolved at compile time (even the dot operator) so it is equally fast than just typing the number yourself.
There is a little detail that makes a significant difference: the constant is not really a constant, but a constant reference to a var object. For numbers and texts, this doesn't make a difference, but you can use this trick to access internal data buffers (and even write to them!):
With this trick, you can load audio files into the module, get the tempoary fft data for analysis.
All constants are resolved (= their getConstant() method is called) when the module is loaded. Except for constants that hold float arrays, they are resolved everytime you call prepareToPlay (because changes are great, you might want to resize the buffers).
The implementation is not as straight forward as it could be, because it is not possible to create var objects and throw them across a DLL boundary, so you have to overload multiple functions for every possible type and return true if the given index should be filled with the specific type.
|
pure virtual |
Overwrite this method and setup the processing for the given specifications.
This method will be called always before calls to processBlock(), so you can setup the working buffers etc. here. the sample rate is obvious, but the block size only specifices the maximal size that can be fed into (it may be smaller). You can safely assume that the block size is always a multiple of 4 to make some SSE stuff without bothering about the edge cases.
This method will be called whenever one of the parameter changes (sample rate adjustment, audio buffer size adjustment), as well as when the script will be compiled. After calling this method, every constants containing float arrays will be recalculated (their getConstant() method will be called) so you can adjust their sizes too.
|
pure virtual |
Overwrite this method and do your processing on the given sample data.
| data | a 'numChannels' sized-array of 'numSamples'-sized float arrays |
| numChannels | the channel amount. This can be either '1' or '2', so you must handle both cases. |
| numSamples | the sample amount: this will be max. the amount specified in the last prepareToPlay() call. |
|
pure virtual |
Return the number of parameters for this module. This must be a constant.
|
pure virtual |
This must return the value for each identifier. You might want to make this thread-aware by using Atomic<float> data members.
|
pure virtual |
This must set the parameter to your value. You might want to make this thread-aware by using Atomic<float> data members.
|
virtual |
Returns a string parameter. Use this to pass text values around (eg. for file I/O).
|
virtual |
Sets a string parameter. Use this to pass text values around (eg. for file I/O).
You need to create a copy from the char pointer (because it was allocated using another heap)
|
virtual |
Overwrite this method if your module has constants that
|
virtualnoexcept |
Overwrite this method and write the id of the constant old-school C-style into the given char pointer (max 64 characters)
You can use HelperFunctions::writeString() to avoid getting your hands dirty in too much C-ness...
| index | the index of the constant. |
| name | the name of the constant as plain old C-style string. |
| size | the size of the name |
|
virtualnoexcept |
Overwrite this method and fill in the value of the constant if the given index should be a float value.
| index | the index of the constant. |
| value | the value that this constant should hold |
|
virtualnoexcept |
Overwrite this method and fill in the value if the given index should be an integer value.
Unlike the other getConstant() methods, the default implementation returns the index itself if the index is a valid parameterIndex. Use this in conjunction with the macro FILL_PARAMETER_ID() to automatically create constants that refer to their parameter slots via their enum name.
| index | the index of the constant. |
| value | the value that this constant should hold |
|
virtualnoexcept |
Overwrite this method and fill in the value if the given index should be an String (max 512 characters).
| index | the index of the constant. |
| text | the text that this constant should hold |
|
virtualnoexcept |
Overwrite this method and pass a pointer to your float array data if the given index should be an float buffer.
You can use HelperFunctions::writeString() to avoid getting your hands dirty in too much C-ness...
Unlike the other methods, this method requires that you allocate the data and pass a pointer to the data pointer back. You must make sure you deallocate the data when the library will be destroyed. Although this is theoretically a constant, the only thing that is constant here is the pointer to the data. That means you can alter the content of the float array as you like (as long as you don't change the size).