Using Hardware To Create Vst Plugins

Posted on

Enabling anyone with the requisite coding chops to create virtual effects and, a few years later, instruments for use as ’plugin’ modules within any compatible DAW, VST at last realised the dream of the entirely-software studio and kickstarted a whole new industry almost overnight. A VST plugin is a software-based audio effect or a virtual instrument intended for use in a host program that supports Virtual Studio Technology. Most digital audio workstations nowadays can load VST and VST3 plugins. VST plugins are used to expand a virtual music studio, much like how hardware effects and instruments are utilized in a real studio.

  1. Using Hardware To Create Vst Plugins Download
  2. Using Hardware To Create Vst Plugins Plugin
  3. Best Professional Vst Plugins
  4. Free Trap Vst Plugins
  5. What Is A Vst Plugin

Introduction

Microsoft announced that it would offer Visual Studio Express free of charge forever. Though the Express version of Visual C++ (hereafter referred to as VC++) has some limitations, it’s still a great tool and it’s nice to see Microsoft taking some steps to support the developers writing software for their platform. This document will describe how to get VC++ installed and building VST plugins. It assumes that you have prior experience developing VST plugins, and are familiar with the structure and layout of the VST SDK.

  1. VST chainer for Mac. Chainer by Plug & Mix is may one of choice for hosting VST and VST instrument without a DAW. Just like Chainer by XLutop. Is also run as a standalone and as a plugin for DAW. The difference, it’s mainly to load the Plug & Mix VIP plugins. But once you authorize the app (Buy it).
  2. Go to your VST plug-ins folder. Right click on each plugin you want and choose “Create shortcut” (multi-selection works too). Move these shortcuts to your new folder, and create sub-folders to organize them. You can now access plug-ins quickly using the shortcuts, inside the appropriate folders.
  3. A VST plugin is a software-based audio effect or a virtual instrument intended for use in a host program that supports Virtual Studio Technology. Most digital audio workstations nowadays can load VST and VST3 plugins. VST plugins are used to expand a virtual music studio, much like how hardware.

