Introduction

REAPER supports VST plug-ins (up to version 2.4). VST is a standard defined by Steinberg Media Technologies GMBH. To get the VST SDK (which you will need to implement VST plug-ins), you will need to download it from Steinberg, as we cannot distribute it.

It is worthwhile noting that while VST is a standard, it is neither an open standard (the fact that you cannot easily distribute the SDK or things derived from it), nor is it a well defined standard.

This document will describe some REAPER-specific implementation notes for VST, as well as list some REAPER-specific VST extensions that plug-in developers are encouraged to use to acheive great integration with REAPER. Additionally, we encourage other VST host developers to add support for these extensions, as we believe they are useful.

• Audio/sample processing: REAPER will use processDoubleReplacing if effFlagsCanDoubleReplacing is set in the flags.
  REAPER will use processReplacing if effFlagsCanReplacing is set and processReplacing != process (if it equals it assumes that it is a faulty implementation of processReplacing). Additionally there is an option in the preferences to not use processReplacing for buggy plug-ins. Note that for plug-ins that have Cockos extensions (see below), the option (to not use processReplacing) is ignored, allowing known-good plug-ins to always run at full speed.
  
  
• Threading/concurrency: Since audio processing can run in other threads from the UI, it's important to note what can run at the same time. REAPER is highly optimized to prevent UI and other actions from interrupting audio, so assume everything can (and WILL) run at the same time as your process/processReplacing, except:
  • effOpen/effClose
  • effSetChunk -- while effGetChunk can run at the same time as audio (user saves project, or for automatic undo state tracking), effSetChunk is guaranteed to not run while audio is processing.
  So nearly _everything_ else should be threadsafe. For many things this doesn't mean having to do much, but there are plenty of plug-ins that barf when audio is running and you open the window (using effEditOpen). There is an option to bypass audio while opening the config window, but it sucks and shouldn't be required.
  
  
• Dynamic parameters: REAPER can deal with the number of parameters for a plug-in changing on the fly. We will soon implement APIs so that plug-ins can notify REAPER of parameter count changes (i.e. parameter X deleted, or new parameter Y), to preserve automation of higher indexed parameters when adding/removing lower parameters.
  
  
• Multiple inputs/outputs: REAPER allows the user to dynamically connect input/output pins of VSTs wherever they want, so enable as much I/O as you need. REAPER also allows input/output counts to change, HOWEVER it is recommended that any changes you make be done from within processReplacing() or process(), and use the old value of numInputs/numOutputs until the next call. Additionally the initial value of numInputs/numOutputs should be set to the most common settings.
  
  
• Longer labels: effGetParamName/effGetParamLabel/effGetParamDisplay all support up to 256 character strings (255+null).
  
  
• More coming soon.
  
  

  case effCanDo:
    if (ptr && !strcmp((char *)ptr,"hasCockosExtensions")) return 0xbeef0000;

  void (*someFunction)();
  *(long *)&someFunction = hostcb(NULL,0xdeadbeef,0xdeadf00d,0,"someFunction",0.0);

• GetPlayPosition()

     double (*GetPlayPosition)();
  

  GetPlayPosition() returns the current playback position of the project. This is the time the user is hearing (and the transport shows etc). The value is in seconds.
  
  
• GetPlayPosition2()

     double (*GetPlayPosition2)();
  

  GetPlayPosition() returns the current playback decode position of the project. This is the time of the audio block that is being processed by the host. The value is in seconds. This may be behind where your plug-in is processing, due to anticipative processing and/or PDC.
  
  
• GetCursorPosition()

    double (*GetCursorPosition)();
  

  GetCursorPosition() returns the current edit cursor position (if any), in seconds.
  
  
• GetPlayState()

    int (*GetPlayState)(); 
  

  GetPlayState() returns an integer value representing the project play state. 1=play, 2=paused, 5=recording, 6=record paused.
  
  
• SetEditCurPos()

    void (*SetEditCurPos)(double time, bool moveview, bool seekplay);
  

  SetEditCurPos() repositions the edit cursor to "time" (in seconds), optionally moving the view if necessary, and optionally seeking playback (if playing back). This function should ONLY be called from a UI context (i.e. from the editor window, NOT from audio processing etc).
  
  
• GetSetRepeat()

    int (*GetSetRepeat)(int parm);
  

  GetSetRepeat() is used to change or query the transport "loop/repeat" state. Pass a parameter of -1 to query the repeat state, 0 to clear, 1 to set, and >1 to toggle. The return value is the new value of the repeat state. ONLY use this function to change the repeat state from the UI thread (however you can query safely at any time).
  
  
• GetProjectPath()

    void (*GetProjectPath)(char *buf, int bufsz);
  

  GetProjectPath() can be used to query the path that media files are stored in for the current project.
  
  
• OnPlayButton(), OnPauseButton(), OnStopButton()

    void (*OnPlayButton)();
    void (*OnStopButton)();
    void (*OnPauseButton)();
  

  These functions control the main transport for the host app. Only call these from the UI thread.
  
  
• IsInRealTimeAudio()

    int (*IsInRealTimeAudio)();
  

  Returns nonzero if in the main audio thread, or in a thread doing synchronous multiprocessing. In these instances low latency is key. If this is 0, and you are in processReplacing, then you are being called in an anticipative processing thread.
  
• Audio_IsRunning()

    int (*Audio_IsRunning)();
  

  Returns nonzero if the audio device is open and running.
  
  
• Additional API functions are listed in the REAPER Extension Plug-in SDK.