JUCE 5.1 Release Notes
JUCE 5.1 launches with new DSP features.
The JUCE DSP module provides a set of optimised signal processing routines, mathematical algorithms, and state-of-the-art filters.
- Easy integration
The DSP module consists of several lightweight, self-contained building blocks called “processors” which can easily be integrated into your plug-in or app’s AudioProcessor. Processors can also be combined into a chain of processors to build larger structures. This can be done dynamically via polymorphic wrappers or, with zero overhead, via C++ metaprogramming.
In addition, the DSP module contains a waveshaper and oscillator processor which allows to use any suitable C++ function as the waveshaper or oscillator’s internal transfer/generator function. By using the DSP module’s wavetable and/or fast-math approximations, you can choose the accuracy with which the waveshaper and oscillator evaluate your C++ function.
- State of the art convolution
The Convolution class is a highly optimised convolution engine. The engine supports impulse responses from an audio buffer or any JUCE supported audio file format. Switching between impulse responses is handled transparently with internal cross-fading and thread synchronisation to avoid any audible artefacts.
- Optimised FFT
JUCE’s FFT has been revised to transparently use the fastest available FFT engine on your platform. For example, on iOS and macOS, JUCE will automatically use Apple’s vDSP framework, but it can also use Intel MKL’s or FFTW’s FFT engine. Only if JUCE cannot find an FFT engine, will it fallback to using the legacy implementation.
- SIMD optimisation
A new SIMDRegister type allows transparent use of your hardware’s SIMD registers regardless if your code is running on a neon, SSE2 or AVX2 CPU. The SIMDRegister type behaves like the corresponding primitive type and, as such, can often be used as a drop-in replacement for primitive variables. Most of the DSP module’s processors support SIMD processing out-of-the-box.
- All-in-one demo example
The DSP Demo app and plug-in will show you how to use many of the DSP module’s features including:
- The FIR, IIR and variable state filters
- Lookup tables
- Fast math approximations
- Convolution engine
- Chaining of processors
Audio & plug-ins features
- Multichannel audio
Multichannel audio file readers/writers: AudioFormatReader and AudioFormatWriter now support multi-channel, surround sound audio files.
- Scaling support for plugins
Added support for VST 2 and 3 extensions that allow a host to give a plugin the scale-factor that it should use for its UI. This will solve the problem of Windows high-DPI support for plugins in hosts which support this.
- Android device button support
JUCE now includes a callback that can be overridden to notify you when the user presses the 'back' button in your Android application - control the navigation flow in your applications by implementing the JUCEApplicationBase::backButtonPressed() method.
The process for locating modules inside the Projucer has been improved with a new global search path setting for JUCE and user-created modules. Simply point the Projucer to your modules directories and this path will be stored locally and used either as a fallback path when an exporter's path field is empty (1) or by default if you select the "Use global path" option in the settings page of an individual module (2) or the "Enable/disable global path for all modules..." button in the main module settings page (3).
The paths can be set via the "Global Search Paths..." menu item under either "Projucer" (Mac) or "File" (Windows and Linux):
The option to set the C++ language standard is now located in the project settings instead of the build configuration settings.
Possible issues: Projects that had a specific verison of the C++ language standard set for exporter build configurations will instead use the default (C++11) when re-saving with the new Projucer.
Workaround: Change the "C++ Language Standard" setting in the main project settings to the required version - the Projucer will add this value to the exported project as a compiler flag when saving exporters.
- Rationale: Having a different C++ language standard option for each build configuration was unnecessary and was not fully implemented for all exporters. Changing it to a per-project settings means that the preference will propagate to all exporters and only needs to be set in one place.
PopupMenus now scale according to the AffineTransform and scaling factor of their target components.
Possible Issues: Developers who have manually scaled their PopupMenus to fit the scaling factor of the parent UI will now have the scaling applied two times in a row.
1) Do not apply your own manual scaling to make your popups match the UI scaling - or -
2) Override the Look&Feel method PopupMenu::LookAndFeelMethods::shouldPopupMenuScaleWithTargetComponent and return false.
- Rationale: Previously, PopupMenus would not scale if the GUI of the target component (or any of it’s parents) were scaled. The only way to scale PopupMenus was via the global scaling factor. This had several drawbacks as the global scaling factor would scale everything. This was especially problematic in plug-in editors.
Removed the setSecurityFlags() method from the Windows implementation of WebInputStream as it disabled HTTPS security features.
Possible Issues: Any code previously relying on connections to insecure webpages succeeding will no longer work
Workaround: Check network connectivity on Windows and re-write any code that relied on insecure connections
- Rationale: The previous behaviour resulted in network connections on Windows having all the HTTPS security features disabled, exposing users to network attacks. HTTPS connections on Windows are now secure and will fail when connecting to an insecure web address
Pointer arithmetic on a pointer will have the same result regardless if it is wrapped in JUCE's Atomic class or not.
Possible Issues: Any code using pointer arithmetic on Atomic will now have a different result leading to undefined behaviour or crashes.
Workaround: Re-write your code in a way that it does not depend on your pointer being wrapped in JUCE's Atomic or not. See rationale.
- Rationale: Before this change, pointer arithmetic with JUCE's Atomic type would yield confusing results. For example, the following code would assert before this change:
int* a; Atomic b; jassert (++a == ++b);
Pointer a in the above code would be advanced by sizeof(int) whereas the JUCE's Atomic always advances it's underlying pointer by a single byte. The same is true for operator+=/operator-= and operator--. The difference in behaviour is confusing and unintuitive. Furthermore, this aligns JUCE's Atomic type with std::atomic.
Improved scaling support Android & Windows
Fixed various bugs involved in handling scale factors on high-DPI displays.
Projucer: default module search paths, file tree search, iOS app groups, project C++ language setting.
- Added Projucer support for iOS app groups
- Added support for AVFoundation and deprecated the use of Quicktime
- Added a new real-time audio thread priority for Android
- Various Projucer UI fixes
- Various documentation fixes
- For various minor improvements and bug fixes see the git log
System requirement changes