Well here's a long answer to a short couple of questions - the current RackAFX API (now named RAFX1) was originally designed as a C++ plugin object that implemented a simple plugin API, but only for the RackAFX platform (which was named "Socket" back then ~2008). When my first book came out, which used RackAFX as a sort of "demo-platform" to show a simple API not tied to any manufacturer, there was immediate pressure to make it work for AU, VST, and later AAX. So, when you export a RAFX plugin now, the resulting AU, AAX and VST projects implement wrappers, which translate their API-specific function calls into RackAFX-specific function calls in the embedded RAFX1 plugin. This isn't uncommon and the VST3 SDK includes wrappers for AU and AAX, though of course they only work with VST3 plugins.
ASPiK(TM) (Audio Specific Plugin Kernel) implements a C++ plugin kernel that is not tied to RackAFX, or any API, or platform. The kernel consists of three specialized objects that do the required work for a monolithic audio plugin (a plugin that packages the audio algorithm and GUI-parameter manipulation/updates in one object). But, the objects don't implement another API, nor do they constitute one - meaning that you can't turn it/themÂ into an API without a ton of customization and extra code and extra objects. And that is on purpose and is a good thing. The fact that they are incomplete as far as being a plugin API helps them be more independent from any API.Â
The resulting AAX, AU and VST projects are not wrappers for another API, they simply *use* the plugin kernel objects to do their very similar set of plugin chores: plugin description, parameter declarations, parameter updates, and audio signal processing, with custom GUI thrown in for good measure. You can just as easily delete the kernel from the AU, AAX and VST projects, and insert your own objects, or just use the objects that you like, and discard the others. In other words there is no tight binding between the plugin kernel, the other APIs, or even the objects within the kernel itself. For example, the audio processing core object has no idea that the GUI object exists, and it doesn't need to know of its existence. And vice versa. There are a couple of C++ interfaces that help with the integration, but the objects are not bound to them - in their absence they still function properly on their own, which means that they can be adapted to new or different APIs in the future.Â
ASPiK generates empty projects for you in any flavor or combination of AU, AAX, and VST for Windows and/or MacOS. You then edit the kernel files once, which are shared across combination projects (BTW, this is also true for current RAFX1 "combination" exports) and build for any/all of them. The kernel objects that you work on when making your plugin don't contain a shred of API-specific code in them either. They are just straight C++ with the std:: library.
Of course there is also a RackAFX option (there has to be!) - RackAFX will generate the ASPiK projects for you and write the GUI parameter code and other necessary/boring stuff into the kernel, based on the familiar RackAFX UI control paradigms. In fact, as far as setting up your GUI controls goes, there is no big difference there. You can still use the RackAFX GUI designer too, to create a custom GUI, or you can use other methods (big surprise coming there too). You can also import old RAFX1 UIs into new projects.
Because it is incomplete as an API, RackAFX doesn't try to deform or shoehorn the plugin kernel into a RAFX1 plugin. Instead, I implemented a new and ultra-thin RackAFX API named RAFX2. RAFX2 plugins contain and use the plugin kernel, just as their AAX, AU and VST counterparts do. When you use RackAFX to write a RAFX2 plugin, you don't alter anything in the RAFX2 objects or code like you do now, where you completely change and mangle those RAFX1 derived objects for each project - even the class names are different for each project! That is totally gone in RAFX2.
When you've debugged your project, just like you do now with the familiar analyzer, oscillator, etc.. and added the GUI (or not), you can export it. But now you export it as an ASPiK project. When this happens, the kernel is extracted from your RAFX2 project, permanently leaving all RackAFX support code and RAFX2 API stuff behind so that the resulting project contains absolutely 0.00% of any RackAFX code, or any kind of link to it.
In fact those ASPiK projects are identical to non-RackAFX-generated ASPiK projects, except that all the parameter/boring code is written for you.
And that code is not difficult to write at all (in fact it is waaaay easier than defining parameters for any of the other APIs) so you can generate and then code an ASPiK project easily and painlessly without RackAFX - of course I always use RAFX.
As for the new RackAFX, other than ASPiK support, the paradigm for adding controls to the main prototyping UI has changed. The middle strip of radio buttons and switches is now gone. So are the hard-to-find user meters.Â
Instead of a bank of 80 knobs (scrollable to reveal 1024 more) on the main UI "panel," there are now 80 *slots* instead. You can insert any kind of control into any slot, including knobs, 4-part radio buttons, 2-state toggle switches and push-buttons, VU meters, and a new Option Menu (drop down list) control. This lets you arrange the prototyping UI panel however you like, with your controls clustered together, in rows, columns, or other groupings, similar to the way you would want it on your final custom GUI. And those panels are scroll-able to reveal a total of 1024 slots.
You can also use the keyboard arrow-keys to easily move up and down through the panels, by individual rows or by entire panels at a time. And you don't have to switch around so much to see the user meters any more - they are now embedded into your main UI, wherever you want them to be located. On top of that, you can now output data to a custom GUI window and write your own code to plot audio waveforms, filter transfer functions, FFTs, even text data, etc... That custom graphics code can then be easily put into a custom view in an ASPiK GUI when you do the project export.Â
I'll be posting new screen shots of RAFX soon and of course you know that there will be numerous new video tutorials on RackAFX, and especially on using ASPiK (with and without RackAFX). All of this is timed with a new book release that I'm wrapping up now. And its gonna be a doozie too.Â
Talk more later -Â
That is some exciting news! I started out coding my audio stuff on RackAFX and your book, Designing Audio Effect Plugins in C++, was the perfect investment to get the ball rolling. Eventually, my realtime audio source separation plugin will be released, and I owe a great deal of thanks to you for being there for us developers, and putting out some awesome literature and APIs. Without it, it would have been much harder for someone like me to get started.
I can't wait to try the new RackAFX and dig into many more insights the new book has to offer.
Best of luck with the release (on both fronts),
Yes - I spoke with my publisher at the AES convention in NYC 2 weeks ago. The manuscript was delayed on their end, but is in the pipeline and hopefully will be published by the end of the year. I should start getting proofs back in a couple of weeks, and then it usually goes pretty quickly after that (2 proofreads).Â
The ASPiK SDK is done. One issue is that inside the SDK, I include the 54 C++ objects that are derived, analyzed, and coded in the book including the WDF ladder filter library and the FFTW-based objects for pitch shifting, sample rate conversion, etc... Since those are actually part of the book's print, I need to wait until the book is in print before releasing them - and yes they are free for you to use in commercial and non-commercial applications.Â
I could release ASPiK now but without all the added objects, and we've been testing it in my plugins classes at the University of Miami for 2 years. But I think it might be better to wait until I can release the full package.
One thing I've already started are some videos that show how to use ASPiK along with others that show how to transition from the "old" RAFX to the new RAFX7. Once those start popping up on YouTube, it will mean that the book is only a few weeks out. I'll leave a note on this thread as well!
Most Users Ever Online: 152
Currently Browsing this Page:
Guest Posters: 1
Moderators: W Pirkle: 689