If you are trying to write VST’s in a language other than C++, than this guide is not for you. There are lots of other frameworks out there for developing VST plugins in other languages (such as C#, Java, Ruby and Python, just to name a few).

This tutorial will walk you through the process of installing and configuring the tools you’ll need to build your own VST plugins with Visual Studio, and creating a simple VST plugin with optional support for a VSTGUI frontend. This guide only covers building VST 2.x plugins, as the VST3 SDK is not very widely supported yet. Note that Steinberg’s website is a bit confusing and it is easy to accidentally download the wrong version of the SDK, so double-check to make sure that you have the 2.4 SDK.

Download required packages

  1. Steinberg’s VST SDK, which requires you to make a free Steinberg Developer account.
  2. Microsoft’s Visual C++. This guide uses the 2010 Express edition, as it was the latest version at time of writing.
  3. Libpng and zlib (optional)

Install Visual C++

If you already have a working installation of VC++, you can skip this step. Otherwise, download VC++ and install it. The standard installation should be OK, but you can choose to perform a custom installation if you don’t want documentation or other stuff installed with it. Before installing VC++, you must remove any other versions of VC++ on your computer.

Next, download and install the Platform SDK, which will provide you with the standard header files and libraries you’ll need to build software. You may choose to install VC++ anywhere on your hard drive, but the default location is C:Program FilesMicrosoft Visual Studio 10.0.

Creating your project

Create a new project of type “Class Library”, which we’ll call YourProjectName. In the rest of this tutorial, whenever you see YourProjectName, replace that text with the actual name of your project.

In Visual Studio 9, you’d make a new project with the wizard found at File -> New -> Project. Select Visual C++ -> Win32 Console Application, and choose a directory for your project. When the wizard opens, press “Next” and select DLL as the Application Type. Also check the “Empty Project” box.

If you prefer not to start with an empty project, then you can remove all of the files that VC++ creates for you, but keep the resource.h and YourProjectName.rc files, and remove any references to these files (such as YourProjectName.ico being listed in the resource file).

Add Source Code to the Project

If you already have source code for your plugin, simply add it to the project. Otherwise, you need to create the following files:

  • YourProjectName.cpp
  • YourProjectName.h
  • resource.h (Only needed if building a plugin GUI)
  • YourProjectName.rc (Only needed if building a plugin GUI)

You will also need to add the files from the VST SDK, which includes everything under the vstsdk2.4/public.sdk/source/vst2.x and vstsdk2.4/pluginterfaces/vst2.x directories. I usually prefer to manually make groups for these directories and drag the files to the groups from Explorer, as dragging the entire “vstsdk2.4” directory to VS can cause it to choke when it tries to add a bunch of unused files to the project.

To start out with, the plugin’s entry point header file (YourProjectName.h) should look something like this:

The accompanying class definition (YourProjectName.cpp) should look something like this:

Note that your project won’t compile just yet, but be patient!

The above code samples are simply blank entry points which don’t do anything exciting. The VST SDK offers lots of methods which you can override in order to do things like setting parameters, receiving MIDI messages, and so on. These things are beyond the scope of this tutorial; if you don’t know what code to put inside of processReplacing, try checking out the “again” example distributed within the VST SDK in the public.sdk/samples/vst2.x/again folder.

You must also create a module definition file for your project, named YourProjectName.def. Usually this file is placed in the same directory as the VC++ project file, but you may place it somewhere else so long as this definition matches the Module Definition File settings in the Linker section of the project preferences. This is just a plain-text file which should contain the following text:

Configure build settings

Go to the project settings either by right clicking on the project in the solution explorer and then selecting “Properties”. Make the following changes to the project for all build configurations:

  • General
    • Character Set: Not Set
    • Common Language Runtime Support: No Common Language Runtime Support
  • C/C++
    • General:
      • Additional Include Directories:
        1. (or wherever you put the VST SDK)
        2. Your source code directory
        3. Any other directories which you may have header files stored in Global SDK directories, such as
    • Preprocessor:
      • Preprocessor Definitions:
      • For Debug builds you may also wish to add
      • If you wish to use PNG graphics for a VSTGUI frontend, add
      • To avoid lots of compiler nags and warnings, define
      • In some cases, you may also need to define
    • Code Generation:
      • Runtime Library: Multi-threaded. Multi-threaded debug may be used for debug builds. This will build the VC++ common runtime library statically into your plugin, increasing its size by approximately 200Kb. If you choose to use the CRL as a dynamic library, then you must also distribute a copy of the CRL with your application, which complicates deployment and distribution.
    • Precompiled Headers:
      • Precompiled Header: Not Using Precompiled Headers. Yeah, this makes rebuilding a bit slower, but will avoid a bunch of weird errors as you are getting your project set up. Once you get the project building you can revisit this step.
  • Linker
    • General:
      • Additional Library Directories: Add any other library directories which your project depends on.
    • Input:
      • Additional Dependencies (for Release builds):
        • libcmt.lib
        • uuid.lib
        • shell32.lib
        • ole32.lib
        • gdi32.lib
        • User32.lib
        • advapi32.lib
        • zlib.lib (only if you are building with a GUI)
        • libpng.lib (only if you are building with a GUI)
      • Additional Dependencies (for Debug builds):
        • shell32.lib
        • msvcrtd.lib
        • ole32.lib
        • gdi32.lib
        • User32.lib
        • advapi32.lib
        • zlib.lib (only if you are building with a GUI)
        • libpng.lib (only if you are building with a GUI)
      • Ignore Specific Default Library (for Release builds):
        • msvcrt.lib
        • libc.lib
        • msvcrtd.lib
        • libcd.lib
        • libcmtd.lib
      • Ignore Specific Default Library (for Debug builds):
        • libcmt.lib
        • libcmtd.lib
        • msvcrt.lib
      • Module Definition File: YourProjectName.def

Adding support for VSTGUI (optional)

Include VSTGUI support in your plugin, simply add the VSTGUI files into your project in addition to your own editor class. At a very minimum, these are:

  • aeffguieditor.cpp
  • vstcontrols.cpp
  • vstgui.cpp

Adding support for PNG graphics (optional)

If you would like to use PNG’s in your plugin instead of BMP graphics, you will need to also build your own version of libpng and zlib. Download the source code for both libraries from the links given in the “Requirements” section of the document and place them in the same directory. There is a Visual Studio project for libpng which will also build zlib for you; it is located in the projectsvisualc71 directory. In order to get the projects to build correctly, you’ll need to rename the source code directories to simply “libpng” and “zlib”, removing the version numbers from the directory name.

When you open the project up, VC++ will run you through the project conversion wizard. Convert the project, and change the “Runtime Library” settings in both libpng and zlib to be Multi-Threaded, as described above. Unless this step is performed, the dependency on the CLR will be present in your project. Next, choose the LIB ASM Release or LIB Release build style and build the project; if you build the libraries as DLL’s, you will be unable to statically link them into your plugin. The project should build ok, but throw a few errors when attempting to run the pngtest files. You can ignore these problems, as the libraries will still be correctly compiled and can now be linked to your project.

Visual Studio doesn’t need to have the libraries within your actual project. Instead, place the libraries in a directory of your choosing and be sure to add this path to the list of “Additional Library Directories” in the Linker preferences for your project. You may choose to place the libraries in the same directory as the Microsoft Platform SDK stuff, but I personally prefer to keep them in a separate directory checked into version control. Also be sure to add references to libpng.lib and zlib.lib for your project in the “Additional Dependencies” section of your Linker preferences for the project.

The path must be relative to the location of the project file. Then, in resource.h, add the following preprocessor definitions:

Now you can use IDB_BITMAP1 (or any other name of your choosing) in your code when creating new CBitmap objects.

I have heard some reports of vstgui.cpp not compiling properly due to the missing symbol png_set_expand_gray_1_2_4_to_8. Changing png_set_gray_1_2_4_to_8 to png_set_expand_gray_1_2_4_to_8 in vstgui.cpp seems to fix this issue.

Final considerations

VC++ ships with an optimizing compiler, but sometimes the compiler will choke on certain files and optimization must be disabled. In particular, I have experienced this with Laurent de Soras’ FFTReal libraries, since they are written as template classes. In general, however, optimization is a good idea, as is “Eliminating Unreferenced Data” (in the linker settings). The “Whole Program Optimization” setting appears tempting, but usually results in dozens of build errors and problems, so it’s best to avoid this. Also, be sure to use the optimization features of this compiler and linker, as they can greatly boost runtime performance.

If you are developing on a multi-core machine, then you might need to disable parallel builds by setting the number of parallel builds to 1 under Tools -> Options -> Projects and Solutions -> Build and Run. In past verisons of VS, I noticed that the compiler does not always link projects in the order one would expect, which caused odd errors during linking about missing symbols. However, VS2010 users probably shouldn’t need worry about this setting.

Unresolved symbols when linking

Using Hardware To Create Vst Plugins Download

Sometimes you may see errors like the following:

If you are getting errors in your build about missing symbols, make sure that you double- and triple-check the debug and release configurations for the library configuration above, since some of the libraries which are used in one build style are specifically excluded from the other. Also, when you close and re-open the project’s build properties, VS always “forgets” the last selected build style, so remember to check and set this appropriately.

Also, you should check to make sure that the Platform SDK was correctly installed on your system and that your project’s include and library paths are pointing to these directories.

Unresolved external symbols

If you are seeing errors like this:

Then this most likely means that the file which contains the given symbol is not correctly added to the VC++ solution.

Linking errors with symbols defined multiple times

This is undoubtedly one of the most frustrating problems which can occur when building a VST in VC++. If you are seeing error messages like this, then it most likely means there is some problem with your library configuration:

Most likely, the libcmt and msvcrt libraries are being included incorrectly in your build. Double-check the library list above, keeping in mind that the recommended configuration uses libcmt for release builds only, and msvcrtd for debug builds only.

VST was developed by Steinberg Media Technologies in 1996. It creates a complete, professional studio environment on the PC or Mac.[1]

Virtual Studio Technology (VST) is an audio plug-in software interface that integrates software synthesizers and effects units into digital audio workstations. VST and similar technologies use digital signal processing to simulate traditional recording studio hardware in software. Thousands of plugins exist, both commercial and freeware, and many audio applications support VST under license from its creator, Steinberg.

Overview[edit]

VST plugins generally run within a digital audio workstation (DAW), to provide additional functionality, though a few standalone plugin hosts exist which support VST. Most VST plugins are either instruments (VSTi) or effects (VSTfx), although other categories exist—for example spectrum analyzers and various meters. VST plugins usually provide a custom graphical user interface that displays controls similar to physical switches and knobs on audio hardware. Some (often older) plugins rely on the host application for their user interface.

VST instruments include software simulation emulations of well-known hardware synthesizers and samplers. These typically emulate the look of the original equipment as well as its sonic characteristics. This lets musicians and recording engineers use virtual versions of devices that otherwise might be difficult and expensive to obtain.

VST instruments receive notes as digital information via MIDI, and output digital audio. Effect plugins receive digital audio and process it through to their outputs. (Some effect plugins also accept MIDI input—for example, MIDI sync to modulate the effect in sync with the tempo). MIDI messages can control both instrument and effect plugin parameters. Most host applications can route the audio output from one VST to the audio input of another VST (chaining). For example, the output of a VST synthesizer can be sent through a VST reverb effect.

History[edit]

Steinberg released the VST interface specification and SDK in 1996. They released it at the same time as Steinberg Cubase 3.02, which included the first VST format plugins: Espacial (a reverb), Choirus (a chorus effect), Stereo Echo, and Auto-Panner.[2]

Steinberg updated the VST interface specification to version 2.0 in 1999. One addition was the ability for plugins to receive MIDI data. This supported the introduction of Virtual Studio Technology Instrument (VSTi) format plugins. VST Instruments can act as standalone software synthesizers, samplers, or drum machines.[3]

Neon[4] was the first available VST Instrument (included with Cubase VST 3.7). It was a 16-voice, 2-oscillator virtual analog synthesizer.[3]

In 2006, the VST interface specification was updated to version 2.4. Changes included the ability to process audio with 64-bit precision.[5] A free-software replacement was developed for LMMS that would be used later by other free-software projects.[6][7]

VST 3.0 came out in 2008. Changes included:[8]

  • Audio Inputs for VST Instruments
  • Multiple MIDI inputs/outputs
  • Optional SKI (Steinberg Kernel Interface) integration

VST 3.5 came out in February 2011. Changes included note expression, which provides extensive articulation information in individual note events in a polyphonic arrangement. According to Steinberg, this supports performance flexibility and a more natural playing feel.[9]

In October 2011, Celemony Software and PreSonus released Audio Random Access (ARA), an extension for audio plug-in interfaces, such as VST, allowing greater integration between audio plug-ins and DAW software.[10]

Trap

In September, 2013, Steinberg discontinued maintenance of the VST 2 SDK. In December, Steinberg stopped distributing the SDK.[11] The higher versions are continued.

VST 3.6.7 came out in March, 2017. It includes a preview version of VST3 for Linux platform, the VST3 part of the SDK gets a dual license: 'Proprietary Steinberg VST3' or the 'Open-source GPLv3'.

As VSTi virtual instrument technology was under development at Steinberg, a platform for virtual instruments using DirectX engine technology was being developed by Cakewalk, famous for its Sonar DAW. However, the format did not gain much acceptance beyond instruments bundled with SONAR. Currently, almost all virtual instruments on the market use Steinberg's VSTi format.[citation needed]

VST plugins[edit]

There are three types of VST plugins:

  • VST instruments generate audio. They are generally either Virtual Synthesizers or Virtual samplers. Many recreate the look and sound of famous hardware synthesizers. Better known VST instruments include Discovery, Nexus, Sylenth1, Massive, Omnisphere, FM8, Absynth, Reaktor, Gladiator, Serum and Vanguard.
  • VST effects process rather than generate audio—and perform the same functions as hardware audio processors such as reverbs and phasers. Other monitoring effects provide visual feedback of the input signal without processing the audio. Most hosts allow multiple effects to be chained. Audio monitoring devices such as spectrum analyzers and meters represent audio characteristics (frequency distribution, amplitude, etc.) visually.
  • VST MIDI effects process MIDI messages (for example, transpose or arpeggiate) and route the MIDI data to other VST instruments or to hardware devices.

VST hosts[edit]

A VST host is a software application or hardware device that VST plugins run under. The host application presents the plugin UIs and routes digital audio and MIDI to and from the plugins.

Software[edit]

Many VST hosts are available. Not all of these support VST 3 plugins.

  • Acon Digital Acoustica
  • Acoustica Mixcraft (VST3)
  • Ardour (open source)
  • Audacity (free and open source, VST support works on Windows, Mac OS X and Linux[12])
  • Digital Performer (version 8 or higher)
  • Psycle (open source)
  • Reason (version 9.5 or higher)
  • vMix (VST3 Only)

Stand-alone dedicated hosts provide a host environment for VST plugins rather than use the plugins to extend their own capabilities. These are usually optimized for live performance use, with features like fast song configuration switching.

VST plugins can be hosted in incompatible environments using a translation layer, or shim. For example, FL Studio only supports its own internal plugin architecture, but an available native 'wrapper' loads VST plugins, among others. FXpansion offers a VST-to-RTAS (Real Time AudioSuite) wrapper that lets VST plugins run in Pro Tools, and a VST-to-Audio Units wrapper lets VST plugins run in Logic Pro.

Hardware[edit]

Using Hardware To Create Vst Plugins Plugin

Hardware VST hosts can load special versions of VST plugins. These units are portable and usable without a computer, though some of them require a computer for editing. Other hardware options include PCI/PCIe cards designed for audio processing, which take over audio processing from the computer's CPU and free up RAM.

Some hardware hosts accept VSTs and VSTis, and either run Windows-compatible music applications like Cubase, Live, Pro Tools, Logic etc., or run their own DAW. Other are VST Hosts only and require a separate DAW application. Origin from Arturia is a hardware DSP system that houses several VST software synthesizers in one machine, like Jupiter 50/80 from Roland. Using appropriate software, audio data can also be sent over a network, so the main host runs on one computer, and VST plugins on peripheral machines.

Standard[edit]

The VST plugin standard is the audio plugin standard created by Steinberg to allow any third-party developers to create VST plugins for use within VST host applications. VST requires separate installations for Windows, Mac OS X and Linux. The majority of VST plugins are available for Windows only due to Apple's competing proprietary Audio Unit technology being used on OS X (Audio Units is a core part of the OS X operating system). The short history of commercial environments for Linux means few developers have targeted this platform.

Presets[edit]

VST plugins often have many controls, and therefore need a method of managing presets (sets of control settings).

Steinberg Cubase VST introduced two file formats for storing presets: an FXP file stores a single preset, while an FXB file stores a whole bank of presets. These formats have since been adopted by many other VST hosts, although Cubase itself switched to a new system of preset management with Cubase 4.0.

Many VST plugins have their own method of loading and saving presets, which do not necessarily use the standard FXP/FXB formats.

Best Professional Vst Plugins

Competing technologies[edit]

  • Apple's Audio Units
  • Avid's Avid Audio eXtension
  • Digidesign's Real Time AudioSuite
  • Digidesign's TDM
  • LADSPA, DSSI for Linux
  • LV2, a cross-platform, open source, liberally licensed audio plugin standard
  • Microsoft's DirectX plugin
  • Mark of the Unicorn's Motu Audio System
  • JACK Audio Connection Kit, an open-source sound server allowing flexible audio routing between apps
  • Reason Studios' Rack Extensions

Programming languages[edit]

Steinberg's VST SDK is a set of C++ classes based around an underlying C API. The SDK can be downloaded from their website.

There are several ports available, such as a Delphi version by Frederic Vanmol,[13] a Java version from the jVSTwRapper project at Sourceforge,[14] and two .NET versions – Noise[15] and VST.NET;[16] this open source project also includes a framework that makes creating VST plugins easier and result in more structured code. VST.NET also provides support for writing managed host applications with a managed class that allows loading an unmanaged Plugin. A notable language supporting VST is FAUST, considering that it is especially made for making signal processing plugins, often producing code faster than hand-written C++.

In addition, Steinberg has developed the VST GUI, which is another set of C++ classes, which can be used to build a graphical interface. There are classes for buttons, sliders and displays, etc. Note that these are low-level C++ classes and the look and feel still have to be created by the plugin manufacturer. VST GUI is part of the VST SDK and is also available as a SourceForge project.[17]

Many commercial and open-source VSTs are written using the Juce C++ framework instead of direct calls to the VST SDK because this allows multi-format (VST, Audio Units and Real Time AudioSuite) binaries to be built from a single codebase.

See also[edit]

  • LADSPA and LV2, similar open-source standards.
  • SynthEdit, a VST/VSTi editor.

References[edit]

Free Trap Vst Plugins

  1. ^'Our Technologies'. www.steinberg.net.
  2. ^Steinberg Cubase 3 (article), Sound on sound, Jul 1996.
  3. ^ abCubase 3.7 (article), Sound on sound, Sep 1999
  4. ^KVR audio.
  5. ^Steinberg.
  6. ^'vestige.h'.
  7. ^'aeffectx.h'.
  8. ^News, KVR audio.
  9. ^VST 3.5 a milestone in VST development (News), Steinberg, 2011-02-10.
  10. ^'Celemony introduces ARA Audio Random Access - Extension for Plug-in Interfaces'. KVR Audio. Retrieved 2018-06-05.
  11. ^SDK for VST 2 software interface discontinued (News), Steinberg, 2013-12-09
  12. ^VST plug-ins
  13. ^VST, Axi world.
  14. ^jVSTwRapper, Source forge.
  15. ^Noise, Google code.
  16. ^VST.Net, Codeplex.
  17. ^http://sourceforge.net/projects/vstgui

What Is A Vst Plugin

Retrieved from 'https://en.wikipedia.org/w/index.php?title=Virtual_Studio_Technology&oldid=989584235'