NOTE: this file may not the latest version of this documentation

ReaScript API

Generated by REAPER v7.08


REAPER provides an API (advanced programming interface) for users and third parties to create extended functionality. API functions can be called from a compiled C/C++ dynamic library that is loaded by REAPER, or at run-time by user-created ReaScripts that can be written using REAPER's own editor.

ReaScripts can be written in EEL2, a specialized language that is also used to write JSFX and video effect processors in REAPER; Lua, a popular scripting language; or Python, a widely-used programming language. EEL2 and Lua are embedded within REAPER and require no additional downloads or settings, and provide the most REAPER-specific features. Python must be downloaded and installed separately, and enabled in REAPER preferences. Because Python is harder to integrate with REAPER, some UI features are not available when using Python.

Learn more about ReaScript: http://www.cockos.com/reaper/sdk/reascript/reascript.php.

View: [all] [C/C++] [EEL2] [Lua] [Python]


ReaScript/EEL2 API

For information on the EEL2 language, please see the EEL2 User Guide

ReaScript/EEL2 scripts can call API functions using functionname().

Parameters that return information are effectively passed by reference, not value.

Examples:
// function returning a single (scalar) value:
sec = parse_timestr("1:12");

// function returning information in the first parameter (function returns void):
GetProjectPath(#string);

// lower volume of track 3 by half:
tr = GetTrack(0, 2);
GetTrackUIVolPan(tr, vol, pan);
SetMediaTrackInfo_Value(tr, "D_VOL", vol*0.5);

ReaScript/EEL2 can import functions from other reascripts using @import filename.eel -- note that only the file's functions will be imported, normal code in that file will not be executed.

In addition to the standard API functions, Reascript/EEL2 also has these built-in functions available:

abs     floor     gfx_getdropfile     gfx_setpixel     rand     strcpy_substr    
acos     fopen     gfx_getfont     gfx_showmenu     runloop     stricmp    
asin     fprintf     gfx_getimgdim     gfx_transformblit     set_action_options     strlen    
atan     fread     gfx_getpixel     gfx_triangle     sign     strncat    
atan2     freembuf     gfx_gradrect     gfx_update     sin     strncmp    
atexit     fseek     gfx_init     ifft     sleep     strncpy    
ceil     ftell     gfx_line     ifft_real     sprintf     strnicmp    
convolve_c     fwrite     gfx_lineto     invsqrt     sqr     tan    
cos     get_action_context     gfx_loadimg     log     sqrt     tcp_close    
defer     gfx VARIABLES     gfx_measurechar     log10     stack_exch     tcp_connect    
eval     gfx_arc     gfx_measurestr     loop     stack_peek     tcp_listen    
exp     gfx_blit     gfx_muladdrect     match     stack_pop     tcp_listen_end    
extension_api     gfx_blitext     gfx_printf     matchi     stack_push     tcp_recv    
fclose     gfx_blurto     gfx_quit     max     str_delsub     tcp_send    
feof     gfx_circle     gfx_rect     mem_get_values     str_getchar     tcp_set_block    
fflush     gfx_clienttoscreen     gfx_rectto     mem_insert_shuffle     str_insert     time    
fft     gfx_deltablit     gfx_roundrect     mem_multiply_sum     str_setchar     time_precise    
fft_ipermute     gfx_dock     gfx_screentoclient     mem_set_values     str_setlen     while    
fft_permute     gfx_drawchar     gfx_set     memcpy     strcat    
fft_real     gfx_drawnumber     gfx_setcursor     memset     strcmp    
fgetc     gfx_drawstr     gfx_setfont     min     strcpy    
fgets     gfx_getchar     gfx_setimgdim     printf     strcpy_from    


ReaScript/Lua API

ReaScript/Lua scripts can call API functions using reaper.functionname().

Some functions return multiple values. In many cases, some function parameters are ignored, especially when similarly named parameters are present in the returned values.

Examples:
-- function returning a single (scalar) value:
sec = reaper.parse_timestr("1:12")

-- function with an ignored (dummy) parameter:
path = reaper.GetProjectPath("")

-- lower volume of track 3 by half:
tr = reaper.GetTrack(0, 2)
ok, vol, pan = reaper.GetTrackUIVolPan(tr, 0, 0)
reaper.SetMediaTrackInfo_Value(tr, "D_VOL", vol*0.5)

ReaScript/Lua can import functions from other ReaScripts using require. If the files are not being found, it is probably a path problem (remember that lua paths are wildcard patterns, not just directory listings, see details here).

In addition to the standard API functions, Reascript/Lua also has these built-in functions available:

atexit     gfx.deltablit     gfx.gradrect     gfx.rect     gfx.transformblit     {reaper.array}.convolve    
defer     gfx.dock     gfx.init     gfx.rectto     gfx.triangle     {reaper.array}.copy    
get_action_context     gfx.drawchar     gfx.line     gfx.roundrect     gfx.update     {reaper.array}.fft    
gfx VARIABLES     gfx.drawnumber     gfx.lineto     gfx.screentoclient     gmem_attach     {reaper.array}.fft_real    
gfx.arc     gfx.drawstr     gfx.loadimg     gfx.set     gmem_read     {reaper.array}.get_alloc    
gfx.blit     gfx.getchar     gfx.measurechar     gfx.setcursor     gmem_write     {reaper.array}.ifft    
gfx.blitext     gfx.getdropfile     gfx.measurestr     gfx.setfont     new_array     {reaper.array}.ifft_real    
gfx.blurto     gfx.getfont     gfx.muladdrect     gfx.setimgdim     runloop     {reaper.array}.multiply    
gfx.circle     gfx.getimgdim     gfx.printf     gfx.setpixel     set_action_options     {reaper.array}.resize    
gfx.clienttoscreen     gfx.getpixel     gfx.quit     gfx.showmenu     {reaper.array}.clear     {reaper.array}.table    


ReaScript/Python API

ReaScript/Python is currently disabled in REAPER user preferences. ReaScript/EEL2 and ReaScript/Lua are always supported.


ReaScript/Python requires a recent version of Python installed on this machine. Python is available from multiple sources as a free download. Python 2.7 is normally included with macOS, and the dynamic library is usually in /usr/lib. If you update to a newer version of Python, it will be installed to a different directory. After installing Python, REAPER may detect the Python dynamic library automatically. If not, you can enter the path in the ReaScript preferences page, at Options/Preferences/Plug-Ins/ReaScript.

ReaScript/Python scripts can call API functions using RPR_functionname().

All parameters are passed by value, not reference. API functions that cannot return information in the parameter list will return a single value. API functions that can return any information in the parameter list will return a list of values; The first value in the list will be the function return value (unless the function is declared to return void).

Examples:
# function returning a single (scalar) value:
sec = RPR_parse_timestr("1:12")

# function returning information in the first parameter (function returns void):
(str) = RPR_GetProjectPath("", 512)

# lower volume of track 3 by half (RPR_GetTrackUIVolPan returns Bool):
tr = RPR_GetTrack(0, 2)
(ok, tr, vol, pan) = RPR_GetTrackUIVolPan(tr, 0, 0)
# this also works, if you only care about one of the returned values:
vol = RPR_GetTrackUIVolPan(tr, 0, 0)[2]
RPR_SetMediaTrackInfo_Value(tr, "D_VOL", vol*0.5)

You can create and save modules of useful functions that you can import into other ReaScripts. For example, if you create a file called reascript_utility.py that contains the function helpful_function(), you can import that file into any Python ReaScript with the line:
import reascript_utility
and call the function by using:
reascript_utility.helpful_function()

Note that ReaScripts must explicitly import the REAPER python module, even if the script is imported into another ReaScript:
from reaper_python import *

In addition to the standard API functions, Reascript/Python also has these built-in functions available:

atexit     defer     runloop    


API Function List

AddMediaItemToTrack     GetEnvelopePointEx     InsertMedia     SetTakeStretchMarkerSlope    
AddProjectMarker     GetEnvelopeScalingMode     InsertMediaSection     SetTempoTimeSigMarker    
AddProjectMarker2     GetEnvelopeStateChunk     InsertTrackAtIndex     SetThemeColor    
AddRemoveReaScript     GetEnvelopeUIState     IsMediaExtension     SetToggleCommandState    
AddTakeToMediaItem     GetExePath     IsMediaItemSelected     SetTrackAutomationMode    
AddTempoTimeSigMarker     GetExtState     IsProjectDirty     SetTrackColor    
adjustZoom     GetFocusedFX     IsTrackSelected     SetTrackMIDILyrics    
AnyTrackSolo     GetFocusedFX2     IsTrackVisible     SetTrackMIDINoteName    
APIExists     GetFreeDiskSpaceForRecordPath     joystick_create     SetTrackMIDINoteNameEx    
APITest     GetFXEnvelope     joystick_destroy     SetTrackSelected    
ApplyNudge     GetGlobalAutomationOverride     joystick_enum     SetTrackSendInfo_Value    
ArmCommand     GetHZoomLevel     joystick_getaxis     SetTrackSendUIPan    
Audio_Init     GetInputActivityLevel     joystick_getbuttonmask     SetTrackSendUIVol    
Audio_IsPreBuffer     GetInputChannelName     joystick_getinfo     SetTrackStateChunk    
Audio_IsRunning     GetInputOutputLatency     joystick_getpov     SetTrackUIInputMonitor    
Audio_Quit     GetItemEditingTime2     joystick_update     SetTrackUIMute    
AudioAccessorStateChanged     GetItemFromPoint     kbd_enumerateActions     SetTrackUIPan    
AudioAccessorUpdate     GetItemProjectContext     kbd_getTextFromCmd     SetTrackUIPolarity    
AudioAccessorValidateState     GetItemStateChunk     LICE_ClipLine     SetTrackUIRecArm    
BypassFxAllTracks     GetLastColorThemeFile     LocalizeString     SetTrackUISolo    
CalcMediaSrcLoudness     GetLastMarkerAndCurRegion     Loop_OnArrow     SetTrackUIVolume    
CalculateNormalization     GetLastTouchedFX     Main_OnCommand     SetTrackUIWidth    
ClearAllRecArmed     GetLastTouchedTrack     Main_OnCommandEx     ShowActionList    
ClearConsole     GetMainHwnd     Main_openProject     ShowConsoleMsg    
ClearPeakCache     GetMasterMuteSoloFlags     Main_SaveProject     ShowMessageBox    
ColorFromNative     GetMasterTrack     Main_SaveProjectEx     ShowPopupMenu    
ColorToNative     GetMasterTrackVisibility     Main_UpdateLoopInfo     SLIDER2DB    
CountActionShortcuts     GetMaxMidiInputs     MarkProjectDirty     SnapToGrid    
CountAutomationItems     GetMaxMidiOutputs     MarkTrackItemsDirty     SoloAllTracks    
CountEnvelopePoints     GetMediaFileMetadata     Master_GetPlayRate     Splash_GetWnd    
CountEnvelopePointsEx     GetMediaItem     Master_GetPlayRateAtTime     SplitMediaItem    
CountMediaItems     GetMediaItem_Track     Master_GetTempo     stringToGuid    
CountProjectMarkers     GetMediaItemInfo_Value     Master_NormalizePlayRate     StuffMIDIMessage    
CountSelectedMediaItems     GetMediaItemNumTakes     Master_NormalizeTempo     TakeFX_AddByName    
CountSelectedTracks     GetMediaItemTake     MB     TakeFX_CopyToTake    
CountSelectedTracks2     GetMediaItemTake_Item     MediaItemDescendsFromTrack     TakeFX_CopyToTrack    
CountTakeEnvelopes     GetMediaItemTake_Peaks     MIDI_CountEvts     TakeFX_Delete    
CountTakes     GetMediaItemTake_Source     MIDI_DeleteCC     TakeFX_EndParamEdit    
CountTCPFXParms     GetMediaItemTake_Track     MIDI_DeleteEvt     TakeFX_FormatParamValue    
CountTempoTimeSigMarkers     GetMediaItemTakeByGUID     MIDI_DeleteNote     TakeFX_FormatParamValueNormalized    
CountTrackEnvelopes     GetMediaItemTakeInfo_Value     MIDI_DeleteTextSysexEvt     TakeFX_GetChainVisible    
CountTrackMediaItems     GetMediaItemTrack     MIDI_DisableSort     TakeFX_GetCount    
CountTracks     GetMediaSourceFileName     MIDI_EnumSelCC     TakeFX_GetEnabled    
CreateNewMIDIItemInProj     GetMediaSourceLength     MIDI_EnumSelEvts     TakeFX_GetEnvelope    
CreateTakeAudioAccessor     GetMediaSourceNumChannels     MIDI_EnumSelNotes     TakeFX_GetFloatingWindow    
CreateTrackAudioAccessor     GetMediaSourceParent     MIDI_EnumSelTextSysexEvts     TakeFX_GetFormattedParamValue    
CreateTrackSend     GetMediaSourceSampleRate     MIDI_GetAllEvts     TakeFX_GetFXGUID    
CSurf_FlushUndo     GetMediaSourceType     MIDI_GetCC     TakeFX_GetFXName    
CSurf_GetTouchState     GetMediaTrackInfo_Value     MIDI_GetCCShape     TakeFX_GetIOSize    
CSurf_GoEnd     GetMIDIInputName     MIDI_GetEvt     TakeFX_GetNamedConfigParm    
CSurf_GoStart     GetMIDIOutputName     MIDI_GetGrid     TakeFX_GetNumParams    
CSurf_NumTracks     GetMixerScroll     MIDI_GetHash     TakeFX_GetOffline    
CSurf_OnArrow     GetMouseModifier     MIDI_GetNote     TakeFX_GetOpen    
CSurf_OnFwd     GetMousePosition     MIDI_GetPPQPos_EndOfMeasure     TakeFX_GetParam    
CSurf_OnFXChange     GetNumAudioInputs     MIDI_GetPPQPos_StartOfMeasure     TakeFX_GetParameterStepSizes    
CSurf_OnInputMonitorChange     GetNumAudioOutputs     MIDI_GetPPQPosFromProjQN     TakeFX_GetParamEx    
CSurf_OnInputMonitorChangeEx     GetNumMIDIInputs     MIDI_GetPPQPosFromProjTime     TakeFX_GetParamFromIdent    
CSurf_OnMuteChange     GetNumMIDIOutputs     MIDI_GetProjQNFromPPQPos     TakeFX_GetParamIdent    
CSurf_OnMuteChangeEx     GetNumTakeMarkers     MIDI_GetProjTimeFromPPQPos     TakeFX_GetParamName    
CSurf_OnPanChange     GetNumTracks     MIDI_GetRecentInputEvent     TakeFX_GetParamNormalized    
CSurf_OnPanChangeEx     GetOS     MIDI_GetScale     TakeFX_GetPinMappings    
CSurf_OnPause     GetOutputChannelName     MIDI_GetTextSysexEvt     TakeFX_GetPreset    
CSurf_OnPlay     GetOutputLatency     MIDI_GetTrackHash     TakeFX_GetPresetIndex    
CSurf_OnPlayRateChange     GetParentTrack     midi_init     TakeFX_GetUserPresetFilename    
CSurf_OnRecArmChange     GetPeakFileName     MIDI_InsertCC     TakeFX_NavigatePresets    
CSurf_OnRecArmChangeEx     GetPeakFileNameEx     MIDI_InsertEvt     TakeFX_SetEnabled    
CSurf_OnRecord     GetPeakFileNameEx2     MIDI_InsertNote     TakeFX_SetNamedConfigParm    
CSurf_OnRecvPanChange     GetPlayPosition     MIDI_InsertTextSysexEvt     TakeFX_SetOffline    
CSurf_OnRecvVolumeChange     GetPlayPosition2     midi_reinit     TakeFX_SetOpen    
CSurf_OnRew     GetPlayPosition2Ex     MIDI_SelectAll     TakeFX_SetParam    
CSurf_OnRewFwd     GetPlayPositionEx     MIDI_SetAllEvts     TakeFX_SetParamNormalized    
CSurf_OnScroll     GetPlayState     MIDI_SetCC     TakeFX_SetPinMappings    
CSurf_OnSelectedChange     GetPlayStateEx     MIDI_SetCCShape     TakeFX_SetPreset    
CSurf_OnSendPanChange     GetProjectLength     MIDI_SetEvt     TakeFX_SetPresetByIndex    
CSurf_OnSendVolumeChange     GetProjectName     MIDI_SetItemExtents     TakeFX_Show    
CSurf_OnSoloChange     GetProjectPath     MIDI_SetNote     TakeIsMIDI    
CSurf_OnSoloChangeEx     GetProjectPathEx     MIDI_SetTextSysexEvt     ThemeLayout_GetLayout    
CSurf_OnStop     GetProjectStateChangeCount     MIDI_Sort     ThemeLayout_GetParameter    
CSurf_OnTempoChange     GetProjectTimeOffset     MIDIEditor_EnumTakes     ThemeLayout_RefreshAll    
CSurf_OnTrackSelection     GetProjectTimeSignature     MIDIEditor_GetActive     ThemeLayout_SetLayout    
CSurf_OnVolumeChange     GetProjectTimeSignature2     MIDIEditor_GetMode     ThemeLayout_SetParameter    
CSurf_OnVolumeChangeEx     GetProjExtState     MIDIEditor_GetSetting_int     time_precise    
CSurf_OnWidthChange     GetResourcePath     MIDIEditor_GetSetting_str     TimeMap2_beatsToTime    
CSurf_OnWidthChangeEx     GetSelectedEnvelope     MIDIEditor_GetTake     TimeMap2_GetDividedBpmAtTime    
CSurf_OnZoom     GetSelectedMediaItem     MIDIEditor_LastFocused_OnCommand     TimeMap2_GetNextChangeTime    
CSurf_ResetAllCachedVolPanStates     GetSelectedTrack     MIDIEditor_OnCommand     TimeMap2_QNToTime    
CSurf_ScrubAmt     GetSelectedTrack2     MIDIEditor_SetSetting_int     TimeMap2_timeToBeats    
CSurf_SetAutoMode     GetSelectedTrackEnvelope     MIDIEditorFlagsForTrack     TimeMap2_timeToQN    
CSurf_SetPlayState     GetSet_ArrangeView2     mkpanstr     TimeMap_curFrameRate    
CSurf_SetRepeatState     GetSet_LoopTimeRange     mkvolpanstr     TimeMap_GetDividedBpmAtTime    
CSurf_SetSurfaceMute     GetSet_LoopTimeRange2     mkvolstr     TimeMap_GetMeasureInfo    
CSurf_SetSurfacePan     GetSetAutomationItemInfo     MoveEditCursor     TimeMap_GetMetronomePattern    
CSurf_SetSurfaceRecArm     GetSetAutomationItemInfo_String     MoveMediaItemToTrack     TimeMap_GetTimeSigAtTime    
CSurf_SetSurfaceSelected     GetSetEnvelopeInfo_String     MuteAllTracks     TimeMap_QNToMeasures    
CSurf_SetSurfaceSolo     GetSetEnvelopeState     my_getViewport     TimeMap_QNToTime    
CSurf_SetSurfaceVolume     GetSetEnvelopeState2     NamedCommandLookup     TimeMap_QNToTime_abs    
CSurf_SetTrackListChange     GetSetItemState     OnPauseButton     TimeMap_timeToQN    
CSurf_TrackFromID     GetSetItemState2     OnPauseButtonEx     TimeMap_timeToQN_abs    
CSurf_TrackToID     GetSetMediaItemInfo_String     OnPlayButton     ToggleTrackSendUIMute    
DB2SLIDER     GetSetMediaItemTakeInfo_String     OnPlayButtonEx     Track_GetPeakHoldDB    
DeleteActionShortcut     GetSetMediaTrackInfo_String     OnStopButton     Track_GetPeakInfo    
DeleteEnvelopePointEx     GetSetProjectAuthor     OnStopButtonEx     TrackCtl_SetToolTip    
DeleteEnvelopePointRange     GetSetProjectGrid     OpenColorThemeFile     TrackFX_AddByName    
DeleteEnvelopePointRangeEx     GetSetProjectInfo     OpenMediaExplorer     TrackFX_CopyToTake    
DeleteExtState     GetSetProjectInfo_String     OscLocalMessageToHost     TrackFX_CopyToTrack    
DeleteProjectMarker     GetSetProjectNotes     parse_timestr     TrackFX_Delete    
DeleteProjectMarkerByIndex     GetSetRepeat     parse_timestr_len     TrackFX_EndParamEdit    
DeleteTakeMarker     GetSetRepeatEx     parse_timestr_pos     TrackFX_FormatParamValue    
DeleteTakeStretchMarkers     GetSetTrackGroupMembership     parsepanstr     TrackFX_FormatParamValueNormalized    
DeleteTempoTimeSigMarker     GetSetTrackGroupMembershipHigh     PCM_Sink_Enum     TrackFX_GetByName    
DeleteTrack     GetSetTrackSendInfo_String     PCM_Sink_GetExtension     TrackFX_GetChainVisible    
DeleteTrackMediaItem     GetSetTrackState     PCM_Sink_ShowConfig     TrackFX_GetCount    
DestroyAudioAccessor     GetSetTrackState2     PCM_Source_BuildPeaks     TrackFX_GetEnabled    
DoActionShortcutDialog     GetSubProjectFromSource     PCM_Source_CreateFromFile     TrackFX_GetEQ    
Dock_UpdateDockID     GetTake     PCM_Source_CreateFromFileEx     TrackFX_GetEQBandEnabled    
DockGetPosition     GetTakeEnvelope     PCM_Source_CreateFromType     TrackFX_GetEQParam    
DockIsChildOfDock     GetTakeEnvelopeByName     PCM_Source_Destroy     TrackFX_GetFloatingWindow    
DockWindowActivate     GetTakeMarker     PCM_Source_GetPeaks     TrackFX_GetFormattedParamValue    
DockWindowAdd     GetTakeName     PCM_Source_GetSectionInfo     TrackFX_GetFXGUID    
DockWindowAddEx     GetTakeNumStretchMarkers     PluginWantsAlwaysRunFx     TrackFX_GetFXName    
DockWindowRefresh     GetTakeStretchMarker     PreventUIRefresh     TrackFX_GetInstrument    
DockWindowRefreshForHWND     GetTakeStretchMarkerSlope     PromptForAction     TrackFX_GetIOSize    
DockWindowRemove     GetTCPFXParm     ReaScriptError     TrackFX_GetNamedConfigParm    
EditTempoTimeSigMarker     GetTempoMatchPlayRate     RecursiveCreateDirectory     TrackFX_GetNumParams    
EnsureNotCompletelyOffscreen     GetTempoTimeSigMarker     reduce_open_files     TrackFX_GetOffline    
EnumerateFiles     GetThemeColor     RefreshToolbar     TrackFX_GetOpen    
EnumerateSubdirectories     GetThingFromPoint     RefreshToolbar2     TrackFX_GetParam    
EnumInstalledFX     GetToggleCommandState     relative_fn     TrackFX_GetParameterStepSizes    
EnumPitchShiftModes     GetToggleCommandStateEx     RemoveTrackSend     TrackFX_GetParamEx    
EnumPitchShiftSubModes     GetTooltipWindow     RenderFileSection     TrackFX_GetParamFromIdent    
EnumProjectMarkers     GetTouchedOrFocusedFX     ReorderSelectedTracks     TrackFX_GetParamIdent    
EnumProjectMarkers2     GetTrack     Resample_EnumModes     TrackFX_GetParamName    
EnumProjectMarkers3     GetTrackAutomationMode     resolve_fn     TrackFX_GetParamNormalized    
EnumProjects     GetTrackColor     resolve_fn2     TrackFX_GetPinMappings    
EnumProjExtState     GetTrackDepth     ReverseNamedCommandLookup     TrackFX_GetPreset    
EnumRegionRenderMatrix     GetTrackEnvelope     ScaleFromEnvelopeMode     TrackFX_GetPresetIndex    
EnumTrackMIDIProgramNames     GetTrackEnvelopeByChunkName     ScaleToEnvelopeMode     TrackFX_GetRecChainVisible    
EnumTrackMIDIProgramNamesEx     GetTrackEnvelopeByName     SectionFromUniqueID     TrackFX_GetRecCount    
Envelope_Evaluate     GetTrackFromPoint     SelectAllMediaItems     TrackFX_GetUserPresetFilename    
Envelope_FormatValue     GetTrackGUID     SelectProjectInstance     TrackFX_NavigatePresets    
Envelope_GetParentTake     GetTrackMediaItem     SendMIDIMessageToHardware     TrackFX_SetEnabled    
Envelope_GetParentTrack     GetTrackMIDILyrics     SetActiveTake     TrackFX_SetEQBandEnabled    
Envelope_SortPoints     GetTrackMIDINoteName     SetAutomationMode     TrackFX_SetEQParam    
Envelope_SortPointsEx     GetTrackMIDINoteNameEx     SetCurrentBPM     TrackFX_SetNamedConfigParm    
ExecProcess     GetTrackMIDINoteRange     SetCursorContext     TrackFX_SetOffline    
file_exists     GetTrackName     SetEditCurPos     TrackFX_SetOpen    
FindTempoTimeSigMarker     GetTrackNumMediaItems     SetEditCurPos2     TrackFX_SetParam    
format_timestr     GetTrackNumSends     SetEnvelopePoint     TrackFX_SetParamNormalized    
format_timestr_len     GetTrackReceiveName     SetEnvelopePointEx     TrackFX_SetPinMappings    
format_timestr_pos     GetTrackReceiveUIMute     SetEnvelopeStateChunk     TrackFX_SetPreset    
genGuid     GetTrackReceiveUIVolPan     SetExtState     TrackFX_SetPresetByIndex    
get_config_var_string     GetTrackSendInfo_Value     SetGlobalAutomationOverride     TrackFX_Show    
get_ini_file     GetTrackSendName     SetItemStateChunk     TrackList_AdjustWindows    
GetActionShortcutDesc     GetTrackSendUIMute     SetMasterTrackVisibility     TrackList_UpdateAllExternalSurfaces    
GetActiveTake     GetTrackSendUIVolPan     SetMediaItemInfo_Value     Undo_BeginBlock    
GetAllProjectPlayStates     GetTrackState     SetMediaItemLength     Undo_BeginBlock2    
GetAppVersion     GetTrackStateChunk     SetMediaItemPosition     Undo_CanRedo2    
GetArmedCommand     GetTrackUIMute     SetMediaItemSelected     Undo_CanUndo2    
GetAudioAccessorEndTime     GetTrackUIPan     SetMediaItemTake_Source     Undo_DoRedo2    
GetAudioAccessorHash     GetTrackUIVolPan     SetMediaItemTakeInfo_Value     Undo_DoUndo2    
GetAudioAccessorSamples     GetUnderrunTime     SetMediaTrackInfo_Value     Undo_EndBlock    
GetAudioAccessorStartTime     GetUserFileNameForRead     SetMIDIEditorGrid     Undo_EndBlock2    
GetAudioDeviceInfo     GetUserInputs     SetMixerScroll     Undo_OnStateChange    
GetConfigWantsDock     GoToMarker     SetMouseModifier     Undo_OnStateChange2    
GetCurrentProjectInLoadSave     GoToRegion     SetOnlyTrackSelected     Undo_OnStateChange_Item    
GetCursorContext     GR_SelectColor     SetProjectGrid     Undo_OnStateChangeEx    
GetCursorContext2     GSC_mainwnd     SetProjectMarker     Undo_OnStateChangeEx2    
GetCursorPosition     guidToString     SetProjectMarker2     UpdateArrange    
GetCursorPositionEx     HasExtState     SetProjectMarker3     UpdateItemInProject    
GetDisplayedMediaItemColor     HasTrackMIDIPrograms     SetProjectMarker4     UpdateItemLanes    
GetDisplayedMediaItemColor2     HasTrackMIDIProgramsEx     SetProjectMarkerByIndex     UpdateTimeline    
GetEnvelopeInfo_Value     Help_Set     SetProjectMarkerByIndex2     ValidatePtr    
GetEnvelopeName     image_resolve_fn     SetProjExtState     ValidatePtr2    
GetEnvelopePoint     InsertAutomationItem     SetRegionRenderMatrix     ViewPrefs    
GetEnvelopePointByTime     InsertEnvelopePoint     SetTakeMarker    
GetEnvelopePointByTimeEx     InsertEnvelopePointEx     SetTakeStretchMarker    




C: MediaItem* AddMediaItemToTrack(MediaTrack* tr)

EEL2: MediaItem AddMediaItemToTrack(MediaTrack tr)

Lua: MediaItem reaper.AddMediaItemToTrack(MediaTrack tr)

Python: MediaItem RPR_AddMediaItemToTrack(MediaTrack tr)

creates a new media item.



C: int AddProjectMarker(ReaProject* proj, bool isrgn, double pos, double rgnend, const char* name, int wantidx)

EEL2: int AddProjectMarker(ReaProject proj, bool isrgn, pos, rgnend, "name", int wantidx)

Lua: integer reaper.AddProjectMarker(ReaProject proj, boolean isrgn, number pos, number rgnend, string name, integer wantidx)

Python: Int RPR_AddProjectMarker(ReaProject proj, Boolean isrgn, Float pos, Float rgnend, String name, Int wantidx)

Returns the index of the created marker/region, or -1 on failure. Supply wantidx>=0 if you want a particular index number, but you'll get a different index number a region and wantidx is already in use.



C: int AddProjectMarker2(ReaProject* proj, bool isrgn, double pos, double rgnend, const char* name, int wantidx, int color)

EEL2: int AddProjectMarker2(ReaProject proj, bool isrgn, pos, rgnend, "name", int wantidx, int color)

Lua: integer reaper.AddProjectMarker2(ReaProject proj, boolean isrgn, number pos, number rgnend, string name, integer wantidx, integer color)

Python: Int RPR_AddProjectMarker2(ReaProject proj, Boolean isrgn, Float pos, Float rgnend, String name, Int wantidx, Int color)

Returns the index of the created marker/region, or -1 on failure. Supply wantidx>=0 if you want a particular index number, but you'll get a different index number a region and wantidx is already in use. color should be 0 (default color), or ColorToNative(r,g,b)|0x1000000



C: int AddRemoveReaScript(bool add, int sectionID, const char* scriptfn, bool commit)

EEL2: int AddRemoveReaScript(bool add, int sectionID, "scriptfn", bool commit)

Lua: integer reaper.AddRemoveReaScript(boolean add, integer sectionID, string scriptfn, boolean commit)

Python: Int RPR_AddRemoveReaScript(Boolean add, Int sectionID, String scriptfn, Boolean commit)

Add a ReaScript (return the new command ID, or 0 if failed) or remove a ReaScript (return >0 on success). Use commit==true when adding/removing a single script. When bulk adding/removing n scripts, you can optimize the n-1 first calls with commit==false and commit==true for the last call.



C: MediaItem_Take* AddTakeToMediaItem(MediaItem* item)

EEL2: MediaItem_Take AddTakeToMediaItem(MediaItem item)

Lua: MediaItem_Take reaper.AddTakeToMediaItem(MediaItem item)

Python: MediaItem_Take RPR_AddTakeToMediaItem(MediaItem item)

creates a new take in an item



C: bool AddTempoTimeSigMarker(ReaProject* proj, double timepos, double bpm, int timesig_num, int timesig_denom, bool lineartempochange)

EEL2: bool AddTempoTimeSigMarker(ReaProject proj, timepos, bpm, int timesig_num, int timesig_denom, bool lineartempochange)

Lua: boolean reaper.AddTempoTimeSigMarker(ReaProject proj, number timepos, number bpm, integer timesig_num, integer timesig_denom, boolean lineartempochange)

Python: Boolean RPR_AddTempoTimeSigMarker(ReaProject proj, Float timepos, Float bpm, Int timesig_num, Int timesig_denom, Boolean lineartempochange)

Deprecated. Use SetTempoTimeSigMarker with ptidx=-1.



C: void adjustZoom(double amt, int forceset, bool doupd, int centermode)

EEL2: adjustZoom(amt, int forceset, bool doupd, int centermode)

Lua: reaper.adjustZoom(number amt, integer forceset, boolean doupd, integer centermode)

Python: RPR_adjustZoom(Float amt, Int forceset, Boolean doupd, Int centermode)

forceset=0,doupd=true,centermode=-1 for default



C: bool AnyTrackSolo(ReaProject* proj)

EEL2: bool AnyTrackSolo(ReaProject proj)

Lua: boolean reaper.AnyTrackSolo(ReaProject proj)

Python: Boolean RPR_AnyTrackSolo(ReaProject proj)



C: bool APIExists(const char* function_name)

EEL2: bool APIExists("function_name")

Lua: boolean reaper.APIExists(string function_name)

Python: Boolean RPR_APIExists(String function_name)

Returns true if function_name exists in the REAPER API



C: void APITest()

EEL2: APITest()

Lua: reaper.APITest()

Python: RPR_APITest()

Displays a message window if the API was successfully called.



C: bool ApplyNudge(ReaProject* project, int nudgeflag, int nudgewhat, int nudgeunits, double value, bool reverse, int copies)

EEL2: bool ApplyNudge(ReaProject project, int nudgeflag, int nudgewhat, int nudgeunits, value, bool reverse, int copies)

Lua: boolean reaper.ApplyNudge(ReaProject project, integer nudgeflag, integer nudgewhat, integer nudgeunits, number value, boolean reverse, integer copies)

Python: Boolean RPR_ApplyNudge(ReaProject project, Int nudgeflag, Int nudgewhat, Int nudgeunits, Float value, Boolean reverse, Int copies)

nudgeflag: &1=set to value (otherwise nudge by value), &2=snap
nudgewhat: 0=position, 1=left trim, 2=left edge, 3=right edge, 4=contents, 5=duplicate, 6=edit cursor
nudgeunit: 0=ms, 1=seconds, 2=grid, 3=256th notes, ..., 15=whole notes, 16=measures.beats (1.15 = 1 measure + 1.5 beats), 17=samples, 18=frames, 19=pixels, 20=item lengths, 21=item selections
value: amount to nudge by, or value to set to
reverse: in nudge mode, nudges left (otherwise ignored)
copies: in nudge duplicate mode, number of copies (otherwise ignored)



C: void ArmCommand(int cmd, const char* sectionname)

EEL2: ArmCommand(int cmd, "sectionname")

Lua: reaper.ArmCommand(integer cmd, string sectionname)

Python: RPR_ArmCommand(Int cmd, String sectionname)

arms a command (or disarms if 0 passed) in section sectionname (empty string for main)



C: void Audio_Init()

EEL2: Audio_Init()

Lua: reaper.Audio_Init()

Python: RPR_Audio_Init()

open all audio and MIDI devices, if not open



C: int Audio_IsPreBuffer()

EEL2: int Audio_IsPreBuffer()

Lua: integer reaper.Audio_IsPreBuffer()

Python: Int RPR_Audio_IsPreBuffer()

is in pre-buffer? threadsafe



C: int Audio_IsRunning()

EEL2: int Audio_IsRunning()

Lua: integer reaper.Audio_IsRunning()

Python: Int RPR_Audio_IsRunning()

is audio running at all? threadsafe



C: void Audio_Quit()

EEL2: Audio_Quit()

Lua: reaper.Audio_Quit()

Python: RPR_Audio_Quit()

close all audio and MIDI devices, if open



C: bool AudioAccessorStateChanged(AudioAccessor* accessor)

EEL2: bool AudioAccessorStateChanged(AudioAccessor accessor)

Lua: boolean reaper.AudioAccessorStateChanged(AudioAccessor accessor)

Python: Boolean RPR_AudioAccessorStateChanged(AudioAccessor accessor)

Returns true if the underlying samples (track or media item take) have changed, but does not update the audio accessor, so the user can selectively call AudioAccessorValidateState only when needed. See CreateTakeAudioAccessor, CreateTrackAudioAccessor, DestroyAudioAccessor, GetAudioAccessorEndTime, GetAudioAccessorSamples.



C: void AudioAccessorUpdate(AudioAccessor* accessor)

EEL2: AudioAccessorUpdate(AudioAccessor accessor)

Lua: reaper.AudioAccessorUpdate(AudioAccessor accessor)

Python: RPR_AudioAccessorUpdate(AudioAccessor accessor)

Force the accessor to reload its state from the underlying track or media item take. See CreateTakeAudioAccessor, CreateTrackAudioAccessor, DestroyAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorStartTime, GetAudioAccessorEndTime, GetAudioAccessorSamples.



C: bool AudioAccessorValidateState(AudioAccessor* accessor)

EEL2: bool AudioAccessorValidateState(AudioAccessor accessor)

Lua: boolean reaper.AudioAccessorValidateState(AudioAccessor accessor)

Python: Boolean RPR_AudioAccessorValidateState(AudioAccessor accessor)

Validates the current state of the audio accessor -- must ONLY call this from the main thread. Returns true if the state changed.



C: void BypassFxAllTracks(int bypass)

EEL2: BypassFxAllTracks(int bypass)

Lua: reaper.BypassFxAllTracks(integer bypass)

Python: RPR_BypassFxAllTracks(Int bypass)

-1 = bypass all if not all bypassed,otherwise unbypass all



C: int CalcMediaSrcLoudness(PCM_source* mediasource)

EEL2: int CalcMediaSrcLoudness(PCM_source mediasource)

Lua: integer reaper.CalcMediaSrcLoudness(PCM_source mediasource)

Python: Int RPR_CalcMediaSrcLoudness(PCM_source mediasource)

Calculates loudness statistics of media via dry run render. Statistics will be displayed to the user; call GetSetProjectInfo_String("RENDER_STATS") to retrieve via API. Returns 1 if loudness was calculated successfully, -1 if user canceled the dry run render.



C: double CalculateNormalization(PCM_source* source, int normalizeTo, double normalizeTarget, double normalizeStart, double normalizeEnd)

EEL2: double CalculateNormalization(PCM_source source, int normalizeTo, normalizeTarget, normalizeStart, normalizeEnd)

Lua: number reaper.CalculateNormalization(PCM_source source, integer normalizeTo, number normalizeTarget, number normalizeStart, number normalizeEnd)

Python: Float RPR_CalculateNormalization(PCM_source source, Int normalizeTo, Float normalizeTarget, Float normalizeStart, Float normalizeEnd)

Calculate normalize adjustment for source media. normalizeTo: 0=LUFS-I, 1=RMS-I, 2=peak, 3=true peak, 4=LUFS-M max, 5=LUFS-S max. normalizeTarget: dBFS or LUFS value. normalizeStart, normalizeEnd: time bounds within source media for normalization calculation. If normalizationStart=0 and normalizationEnd=0, the full duration of the media will be used for the calculation.



C: void ClearAllRecArmed()

EEL2: ClearAllRecArmed()

Lua: reaper.ClearAllRecArmed()

Python: RPR_ClearAllRecArmed()



C: void ClearConsole()

EEL2: ClearConsole()

Lua: reaper.ClearConsole()

Python: RPR_ClearConsole()

Clear the ReaScript console. See ShowConsoleMsg



C: void ClearPeakCache()

EEL2: ClearPeakCache()

Lua: reaper.ClearPeakCache()

Python: RPR_ClearPeakCache()

resets the global peak caches



C: void ColorFromNative(int col, int* rOut, int* gOut, int* bOut)

EEL2: ColorFromNative(int col, int &r, int &g, int &b)

Lua: integer r, integer g, integer b = reaper.ColorFromNative(integer col)

Python: (Int col, Int rOut, Int gOut, Int bOut) = RPR_ColorFromNative(col, rOut, gOut, bOut)

Extract RGB values from an OS dependent color. See ColorToNative.



C: int ColorToNative(int r, int g, int b)

EEL2: int ColorToNative(int r, int g, int b)

Lua: integer reaper.ColorToNative(integer r, integer g, integer b)

Python: Int RPR_ColorToNative(Int r, Int g, Int b)

Make an OS dependent color from RGB values (e.g. RGB() macro on Windows). r,g and b are in [0..255]. See ColorFromNative.



C: int CountActionShortcuts(KbdSectionInfo* section, int cmdID)

EEL2: int CountActionShortcuts(KbdSectionInfo section, int cmdID)

Lua: integer reaper.CountActionShortcuts(KbdSectionInfo section, integer cmdID)

Python: Int RPR_CountActionShortcuts(KbdSectionInfo section, Int cmdID)

Returns the number of shortcuts that exist for the given command ID.
see GetActionShortcutDesc, DeleteActionShortcut, DoActionShortcutDialog.



C: int CountAutomationItems(TrackEnvelope* env)

EEL2: int CountAutomationItems(TrackEnvelope env)

Lua: integer reaper.CountAutomationItems(TrackEnvelope env)

Python: Int RPR_CountAutomationItems(TrackEnvelope env)

Returns the number of automation items on this envelope. See GetSetAutomationItemInfo



C: int CountEnvelopePoints(TrackEnvelope* envelope)

EEL2: int CountEnvelopePoints(TrackEnvelope envelope)

Lua: integer reaper.CountEnvelopePoints(TrackEnvelope envelope)

Python: Int RPR_CountEnvelopePoints(TrackEnvelope envelope)

Returns the number of points in the envelope. See CountEnvelopePointsEx.



C: int CountEnvelopePointsEx(TrackEnvelope* envelope, int autoitem_idx)

EEL2: int CountEnvelopePointsEx(TrackEnvelope envelope, int autoitem_idx)

Lua: integer reaper.CountEnvelopePointsEx(TrackEnvelope envelope, integer autoitem_idx)

Python: Int RPR_CountEnvelopePointsEx(TrackEnvelope envelope, Int autoitem_idx)

Returns the number of points in the envelope.
autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.
For automation items, pass autoitem_idx|0x10000000 to base ptidx on the number of points in one full loop iteration,
even if the automation item is trimmed so that not all points are visible.
Otherwise, ptidx will be based on the number of visible points in the automation item, including all loop iterations.
See GetEnvelopePointEx, SetEnvelopePointEx, InsertEnvelopePointEx, DeleteEnvelopePointEx.



C: int CountMediaItems(ReaProject* proj)

EEL2: int CountMediaItems(ReaProject proj)

Lua: integer reaper.CountMediaItems(ReaProject proj)

Python: Int RPR_CountMediaItems(ReaProject proj)

count the number of items in the project (proj=0 for active project)



C: int CountProjectMarkers(ReaProject* proj, int* num_markersOut, int* num_regionsOut)

EEL2: int CountProjectMarkers(ReaProject proj, int &num_markers, int &num_regions)

Lua: integer retval, integer num_markers, integer num_regions = reaper.CountProjectMarkers(ReaProject proj)

Python: (Int retval, ReaProject proj, Int num_markersOut, Int num_regionsOut) = RPR_CountProjectMarkers(proj, num_markersOut, num_regionsOut)

num_markersOut and num_regionsOut may be NULL.



C: int CountSelectedMediaItems(ReaProject* proj)

EEL2: int CountSelectedMediaItems(ReaProject proj)

Lua: integer reaper.CountSelectedMediaItems(ReaProject proj)

Python: Int RPR_CountSelectedMediaItems(ReaProject proj)

count the number of selected items in the project (proj=0 for active project)



C: int CountSelectedTracks(ReaProject* proj)

EEL2: int CountSelectedTracks(ReaProject proj)

Lua: integer reaper.CountSelectedTracks(ReaProject proj)

Python: Int RPR_CountSelectedTracks(ReaProject proj)

Count the number of selected tracks in the project (proj=0 for active project). This function ignores the master track, see CountSelectedTracks2.



C: int CountSelectedTracks2(ReaProject* proj, bool wantmaster)

EEL2: int CountSelectedTracks2(ReaProject proj, bool wantmaster)

Lua: integer reaper.CountSelectedTracks2(ReaProject proj, boolean wantmaster)

Python: Int RPR_CountSelectedTracks2(ReaProject proj, Boolean wantmaster)

Count the number of selected tracks in the project (proj=0 for active project).



C: int CountTakeEnvelopes(MediaItem_Take* take)

EEL2: int CountTakeEnvelopes(MediaItem_Take take)

Lua: integer reaper.CountTakeEnvelopes(MediaItem_Take take)

Python: Int RPR_CountTakeEnvelopes(MediaItem_Take take)

See GetTakeEnvelope



C: int CountTakes(MediaItem* item)

EEL2: int CountTakes(MediaItem item)

Lua: integer reaper.CountTakes(MediaItem item)

Python: Int RPR_CountTakes(MediaItem item)

count the number of takes in the item



C: int CountTCPFXParms(ReaProject* project, MediaTrack* track)

EEL2: int CountTCPFXParms(ReaProject project, MediaTrack track)

Lua: integer reaper.CountTCPFXParms(ReaProject project, MediaTrack track)

Python: Int RPR_CountTCPFXParms(ReaProject project, MediaTrack track)

Count the number of FX parameter knobs displayed on the track control panel.



C: int CountTempoTimeSigMarkers(ReaProject* proj)

EEL2: int CountTempoTimeSigMarkers(ReaProject proj)

Lua: integer reaper.CountTempoTimeSigMarkers(ReaProject proj)

Python: Int RPR_CountTempoTimeSigMarkers(ReaProject proj)

Count the number of tempo/time signature markers in the project. See GetTempoTimeSigMarker, SetTempoTimeSigMarker, AddTempoTimeSigMarker.



C: int CountTrackEnvelopes(MediaTrack* track)

EEL2: int CountTrackEnvelopes(MediaTrack track)

Lua: integer reaper.CountTrackEnvelopes(MediaTrack track)

Python: Int RPR_CountTrackEnvelopes(MediaTrack track)

see GetTrackEnvelope



C: int CountTrackMediaItems(MediaTrack* track)

EEL2: int CountTrackMediaItems(MediaTrack track)

Lua: integer reaper.CountTrackMediaItems(MediaTrack track)

Python: Int RPR_CountTrackMediaItems(MediaTrack track)

count the number of items in the track



C: int CountTracks(ReaProject* projOptional)

EEL2: int CountTracks(ReaProject proj)

Lua: integer reaper.CountTracks(ReaProject proj)

Python: Int RPR_CountTracks(ReaProject projOptional)

count the number of tracks in the project (proj=0 for active project)



C: MediaItem* CreateNewMIDIItemInProj(MediaTrack* track, double starttime, double endtime, const bool* qnInOptional)

EEL2: MediaItem CreateNewMIDIItemInProj(MediaTrack track, starttime, endtime, optional bool qnIn)

Lua: MediaItem reaper.CreateNewMIDIItemInProj(MediaTrack track, number starttime, number endtime, optional boolean qnIn)

Python: MediaItem RPR_CreateNewMIDIItemInProj(MediaTrack track, Float starttime, Float endtime, const bool qnInOptional)

Create a new MIDI media item, containing no MIDI events. Time is in seconds unless qn is set.



C: AudioAccessor* CreateTakeAudioAccessor(MediaItem_Take* take)

EEL2: AudioAccessor CreateTakeAudioAccessor(MediaItem_Take take)

Lua: AudioAccessor reaper.CreateTakeAudioAccessor(MediaItem_Take take)

Python: AudioAccessor RPR_CreateTakeAudioAccessor(MediaItem_Take take)

Create an audio accessor object for this take. Must only call from the main thread. See CreateTrackAudioAccessor, DestroyAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorStartTime, GetAudioAccessorEndTime, GetAudioAccessorSamples.



C: AudioAccessor* CreateTrackAudioAccessor(MediaTrack* track)

EEL2: AudioAccessor CreateTrackAudioAccessor(MediaTrack track)

Lua: AudioAccessor reaper.CreateTrackAudioAccessor(MediaTrack track)

Python: AudioAccessor RPR_CreateTrackAudioAccessor(MediaTrack track)

Create an audio accessor object for this track. Must only call from the main thread. See CreateTakeAudioAccessor, DestroyAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorStartTime, GetAudioAccessorEndTime, GetAudioAccessorSamples.



C: int CreateTrackSend(MediaTrack* tr, MediaTrack* desttrInOptional)

EEL2: int CreateTrackSend(MediaTrack tr, MediaTrack desttrIn)

Lua: integer reaper.CreateTrackSend(MediaTrack tr, MediaTrack desttrIn)

Python: Int RPR_CreateTrackSend(MediaTrack tr, MediaTrack desttrInOptional)

Create a send/receive (desttrInOptional!=NULL), or a hardware output (desttrInOptional==NULL) with default properties, return >=0 on success (== new send/receive index). See RemoveTrackSend, GetSetTrackSendInfo, GetTrackSendInfo_Value, SetTrackSendInfo_Value.



C: void CSurf_FlushUndo(bool force)

EEL2: CSurf_FlushUndo(bool force)

Lua: reaper.CSurf_FlushUndo(boolean force)

Python: RPR_CSurf_FlushUndo(Boolean force)

call this to force flushing of the undo states after using CSurf_On*Change()



C: bool CSurf_GetTouchState(MediaTrack* trackid, int isPan)

EEL2: bool CSurf_GetTouchState(MediaTrack trackid, int isPan)

Lua: boolean reaper.CSurf_GetTouchState(MediaTrack trackid, integer isPan)

Python: Boolean RPR_CSurf_GetTouchState(MediaTrack trackid, Int isPan)



C: void CSurf_GoEnd()

EEL2: CSurf_GoEnd()

Lua: reaper.CSurf_GoEnd()

Python: RPR_CSurf_GoEnd()



C: void CSurf_GoStart()

EEL2: CSurf_GoStart()

Lua: reaper.CSurf_GoStart()

Python: RPR_CSurf_GoStart()



C: int CSurf_NumTracks(bool mcpView)

EEL2: int CSurf_NumTracks(bool mcpView)

Lua: integer reaper.CSurf_NumTracks(boolean mcpView)

Python: Int RPR_CSurf_NumTracks(Boolean mcpView)



C: void CSurf_OnArrow(int whichdir, bool wantzoom)

EEL2: CSurf_OnArrow(int whichdir, bool wantzoom)

Lua: reaper.CSurf_OnArrow(integer whichdir, boolean wantzoom)

Python: RPR_CSurf_OnArrow(Int whichdir, Boolean wantzoom)



C: void CSurf_OnFwd(int seekplay)

EEL2: CSurf_OnFwd(int seekplay)

Lua: reaper.CSurf_OnFwd(integer seekplay)

Python: RPR_CSurf_OnFwd(Int seekplay)



C: bool CSurf_OnFXChange(MediaTrack* trackid, int en)

EEL2: bool CSurf_OnFXChange(MediaTrack trackid, int en)

Lua: boolean reaper.CSurf_OnFXChange(MediaTrack trackid, integer en)

Python: Boolean RPR_CSurf_OnFXChange(MediaTrack trackid, Int en)



C: int CSurf_OnInputMonitorChange(MediaTrack* trackid, int monitor)

EEL2: int CSurf_OnInputMonitorChange(MediaTrack trackid, int monitor)

Lua: integer reaper.CSurf_OnInputMonitorChange(MediaTrack trackid, integer monitor)

Python: Int RPR_CSurf_OnInputMonitorChange(MediaTrack trackid, Int monitor)



C: int CSurf_OnInputMonitorChangeEx(MediaTrack* trackid, int monitor, bool allowgang)

EEL2: int CSurf_OnInputMonitorChangeEx(MediaTrack trackid, int monitor, bool allowgang)

Lua: integer reaper.CSurf_OnInputMonitorChangeEx(MediaTrack trackid, integer monitor, boolean allowgang)

Python: Int RPR_CSurf_OnInputMonitorChangeEx(MediaTrack trackid, Int monitor, Boolean allowgang)



C: bool CSurf_OnMuteChange(MediaTrack* trackid, int mute)

EEL2: bool CSurf_OnMuteChange(MediaTrack trackid, int mute)

Lua: boolean reaper.CSurf_OnMuteChange(MediaTrack trackid, integer mute)

Python: Boolean RPR_CSurf_OnMuteChange(MediaTrack trackid, Int mute)



C: bool CSurf_OnMuteChangeEx(MediaTrack* trackid, int mute, bool allowgang)

EEL2: bool CSurf_OnMuteChangeEx(MediaTrack trackid, int mute, bool allowgang)

Lua: boolean reaper.CSurf_OnMuteChangeEx(MediaTrack trackid, integer mute, boolean allowgang)

Python: Boolean RPR_CSurf_OnMuteChangeEx(MediaTrack trackid, Int mute, Boolean allowgang)



C: double CSurf_OnPanChange(MediaTrack* trackid, double pan, bool relative)

EEL2: double CSurf_OnPanChange(MediaTrack trackid, pan, bool relative)

Lua: number reaper.CSurf_OnPanChange(MediaTrack trackid, number pan, boolean relative)

Python: Float RPR_CSurf_OnPanChange(MediaTrack trackid, Float pan, Boolean relative)



C: double CSurf_OnPanChangeEx(MediaTrack* trackid, double pan, bool relative, bool allowGang)

EEL2: double CSurf_OnPanChangeEx(MediaTrack trackid, pan, bool relative, bool allowGang)

Lua: number reaper.CSurf_OnPanChangeEx(MediaTrack trackid, number pan, boolean relative, boolean allowGang)

Python: Float RPR_CSurf_OnPanChangeEx(MediaTrack trackid, Float pan, Boolean relative, Boolean allowGang)



C: void CSurf_OnPause()

EEL2: CSurf_OnPause()

Lua: reaper.CSurf_OnPause()

Python: RPR_CSurf_OnPause()



C: void CSurf_OnPlay()

EEL2: CSurf_OnPlay()

Lua: reaper.CSurf_OnPlay()

Python: RPR_CSurf_OnPlay()



C: void CSurf_OnPlayRateChange(double playrate)

EEL2: CSurf_OnPlayRateChange(playrate)

Lua: reaper.CSurf_OnPlayRateChange(number playrate)

Python: RPR_CSurf_OnPlayRateChange(Float playrate)



C: bool CSurf_OnRecArmChange(MediaTrack* trackid, int recarm)

EEL2: bool CSurf_OnRecArmChange(MediaTrack trackid, int recarm)

Lua: boolean reaper.CSurf_OnRecArmChange(MediaTrack trackid, integer recarm)

Python: Boolean RPR_CSurf_OnRecArmChange(MediaTrack trackid, Int recarm)



C: bool CSurf_OnRecArmChangeEx(MediaTrack* trackid, int recarm, bool allowgang)

EEL2: bool CSurf_OnRecArmChangeEx(MediaTrack trackid, int recarm, bool allowgang)

Lua: boolean reaper.CSurf_OnRecArmChangeEx(MediaTrack trackid, integer recarm, boolean allowgang)

Python: Boolean RPR_CSurf_OnRecArmChangeEx(MediaTrack trackid, Int recarm, Boolean allowgang)



C: void CSurf_OnRecord()

EEL2: CSurf_OnRecord()

Lua: reaper.CSurf_OnRecord()

Python: RPR_CSurf_OnRecord()



C: double CSurf_OnRecvPanChange(MediaTrack* trackid, int recv_index, double pan, bool relative)

EEL2: double CSurf_OnRecvPanChange(MediaTrack trackid, int recv_index, pan, bool relative)

Lua: number reaper.CSurf_OnRecvPanChange(MediaTrack trackid, integer recv_index, number pan, boolean relative)

Python: Float RPR_CSurf_OnRecvPanChange(MediaTrack trackid, Int recv_index, Float pan, Boolean relative)



C: double CSurf_OnRecvVolumeChange(MediaTrack* trackid, int recv_index, double volume, bool relative)

EEL2: double CSurf_OnRecvVolumeChange(MediaTrack trackid, int recv_index, volume, bool relative)

Lua: number reaper.CSurf_OnRecvVolumeChange(MediaTrack trackid, integer recv_index, number volume, boolean relative)

Python: Float RPR_CSurf_OnRecvVolumeChange(MediaTrack trackid, Int recv_index, Float volume, Boolean relative)



C: void CSurf_OnRew(int seekplay)

EEL2: CSurf_OnRew(int seekplay)

Lua: reaper.CSurf_OnRew(integer seekplay)

Python: RPR_CSurf_OnRew(Int seekplay)



C: void CSurf_OnRewFwd(int seekplay, int dir)

EEL2: CSurf_OnRewFwd(int seekplay, int dir)

Lua: reaper.CSurf_OnRewFwd(integer seekplay, integer dir)

Python: RPR_CSurf_OnRewFwd(Int seekplay, Int dir)



C: void CSurf_OnScroll(int xdir, int ydir)

EEL2: CSurf_OnScroll(int xdir, int ydir)

Lua: reaper.CSurf_OnScroll(integer xdir, integer ydir)

Python: RPR_CSurf_OnScroll(Int xdir, Int ydir)



C: bool CSurf_OnSelectedChange(MediaTrack* trackid, int selected)

EEL2: bool CSurf_OnSelectedChange(MediaTrack trackid, int selected)

Lua: boolean reaper.CSurf_OnSelectedChange(MediaTrack trackid, integer selected)

Python: Boolean RPR_CSurf_OnSelectedChange(MediaTrack trackid, Int selected)



C: double CSurf_OnSendPanChange(MediaTrack* trackid, int send_index, double pan, bool relative)

EEL2: double CSurf_OnSendPanChange(MediaTrack trackid, int send_index, pan, bool relative)

Lua: number reaper.CSurf_OnSendPanChange(MediaTrack trackid, integer send_index, number pan, boolean relative)

Python: Float RPR_CSurf_OnSendPanChange(MediaTrack trackid, Int send_index, Float pan, Boolean relative)



C: double CSurf_OnSendVolumeChange(MediaTrack* trackid, int send_index, double volume, bool relative)

EEL2: double CSurf_OnSendVolumeChange(MediaTrack trackid, int send_index, volume, bool relative)

Lua: number reaper.CSurf_OnSendVolumeChange(MediaTrack trackid, integer send_index, number volume, boolean relative)

Python: Float RPR_CSurf_OnSendVolumeChange(MediaTrack trackid, Int send_index, Float volume, Boolean relative)



C: bool CSurf_OnSoloChange(MediaTrack* trackid, int solo)

EEL2: bool CSurf_OnSoloChange(MediaTrack trackid, int solo)

Lua: boolean reaper.CSurf_OnSoloChange(MediaTrack trackid, integer solo)

Python: Boolean RPR_CSurf_OnSoloChange(MediaTrack trackid, Int solo)



C: bool CSurf_OnSoloChangeEx(MediaTrack* trackid, int solo, bool allowgang)

EEL2: bool CSurf_OnSoloChangeEx(MediaTrack trackid, int solo, bool allowgang)

Lua: boolean reaper.CSurf_OnSoloChangeEx(MediaTrack trackid, integer solo, boolean allowgang)

Python: Boolean RPR_CSurf_OnSoloChangeEx(MediaTrack trackid, Int solo, Boolean allowgang)



C: void CSurf_OnStop()

EEL2: CSurf_OnStop()

Lua: reaper.CSurf_OnStop()

Python: RPR_CSurf_OnStop()



C: void CSurf_OnTempoChange(double bpm)

EEL2: CSurf_OnTempoChange(bpm)

Lua: reaper.CSurf_OnTempoChange(number bpm)

Python: RPR_CSurf_OnTempoChange(Float bpm)



C: void CSurf_OnTrackSelection(MediaTrack* trackid)

EEL2: CSurf_OnTrackSelection(MediaTrack trackid)

Lua: reaper.CSurf_OnTrackSelection(MediaTrack trackid)

Python: RPR_CSurf_OnTrackSelection(MediaTrack trackid)



C: double CSurf_OnVolumeChange(MediaTrack* trackid, double volume, bool relative)

EEL2: double CSurf_OnVolumeChange(MediaTrack trackid, volume, bool relative)

Lua: number reaper.CSurf_OnVolumeChange(MediaTrack trackid, number volume, boolean relative)

Python: Float RPR_CSurf_OnVolumeChange(MediaTrack trackid, Float volume, Boolean relative)



C: double CSurf_OnVolumeChangeEx(MediaTrack* trackid, double volume, bool relative, bool allowGang)

EEL2: double CSurf_OnVolumeChangeEx(MediaTrack trackid, volume, bool relative, bool allowGang)

Lua: number reaper.CSurf_OnVolumeChangeEx(MediaTrack trackid, number volume, boolean relative, boolean allowGang)

Python: Float RPR_CSurf_OnVolumeChangeEx(MediaTrack trackid, Float volume, Boolean relative, Boolean allowGang)



C: double CSurf_OnWidthChange(MediaTrack* trackid, double width, bool relative)

EEL2: double CSurf_OnWidthChange(MediaTrack trackid, width, bool relative)

Lua: number reaper.CSurf_OnWidthChange(MediaTrack trackid, number width, boolean relative)

Python: Float RPR_CSurf_OnWidthChange(MediaTrack trackid, Float width, Boolean relative)



C: double CSurf_OnWidthChangeEx(MediaTrack* trackid, double width, bool relative, bool allowGang)

EEL2: double CSurf_OnWidthChangeEx(MediaTrack trackid, width, bool relative, bool allowGang)

Lua: number reaper.CSurf_OnWidthChangeEx(MediaTrack trackid, number width, boolean relative, boolean allowGang)

Python: Float RPR_CSurf_OnWidthChangeEx(MediaTrack trackid, Float width, Boolean relative, Boolean allowGang)



C: void CSurf_OnZoom(int xdir, int ydir)

EEL2: CSurf_OnZoom(int xdir, int ydir)

Lua: reaper.CSurf_OnZoom(integer xdir, integer ydir)

Python: RPR_CSurf_OnZoom(Int xdir, Int ydir)



C: void CSurf_ResetAllCachedVolPanStates()

EEL2: CSurf_ResetAllCachedVolPanStates()

Lua: reaper.CSurf_ResetAllCachedVolPanStates()

Python: RPR_CSurf_ResetAllCachedVolPanStates()



C: void CSurf_ScrubAmt(double amt)

EEL2: CSurf_ScrubAmt(amt)

Lua: reaper.CSurf_ScrubAmt(number amt)

Python: RPR_CSurf_ScrubAmt(Float amt)



C: void CSurf_SetAutoMode(int mode, IReaperControlSurface* ignoresurf)

EEL2: CSurf_SetAutoMode(int mode, IReaperControlSurface ignoresurf)

Lua: reaper.CSurf_SetAutoMode(integer mode, IReaperControlSurface ignoresurf)

Python: RPR_CSurf_SetAutoMode(Int mode, IReaperControlSurface ignoresurf)



C: void CSurf_SetPlayState(bool play, bool pause, bool rec, IReaperControlSurface* ignoresurf)

EEL2: CSurf_SetPlayState(bool play, bool pause, bool rec, IReaperControlSurface ignoresurf)

Lua: reaper.CSurf_SetPlayState(boolean play, boolean pause, boolean rec, IReaperControlSurface ignoresurf)

Python: RPR_CSurf_SetPlayState(Boolean play, Boolean pause, Boolean rec, IReaperControlSurface ignoresurf)



C: void CSurf_SetRepeatState(bool rep, IReaperControlSurface* ignoresurf)

EEL2: CSurf_SetRepeatState(bool rep, IReaperControlSurface ignoresurf)

Lua: reaper.CSurf_SetRepeatState(boolean rep, IReaperControlSurface ignoresurf)

Python: RPR_CSurf_SetRepeatState(Boolean rep, IReaperControlSurface ignoresurf)



C: void CSurf_SetSurfaceMute(MediaTrack* trackid, bool mute, IReaperControlSurface* ignoresurf)

EEL2: CSurf_SetSurfaceMute(MediaTrack trackid, bool mute, IReaperControlSurface ignoresurf)

Lua: reaper.CSurf_SetSurfaceMute(MediaTrack trackid, boolean mute, IReaperControlSurface ignoresurf)

Python: RPR_CSurf_SetSurfaceMute(MediaTrack trackid, Boolean mute, IReaperControlSurface ignoresurf)



C: void CSurf_SetSurfacePan(MediaTrack* trackid, double pan, IReaperControlSurface* ignoresurf)

EEL2: CSurf_SetSurfacePan(MediaTrack trackid, pan, IReaperControlSurface ignoresurf)

Lua: reaper.CSurf_SetSurfacePan(MediaTrack trackid, number pan, IReaperControlSurface ignoresurf)

Python: RPR_CSurf_SetSurfacePan(MediaTrack trackid, Float pan, IReaperControlSurface ignoresurf)



C: void CSurf_SetSurfaceRecArm(MediaTrack* trackid, bool recarm, IReaperControlSurface* ignoresurf)

EEL2: CSurf_SetSurfaceRecArm(MediaTrack trackid, bool recarm, IReaperControlSurface ignoresurf)

Lua: reaper.CSurf_SetSurfaceRecArm(MediaTrack trackid, boolean recarm, IReaperControlSurface ignoresurf)

Python: RPR_CSurf_SetSurfaceRecArm(MediaTrack trackid, Boolean recarm, IReaperControlSurface ignoresurf)



C: void CSurf_SetSurfaceSelected(MediaTrack* trackid, bool selected, IReaperControlSurface* ignoresurf)

EEL2: CSurf_SetSurfaceSelected(MediaTrack trackid, bool selected, IReaperControlSurface ignoresurf)

Lua: reaper.CSurf_SetSurfaceSelected(MediaTrack trackid, boolean selected, IReaperControlSurface ignoresurf)

Python: RPR_CSurf_SetSurfaceSelected(MediaTrack trackid, Boolean selected, IReaperControlSurface ignoresurf)



C: void CSurf_SetSurfaceSolo(MediaTrack* trackid, bool solo, IReaperControlSurface* ignoresurf)

EEL2: CSurf_SetSurfaceSolo(MediaTrack trackid, bool solo, IReaperControlSurface ignoresurf)

Lua: reaper.CSurf_SetSurfaceSolo(MediaTrack trackid, boolean solo, IReaperControlSurface ignoresurf)

Python: RPR_CSurf_SetSurfaceSolo(MediaTrack trackid, Boolean solo, IReaperControlSurface ignoresurf)



C: void CSurf_SetSurfaceVolume(MediaTrack* trackid, double volume, IReaperControlSurface* ignoresurf)

EEL2: CSurf_SetSurfaceVolume(MediaTrack trackid, volume, IReaperControlSurface ignoresurf)

Lua: reaper.CSurf_SetSurfaceVolume(MediaTrack trackid, number volume, IReaperControlSurface ignoresurf)

Python: RPR_CSurf_SetSurfaceVolume(MediaTrack trackid, Float volume, IReaperControlSurface ignoresurf)



C: void CSurf_SetTrackListChange()

EEL2: CSurf_SetTrackListChange()

Lua: reaper.CSurf_SetTrackListChange()

Python: RPR_CSurf_SetTrackListChange()



C: MediaTrack* CSurf_TrackFromID(int idx, bool mcpView)

EEL2: MediaTrack CSurf_TrackFromID(int idx, bool mcpView)

Lua: MediaTrack reaper.CSurf_TrackFromID(integer idx, boolean mcpView)

Python: MediaTrack RPR_CSurf_TrackFromID(Int idx, Boolean mcpView)



C: int CSurf_TrackToID(MediaTrack* track, bool mcpView)

EEL2: int CSurf_TrackToID(MediaTrack track, bool mcpView)

Lua: integer reaper.CSurf_TrackToID(MediaTrack track, boolean mcpView)

Python: Int RPR_CSurf_TrackToID(MediaTrack track, Boolean mcpView)



C: double DB2SLIDER(double x)

EEL2: double DB2SLIDER(x)

Lua: number reaper.DB2SLIDER(number x)

Python: Float RPR_DB2SLIDER(Float x)



C: bool DeleteActionShortcut(KbdSectionInfo* section, int cmdID, int shortcutidx)

EEL2: bool DeleteActionShortcut(KbdSectionInfo section, int cmdID, int shortcutidx)

Lua: boolean reaper.DeleteActionShortcut(KbdSectionInfo section, integer cmdID, integer shortcutidx)

Python: Boolean RPR_DeleteActionShortcut(KbdSectionInfo section, Int cmdID, Int shortcutidx)

Delete the specific shortcut for the given command ID.
See CountActionShortcuts, GetActionShortcutDesc, DoActionShortcutDialog.



C: bool DeleteEnvelopePointEx(TrackEnvelope* envelope, int autoitem_idx, int ptidx)

EEL2: bool DeleteEnvelopePointEx(TrackEnvelope envelope, int autoitem_idx, int ptidx)

Lua: boolean reaper.DeleteEnvelopePointEx(TrackEnvelope envelope, integer autoitem_idx, integer ptidx)

Python: Boolean RPR_DeleteEnvelopePointEx(TrackEnvelope envelope, Int autoitem_idx, Int ptidx)

Delete an envelope point. If setting multiple points at once, set noSort=true, and call Envelope_SortPoints when done.
autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.
For automation items, pass autoitem_idx|0x10000000 to base ptidx on the number of points in one full loop iteration,
even if the automation item is trimmed so that not all points are visible.
Otherwise, ptidx will be based on the number of visible points in the automation item, including all loop iterations.
See CountEnvelopePointsEx, GetEnvelopePointEx, SetEnvelopePointEx, InsertEnvelopePointEx.



C: bool DeleteEnvelopePointRange(TrackEnvelope* envelope, double time_start, double time_end)

EEL2: bool DeleteEnvelopePointRange(TrackEnvelope envelope, time_start, time_end)

Lua: boolean reaper.DeleteEnvelopePointRange(TrackEnvelope envelope, number time_start, number time_end)

Python: Boolean RPR_DeleteEnvelopePointRange(TrackEnvelope envelope, Float time_start, Float time_end)

Delete a range of envelope points. See DeleteEnvelopePointRangeEx, DeleteEnvelopePointEx.



C: bool DeleteEnvelopePointRangeEx(TrackEnvelope* envelope, int autoitem_idx, double time_start, double time_end)

EEL2: bool DeleteEnvelopePointRangeEx(TrackEnvelope envelope, int autoitem_idx, time_start, time_end)

Lua: boolean reaper.DeleteEnvelopePointRangeEx(TrackEnvelope envelope, integer autoitem_idx, number time_start, number time_end)

Python: Boolean RPR_DeleteEnvelopePointRangeEx(TrackEnvelope envelope, Int autoitem_idx, Float time_start, Float time_end)

Delete a range of envelope points. autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.



C: void DeleteExtState(const char* section, const char* key, bool persist)

EEL2: DeleteExtState("section", "key", bool persist)

Lua: reaper.DeleteExtState(string section, string key, boolean persist)

Python: RPR_DeleteExtState(String section, String key, Boolean persist)

Delete the extended state value for a specific section and key. persist=true means the value should remain deleted the next time REAPER is opened. See SetExtState, GetExtState, HasExtState.



C: bool DeleteProjectMarker(ReaProject* proj, int markrgnindexnumber, bool isrgn)

EEL2: bool DeleteProjectMarker(ReaProject proj, int markrgnindexnumber, bool isrgn)

Lua: boolean reaper.DeleteProjectMarker(ReaProject proj, integer markrgnindexnumber, boolean isrgn)

Python: Boolean RPR_DeleteProjectMarker(ReaProject proj, Int markrgnindexnumber, Boolean isrgn)

Delete a marker. proj==NULL for the active project.



C: bool DeleteProjectMarkerByIndex(ReaProject* proj, int markrgnidx)

EEL2: bool DeleteProjectMarkerByIndex(ReaProject proj, int markrgnidx)

Lua: boolean reaper.DeleteProjectMarkerByIndex(ReaProject proj, integer markrgnidx)

Python: Boolean RPR_DeleteProjectMarkerByIndex(ReaProject proj, Int markrgnidx)

Differs from DeleteProjectMarker only in that markrgnidx is 0 for the first marker/region, 1 for the next, etc (see EnumProjectMarkers3), rather than representing the displayed marker/region ID number (see SetProjectMarker4).



C: bool DeleteTakeMarker(MediaItem_Take* take, int idx)

EEL2: bool DeleteTakeMarker(MediaItem_Take take, int idx)

Lua: boolean reaper.DeleteTakeMarker(MediaItem_Take take, integer idx)

Python: Boolean RPR_DeleteTakeMarker(MediaItem_Take take, Int idx)

Delete a take marker. Note that idx will change for all following take markers. See GetNumTakeMarkers, GetTakeMarker, SetTakeMarker



C: int DeleteTakeStretchMarkers(MediaItem_Take* take, int idx, const int* countInOptional)

EEL2: int DeleteTakeStretchMarkers(MediaItem_Take take, int idx, optional int countIn)

Lua: integer reaper.DeleteTakeStretchMarkers(MediaItem_Take take, integer idx, optional integer countIn)

Python: Int RPR_DeleteTakeStretchMarkers(MediaItem_Take take, Int idx, const int countInOptional)

Deletes one or more stretch markers. Returns number of stretch markers deleted.



C: bool DeleteTempoTimeSigMarker(ReaProject* project, int markerindex)

EEL2: bool DeleteTempoTimeSigMarker(ReaProject project, int markerindex)

Lua: boolean reaper.DeleteTempoTimeSigMarker(ReaProject project, integer markerindex)

Python: Boolean RPR_DeleteTempoTimeSigMarker(ReaProject project, Int markerindex)

Delete a tempo/time signature marker.



C: void DeleteTrack(MediaTrack* tr)

EEL2: DeleteTrack(MediaTrack tr)

Lua: reaper.DeleteTrack(MediaTrack tr)

Python: RPR_DeleteTrack(MediaTrack tr)

deletes a track



C: bool DeleteTrackMediaItem(MediaTrack* tr, MediaItem* it)

EEL2: bool DeleteTrackMediaItem(MediaTrack tr, MediaItem it)

Lua: boolean reaper.DeleteTrackMediaItem(MediaTrack tr, MediaItem it)

Python: Boolean RPR_DeleteTrackMediaItem(MediaTrack tr, MediaItem it)



C: void DestroyAudioAccessor(AudioAccessor* accessor)

EEL2: DestroyAudioAccessor(AudioAccessor accessor)

Lua: reaper.DestroyAudioAccessor(AudioAccessor accessor)

Python: RPR_DestroyAudioAccessor(AudioAccessor accessor)

Destroy an audio accessor. Must only call from the main thread. See CreateTakeAudioAccessor, CreateTrackAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorStartTime, GetAudioAccessorEndTime, GetAudioAccessorSamples.



C: bool DoActionShortcutDialog(HWND hwnd, KbdSectionInfo* section, int cmdID, int shortcutidx)

EEL2: bool DoActionShortcutDialog(HWND hwnd, KbdSectionInfo section, int cmdID, int shortcutidx)

Lua: boolean reaper.DoActionShortcutDialog(HWND hwnd, KbdSectionInfo section, integer cmdID, integer shortcutidx)

Python: Boolean RPR_DoActionShortcutDialog(HWND hwnd, KbdSectionInfo section, Int cmdID, Int shortcutidx)

Open the action shortcut dialog to edit or add a shortcut for the given command ID. If (shortcutidx >= 0 && shortcutidx < CountActionShortcuts()), that specific shortcut will be replaced, otherwise a new shortcut will be added.
See CountActionShortcuts, GetActionShortcutDesc, DeleteActionShortcut.



C: void Dock_UpdateDockID(const char* ident_str, int whichDock)

EEL2: Dock_UpdateDockID("ident_str", int whichDock)

Lua: reaper.Dock_UpdateDockID(string ident_str, integer whichDock)

Python: RPR_Dock_UpdateDockID(String ident_str, Int whichDock)

updates preference for docker window ident_str to be in dock whichDock on next open



C: int DockGetPosition(int whichDock)

EEL2: int DockGetPosition(int whichDock)

Lua: integer reaper.DockGetPosition(integer whichDock)

Python: Int RPR_DockGetPosition(Int whichDock)

-1=not found, 0=bottom, 1=left, 2=top, 3=right, 4=floating



C: int DockIsChildOfDock(HWND hwnd, bool* isFloatingDockerOut)

EEL2: int DockIsChildOfDock(HWND hwnd, bool &isFloatingDocker)

Lua: integer retval, boolean isFloatingDocker = reaper.DockIsChildOfDock(HWND hwnd)

Python: (Int retval, HWND hwnd, Boolean isFloatingDockerOut) = RPR_DockIsChildOfDock(hwnd, isFloatingDockerOut)

returns dock index that contains hwnd, or -1



C: void DockWindowActivate(HWND hwnd)

EEL2: DockWindowActivate(HWND hwnd)

Lua: reaper.DockWindowActivate(HWND hwnd)

Python: RPR_DockWindowActivate(HWND hwnd)



C: void DockWindowAdd(HWND hwnd, const char* name, int pos, bool allowShow)

EEL2: DockWindowAdd(HWND hwnd, "name", int pos, bool allowShow)

Lua: reaper.DockWindowAdd(HWND hwnd, string name, integer pos, boolean allowShow)

Python: RPR_DockWindowAdd(HWND hwnd, String name, Int pos, Boolean allowShow)



C: void DockWindowAddEx(HWND hwnd, const char* name, const char* identstr, bool allowShow)

EEL2: DockWindowAddEx(HWND hwnd, "name", "identstr", bool allowShow)

Lua: reaper.DockWindowAddEx(HWND hwnd, string name, string identstr, boolean allowShow)

Python: RPR_DockWindowAddEx(HWND hwnd, String name, String identstr, Boolean allowShow)



C: void DockWindowRefresh()

EEL2: DockWindowRefresh()

Lua: reaper.DockWindowRefresh()

Python: RPR_DockWindowRefresh()



C: void DockWindowRefreshForHWND(HWND hwnd)

EEL2: DockWindowRefreshForHWND(HWND hwnd)

Lua: reaper.DockWindowRefreshForHWND(HWND hwnd)

Python: RPR_DockWindowRefreshForHWND(HWND hwnd)



C: void DockWindowRemove(HWND hwnd)

EEL2: DockWindowRemove(HWND hwnd)

Lua: reaper.DockWindowRemove(HWND hwnd)

Python: RPR_DockWindowRemove(HWND hwnd)



C: bool EditTempoTimeSigMarker(ReaProject* project, int markerindex)

EEL2: bool EditTempoTimeSigMarker(ReaProject project, int markerindex)

Lua: boolean reaper.EditTempoTimeSigMarker(ReaProject project, integer markerindex)

Python: Boolean RPR_EditTempoTimeSigMarker(ReaProject project, Int markerindex)

Open the tempo/time signature marker editor dialog.



C: void EnsureNotCompletelyOffscreen(RECT* rInOut)

EEL2: EnsureNotCompletelyOffscreen(int &r.left, int &r.top, int &r.right, int &r.bot)

Lua: integerr.left, integerr.top, integerr.right, integerr.bot = reaper.EnsureNotCompletelyOffscreen(integerr.left, integerr.top, integerr.right, integerr.bot)

Python: RPR_EnsureNotCompletelyOffscreen(RECT rInOut)

call with a saved window rect for your window and it'll correct any positioning info.



C: const char* EnumerateFiles(const char* path, int fileindex)

EEL2: bool EnumerateFiles(#retval, "path", int fileindex)

Lua: string reaper.EnumerateFiles(string path, integer fileindex)

Python: String RPR_EnumerateFiles(String path, Int fileindex)

List the files in the "path" directory. Returns NULL/nil when all files have been listed. Use fileindex = -1 to force re-read of directory (invalidate cache). See EnumerateSubdirectories



C: const char* EnumerateSubdirectories(const char* path, int subdirindex)

EEL2: bool EnumerateSubdirectories(#retval, "path", int subdirindex)

Lua: string reaper.EnumerateSubdirectories(string path, integer subdirindex)

Python: String RPR_EnumerateSubdirectories(String path, Int subdirindex)

List the subdirectories in the "path" directory. Use subdirindex = -1 to force re-read of directory (invalidate cache). Returns NULL/nil when all subdirectories have been listed. See EnumerateFiles



C: bool EnumInstalledFX(int index, const char** nameOut, const char** identOut)

EEL2: bool EnumInstalledFX(int index, #name, #ident)

Lua: boolean retval, string name, string ident = reaper.EnumInstalledFX(integer index)

Python: Boolean RPR_EnumInstalledFX(Int index, String nameOut, String identOut)

Enumerates installed FX. Returns true if successful, sets nameOut and identOut to name and ident of FX at index.



C: bool EnumPitchShiftModes(int mode, const char** strOut)

EEL2: bool EnumPitchShiftModes(int mode, #str)

Lua: boolean retval, string str = reaper.EnumPitchShiftModes(integer mode)

Python: Boolean RPR_EnumPitchShiftModes(Int mode, String strOut)

Start querying modes at 0, returns FALSE when no more modes possible, sets strOut to NULL if a mode is currently unsupported



C: const char* EnumPitchShiftSubModes(int mode, int submode)

EEL2: bool EnumPitchShiftSubModes(#retval, int mode, int submode)

Lua: string reaper.EnumPitchShiftSubModes(integer mode, integer submode)

Python: String RPR_EnumPitchShiftSubModes(Int mode, Int submode)

Returns submode name, or NULL



C: int EnumProjectMarkers(int idx, bool* isrgnOut, double* posOut, double* rgnendOut, const char** nameOut, int* markrgnindexnumberOut)

EEL2: int EnumProjectMarkers(int idx, bool &isrgn, &pos, &rgnend, #name, int &markrgnindexnumber)

Lua: integer retval, boolean isrgn, number pos, number rgnend, string name, integer markrgnindexnumber = reaper.EnumProjectMarkers(integer idx)

Python: (Int retval, Int idx, Boolean isrgnOut, Float posOut, Float rgnendOut, String nameOut, Int markrgnindexnumberOut) = RPR_EnumProjectMarkers(idx, isrgnOut, posOut, rgnendOut, nameOut, markrgnindexnumberOut)



C: int EnumProjectMarkers2(ReaProject* proj, int idx, bool* isrgnOut, double* posOut, double* rgnendOut, const char** nameOut, int* markrgnindexnumberOut)

EEL2: int EnumProjectMarkers2(ReaProject proj, int idx, bool &isrgn, &pos, &rgnend, #name, int &markrgnindexnumber)

Lua: integer retval, boolean isrgn, number pos, number rgnend, string name, integer markrgnindexnumber = reaper.EnumProjectMarkers2(ReaProject proj, integer idx)

Python: (Int retval, ReaProject proj, Int idx, Boolean isrgnOut, Float posOut, Float rgnendOut, String nameOut, Int markrgnindexnumberOut) = RPR_EnumProjectMarkers2(proj, idx, isrgnOut, posOut, rgnendOut, nameOut, markrgnindexnumberOut)



C: int EnumProjectMarkers3(ReaProject* proj, int idx, bool* isrgnOut, double* posOut, double* rgnendOut, const char** nameOut, int* markrgnindexnumberOut, int* colorOut)

EEL2: int EnumProjectMarkers3(ReaProject proj, int idx, bool &isrgn, &pos, &rgnend, #name, int &markrgnindexnumber, int &color)

Lua: integer retval, boolean isrgn, number pos, number rgnend, string name, integer markrgnindexnumber, integer color = reaper.EnumProjectMarkers3(ReaProject proj, integer idx)

Python: (Int retval, ReaProject proj, Int idx, Boolean isrgnOut, Float posOut, Float rgnendOut, String nameOut, Int markrgnindexnumberOut, Int colorOut) = RPR_EnumProjectMarkers3(proj, idx, isrgnOut, posOut, rgnendOut, nameOut, markrgnindexnumberOut, colorOut)



C: ReaProject* EnumProjects(int idx, char* projfnOutOptional, int projfnOutOptional_sz)

EEL2: ReaProject EnumProjects(int idx, optional #projfn)

Lua: ReaProject retval, optional string projfn = reaper.EnumProjects(integer idx)

Python: (ReaProject retval, Int idx, String projfnOutOptional, Int projfnOutOptional_sz) = RPR_EnumProjects(idx, projfnOutOptional, projfnOutOptional_sz)

idx=-1 for current project,projfn can be NULL if not interested in filename. use idx 0x40000000 for currently rendering project, if any.



C: bool EnumProjExtState(ReaProject* proj, const char* extname, int idx, char* keyOutOptional, int keyOutOptional_sz, char* valOutOptional, int valOutOptional_sz)

EEL2: bool EnumProjExtState(ReaProject proj, "extname", int idx, optional #key, optional #val)

Lua: boolean retval, optional string key, optional string val = reaper.EnumProjExtState(ReaProject proj, string extname, integer idx)

Python: (Boolean retval, ReaProject proj, String extname, Int idx, String keyOutOptional, Int keyOutOptional_sz, String valOutOptional, Int valOutOptional_sz) = RPR_EnumProjExtState(proj, extname, idx, keyOutOptional, keyOutOptional_sz, valOutOptional, valOutOptional_sz)

Enumerate the data stored with the project for a specific extname. Returns false when there is no more data. See SetProjExtState, GetProjExtState.



C: MediaTrack* EnumRegionRenderMatrix(ReaProject* proj, int regionindex, int rendertrack)

EEL2: MediaTrack EnumRegionRenderMatrix(ReaProject proj, int regionindex, int rendertrack)

Lua: MediaTrack reaper.EnumRegionRenderMatrix(ReaProject proj, integer regionindex, integer rendertrack)

Python: MediaTrack RPR_EnumRegionRenderMatrix(ReaProject proj, Int regionindex, Int rendertrack)

Enumerate which tracks will be rendered within this region when using the region render matrix. When called with rendertrack==0, the function returns the first track that will be rendered (which may be the master track); rendertrack==1 will return the next track rendered, and so on. The function returns NULL when there are no more tracks that will be rendered within this region.



C: bool EnumTrackMIDIProgramNames(int track, int programNumber, char* programName, int programName_sz)

EEL2: bool EnumTrackMIDIProgramNames(int track, int programNumber, #programName)

Lua: boolean retval, string programName = reaper.EnumTrackMIDIProgramNames(integer track, integer programNumber, string programName)

Python: (Boolean retval, Int track, Int programNumber, String programName, Int programName_sz) = RPR_EnumTrackMIDIProgramNames(track, programNumber, programName, programName_sz)

returns false if there are no plugins on the track that support MIDI programs,or if all programs have been enumerated



C: bool EnumTrackMIDIProgramNamesEx(ReaProject* proj, MediaTrack* track, int programNumber, char* programName, int programName_sz)

EEL2: bool EnumTrackMIDIProgramNamesEx(ReaProject proj, MediaTrack track, int programNumber, #programName)

Lua: boolean retval, string programName = reaper.EnumTrackMIDIProgramNamesEx(ReaProject proj, MediaTrack track, integer programNumber, string programName)

Python: (Boolean retval, ReaProject proj, MediaTrack track, Int programNumber, String programName, Int programName_sz) = RPR_EnumTrackMIDIProgramNamesEx(proj, track, programNumber, programName, programName_sz)

returns false if there are no plugins on the track that support MIDI programs,or if all programs have been enumerated



C: int Envelope_Evaluate(TrackEnvelope* envelope, double time, double samplerate, int samplesRequested, double* valueOut, double* dVdSOut, double* ddVdSOut, double* dddVdSOut)

EEL2: int Envelope_Evaluate(TrackEnvelope envelope, time, samplerate, int samplesRequested, &value, &dVdS, &ddVdS, &dddVdS)

Lua: integer retval, number value, number dVdS, number ddVdS, number dddVdS = reaper.Envelope_Evaluate(TrackEnvelope envelope, number time, number samplerate, integer samplesRequested)

Python: (Int retval, TrackEnvelope envelope, Float time, Float samplerate, Int samplesRequested, Float valueOut, Float dVdSOut, Float ddVdSOut, Float dddVdSOut) = RPR_Envelope_Evaluate(envelope, time, samplerate, samplesRequested, valueOut, dVdSOut, ddVdSOut, dddVdSOut)

Get the effective envelope value at a given time position. samplesRequested is how long the caller expects until the next call to Envelope_Evaluate (often, the buffer block size). The return value is how many samples beyond that time position that the returned values are valid. dVdS is the change in value per sample (first derivative), ddVdS is the second derivative, dddVdS is the third derivative. See GetEnvelopeScalingMode.



C: void Envelope_FormatValue(TrackEnvelope* env, double value, char* bufOut, int bufOut_sz)

EEL2: Envelope_FormatValue(TrackEnvelope env, value, #buf)

Lua: string buf = reaper.Envelope_FormatValue(TrackEnvelope env, number value)

Python: (TrackEnvelope env, Float value, String bufOut, Int bufOut_sz) = RPR_Envelope_FormatValue(env, value, bufOut, bufOut_sz)

Formats the value of an envelope to a user-readable form



C: MediaItem_Take* Envelope_GetParentTake(TrackEnvelope* env, int* indexOut, int* index2Out)

EEL2: MediaItem_Take Envelope_GetParentTake(TrackEnvelope env, int &index, int &index2)

Lua: MediaItem_Take retval, integer index, integer index2 = reaper.Envelope_GetParentTake(TrackEnvelope env)

Python: (MediaItem_Take retval, TrackEnvelope env, Int indexOut, Int index2Out) = RPR_Envelope_GetParentTake(env, indexOut, index2Out)

If take envelope, gets the take from the envelope. If FX, indexOut set to FX index, index2Out set to parameter index, otherwise -1.



C: MediaTrack* Envelope_GetParentTrack(TrackEnvelope* env, int* indexOut, int* index2Out)

EEL2: MediaTrack Envelope_GetParentTrack(TrackEnvelope env, int &index, int &index2)

Lua: MediaTrack retval, integer index, integer index2 = reaper.Envelope_GetParentTrack(TrackEnvelope env)

Python: (MediaTrack retval, TrackEnvelope env, Int indexOut, Int index2Out) = RPR_Envelope_GetParentTrack(env, indexOut, index2Out)

If track envelope, gets the track from the envelope. If FX, indexOut set to FX index, index2Out set to parameter index, otherwise -1.



C: bool Envelope_SortPoints(TrackEnvelope* envelope)

EEL2: bool Envelope_SortPoints(TrackEnvelope envelope)

Lua: boolean reaper.Envelope_SortPoints(TrackEnvelope envelope)

Python: Boolean RPR_Envelope_SortPoints(TrackEnvelope envelope)

Sort envelope points by time. See SetEnvelopePoint, InsertEnvelopePoint.



C: bool Envelope_SortPointsEx(TrackEnvelope* envelope, int autoitem_idx)

EEL2: bool Envelope_SortPointsEx(TrackEnvelope envelope, int autoitem_idx)

Lua: boolean reaper.Envelope_SortPointsEx(TrackEnvelope envelope, integer autoitem_idx)

Python: Boolean RPR_Envelope_SortPointsEx(TrackEnvelope envelope, Int autoitem_idx)

Sort envelope points by time. autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc. See SetEnvelopePoint, InsertEnvelopePoint.



C: const char* ExecProcess(const char* cmdline, int timeoutmsec)

EEL2: bool ExecProcess(#retval, "cmdline", int timeoutmsec)

Lua: string reaper.ExecProcess(string cmdline, integer timeoutmsec)

Python: String RPR_ExecProcess(String cmdline, Int timeoutmsec)

Executes command line, returns NULL on total failure, otherwise the return value, a newline, and then the output of the command. If timeoutmsec is 0, command will be allowed to run indefinitely (recommended for large amounts of returned output). timeoutmsec is -1 for no wait/terminate, -2 for no wait and minimize



C: bool file_exists(const char* path)

EEL2: bool file_exists("path")

Lua: boolean reaper.file_exists(string path)

Python: Boolean RPR_file_exists(String path)

returns true if path points to a valid, readable file



C: int FindTempoTimeSigMarker(ReaProject* project, double time)

EEL2: int FindTempoTimeSigMarker(ReaProject project, time)

Lua: integer reaper.FindTempoTimeSigMarker(ReaProject project, number time)

Python: Int RPR_FindTempoTimeSigMarker(ReaProject project, Float time)

Find the tempo/time signature marker that falls at or before this time position (the marker that is in effect as of this time position).



C: void format_timestr(double tpos, char* buf, int buf_sz)

EEL2: format_timestr(tpos, #buf)

Lua: string buf = reaper.format_timestr(number tpos, string buf)

Python: (Float tpos, String buf, Int buf_sz) = RPR_format_timestr(tpos, buf, buf_sz)

Format tpos (which is time in seconds) as hh:mm:ss.sss. See format_timestr_pos, format_timestr_len.



C: void format_timestr_len(double tpos, char* buf, int buf_sz, double offset, int modeoverride)

EEL2: format_timestr_len(tpos, #buf, offset, int modeoverride)

Lua: string buf = reaper.format_timestr_len(number tpos, string buf, number offset, integer modeoverride)

Python: (Float tpos, String buf, Int buf_sz, Float offset, Int modeoverride) = RPR_format_timestr_len(tpos, buf, buf_sz, offset, modeoverride)

time formatting mode overrides: -1=proj default.
0=time
1=measures.beats + time
2=measures.beats
3=seconds
4=samples
5=h:m:s:f
offset is start of where the length will be calculated from



C: void format_timestr_pos(double tpos, char* buf, int buf_sz, int modeoverride)

EEL2: format_timestr_pos(tpos, #buf, int modeoverride)

Lua: string buf = reaper.format_timestr_pos(number tpos, string buf, integer modeoverride)

Python: (Float tpos, String buf, Int buf_sz, Int modeoverride) = RPR_format_timestr_pos(tpos, buf, buf_sz, modeoverride)

time formatting mode overrides: -1=proj default.
0=time
1=measures.beats + time
2=measures.beats
3=seconds
4=samples
5=h:m:s:f




C: void genGuid(GUID* g)

EEL2: genGuid(#gGUID)

Lua: string gGUID = reaper.genGuid(string gGUID)

Python: RPR_genGuid(GUID g)



C: bool get_config_var_string(const char* name, char* bufOut, int bufOut_sz)

EEL2: bool get_config_var_string("name", #buf)

Lua: boolean retval, string buf = reaper.get_config_var_string(string name)

Python: (Boolean retval, String name, String bufOut, Int bufOut_sz) = RPR_get_config_var_string(name, bufOut, bufOut_sz)

gets ini configuration variable value as string



C: const char* get_ini_file()

EEL2: bool get_ini_file(#retval)

Lua: string reaper.get_ini_file()

Python: String RPR_get_ini_file()

Get reaper.ini full filename.



C: bool GetActionShortcutDesc(KbdSectionInfo* section, int cmdID, int shortcutidx, char* descOut, int descOut_sz)

EEL2: bool GetActionShortcutDesc(KbdSectionInfo section, int cmdID, int shortcutidx, #desc)

Lua: boolean retval, string desc = reaper.GetActionShortcutDesc(KbdSectionInfo section, integer cmdID, integer shortcutidx)

Python: (Boolean retval, KbdSectionInfo section, Int cmdID, Int shortcutidx, String descOut, Int descOut_sz) = RPR_GetActionShortcutDesc(section, cmdID, shortcutidx, descOut, descOut_sz)

Get the text description of a specific shortcut for the given command ID.
See CountActionShortcuts,DeleteActionShortcut,DoActionShortcutDialog.



C: MediaItem_Take* GetActiveTake(MediaItem* item)

EEL2: MediaItem_Take GetActiveTake(MediaItem item)

Lua: MediaItem_Take reaper.GetActiveTake(MediaItem item)

Python: MediaItem_Take RPR_GetActiveTake(MediaItem item)

get the active take in this item



C: int GetAllProjectPlayStates(ReaProject* ignoreProject)

EEL2: int GetAllProjectPlayStates(ReaProject ignoreProject)

Lua: integer reaper.GetAllProjectPlayStates(ReaProject ignoreProject)

Python: Int RPR_GetAllProjectPlayStates(ReaProject ignoreProject)

returns the bitwise OR of all project play states (1=playing, 2=pause, 4=recording)



C: const char* GetAppVersion()

EEL2: bool GetAppVersion(#retval)

Lua: string reaper.GetAppVersion()

Python: String RPR_GetAppVersion()

Returns app version which may include an OS/arch signifier, such as: "6.17" (windows 32-bit), "6.17/x64" (windows 64-bit), "6.17/OSX64" (macOS 64-bit Intel), "6.17/OSX" (macOS 32-bit), "6.17/macOS-arm64", "6.17/linux-x86_64", "6.17/linux-i686", "6.17/linux-aarch64", "6.17/linux-armv7l", etc



C: int GetArmedCommand(char* secOut, int secOut_sz)

EEL2: int GetArmedCommand(#sec)

Lua: integer retval, string sec = reaper.GetArmedCommand()

Python: (Int retval, String secOut, Int secOut_sz) = RPR_GetArmedCommand(secOut, secOut_sz)

gets the currently armed command and section name (returns 0 if nothing armed). section name is empty-string for main section.



C: double GetAudioAccessorEndTime(AudioAccessor* accessor)

EEL2: double GetAudioAccessorEndTime(AudioAccessor accessor)

Lua: number reaper.GetAudioAccessorEndTime(AudioAccessor accessor)

Python: Float RPR_GetAudioAccessorEndTime(AudioAccessor accessor)

Get the end time of the audio that can be returned from this accessor. See CreateTakeAudioAccessor, CreateTrackAudioAccessor, DestroyAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorStartTime, GetAudioAccessorSamples.



C: void GetAudioAccessorHash(AudioAccessor* accessor, char* hashNeed128)

EEL2: GetAudioAccessorHash(AudioAccessor accessor, #hashNeed128)

Lua: string hashNeed128 = reaper.GetAudioAccessorHash(AudioAccessor accessor, string hashNeed128)

Python: (AudioAccessor accessor, String hashNeed128) = RPR_GetAudioAccessorHash(accessor, hashNeed128)

Deprecated. See AudioAccessorStateChanged instead.



C: int GetAudioAccessorSamples(AudioAccessor* accessor, int samplerate, int numchannels, double starttime_sec, int numsamplesperchannel, double* samplebuffer)

EEL2: int GetAudioAccessorSamples(AudioAccessor accessor, int samplerate, int numchannels, starttime_sec, int numsamplesperchannel, buffer_ptr samplebuffer)

Lua: integer reaper.GetAudioAccessorSamples(AudioAccessor accessor, integer samplerate, integer numchannels, number starttime_sec, integer numsamplesperchannel, reaper.array samplebuffer)

Python: (Int retval, AudioAccessor accessor, Int samplerate, Int numchannels, Float starttime_sec, Int numsamplesperchannel, Float samplebuffer) = RPR_GetAudioAccessorSamples(accessor, samplerate, numchannels, starttime_sec, numsamplesperchannel, samplebuffer)

Get a block of samples from the audio accessor. Samples are extracted immediately pre-FX, and returned interleaved (first sample of first channel, first sample of second channel...). Returns 0 if no audio, 1 if audio, -1 on error. See CreateTakeAudioAccessor, CreateTrackAudioAccessor, DestroyAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorStartTime, GetAudioAccessorEndTime.

This function has special handling in Python, and only returns two objects, the API function return value, and the sample buffer. Example usage:

tr = RPR_GetTrack(0, 0)
aa = RPR_CreateTrackAudioAccessor(tr)
buf = list([0]*2*1024) # 2 channels, 1024 samples each, initialized to zero
pos = 0.0
(ret, buf) = GetAudioAccessorSamples(aa, 44100, 2, pos, 1024, buf)
# buf now holds the first 2*1024 audio samples from the track.
# typically GetAudioAccessorSamples() would be called within a loop, increasing pos each time.




C: double GetAudioAccessorStartTime(AudioAccessor* accessor)

EEL2: double GetAudioAccessorStartTime(AudioAccessor accessor)

Lua: number reaper.GetAudioAccessorStartTime(AudioAccessor accessor)

Python: Float RPR_GetAudioAccessorStartTime(AudioAccessor accessor)

Get the start time of the audio that can be returned from this accessor. See CreateTakeAudioAccessor, CreateTrackAudioAccessor, DestroyAudioAccessor, AudioAccessorStateChanged, GetAudioAccessorEndTime, GetAudioAccessorSamples.



C: bool GetAudioDeviceInfo(const char* attribute, char* descOut, int descOut_sz)

EEL2: bool GetAudioDeviceInfo("attribute", #desc)

Lua: boolean retval, string desc = reaper.GetAudioDeviceInfo(string attribute)

Python: (Boolean retval, String attribute, String descOut, Int descOut_sz) = RPR_GetAudioDeviceInfo(attribute, descOut, descOut_sz)

get information about the currently open audio device. attribute can be MODE, IDENT_IN, IDENT_OUT, BSIZE, SRATE, BPS. returns false if unknown attribute or device not open.



C: int GetConfigWantsDock(const char* ident_str)

EEL2: int GetConfigWantsDock("ident_str")

Lua: integer reaper.GetConfigWantsDock(string ident_str)

Python: Int RPR_GetConfigWantsDock(String ident_str)

gets the dock ID desired by ident_str, if any



C: ReaProject* GetCurrentProjectInLoadSave()

EEL2: ReaProject GetCurrentProjectInLoadSave()

Lua: ReaProject reaper.GetCurrentProjectInLoadSave()

Python: ReaProject RPR_GetCurrentProjectInLoadSave()

returns current project if in load/save (usually only used from project_config_extension_t)



C: int GetCursorContext()

EEL2: int GetCursorContext()

Lua: integer reaper.GetCursorContext()

Python: Int RPR_GetCursorContext()

return the current cursor context: 0 if track panels, 1 if items, 2 if envelopes, otherwise unknown



C: int GetCursorContext2(bool want_last_valid)

EEL2: int GetCursorContext2(bool want_last_valid)

Lua: integer reaper.GetCursorContext2(boolean want_last_valid)

Python: Int RPR_GetCursorContext2(Boolean want_last_valid)

0 if track panels, 1 if items, 2 if envelopes, otherwise unknown (unlikely when want_last_valid is true)



C: double GetCursorPosition()

EEL2: double GetCursorPosition()

Lua: number reaper.GetCursorPosition()

Python: Float RPR_GetCursorPosition()

edit cursor position



C: double GetCursorPositionEx(ReaProject* proj)

EEL2: double GetCursorPositionEx(ReaProject proj)

Lua: number reaper.GetCursorPositionEx(ReaProject proj)

Python: Float RPR_GetCursorPositionEx(ReaProject proj)

edit cursor position



C: int GetDisplayedMediaItemColor(MediaItem* item)

EEL2: int GetDisplayedMediaItemColor(MediaItem item)

Lua: integer reaper.GetDisplayedMediaItemColor(MediaItem item)

Python: Int RPR_GetDisplayedMediaItemColor(MediaItem item)

see GetDisplayedMediaItemColor2.



C: int GetDisplayedMediaItemColor2(MediaItem* item, MediaItem_Take* take)

EEL2: int GetDisplayedMediaItemColor2(MediaItem item, MediaItem_Take take)

Lua: integer reaper.GetDisplayedMediaItemColor2(MediaItem item, MediaItem_Take take)

Python: Int RPR_GetDisplayedMediaItemColor2(MediaItem item, MediaItem_Take take)

Returns the custom take, item, or track color that is used (according to the user preference) to color the media item. The returned color is OS dependent|0x01000000 (i.e. ColorToNative(r,g,b)|0x01000000), so a return of zero means "no color", not black.



C: double GetEnvelopeInfo_Value(TrackEnvelope* env, const char* parmname)

EEL2: double GetEnvelopeInfo_Value(TrackEnvelope env, "parmname")

Lua: number reaper.GetEnvelopeInfo_Value(TrackEnvelope env, string parmname)

Python: Float RPR_GetEnvelopeInfo_Value(TrackEnvelope env, String parmname)

Gets an envelope numerical-value attribute:
I_TCPY : int : Y offset of envelope relative to parent track (may be separate lane or overlap with track contents)
I_TCPH : int : visible height of envelope
I_TCPY_USED : int : Y offset of envelope relative to parent track, exclusive of padding
I_TCPH_USED : int : visible height of envelope, exclusive of padding
P_TRACK : MediaTrack * : parent track pointer (if any)
P_DESTTRACK : MediaTrack * : destination track pointer, if on a send
P_ITEM : MediaItem * : parent item pointer (if any)
P_TAKE : MediaItem_Take * : parent take pointer (if any)
I_SEND_IDX : int : 1-based index of send in P_TRACK, or 0 if not a send
I_HWOUT_IDX : int : 1-based index of hardware output in P_TRACK or 0 if not a hardware output
I_RECV_IDX : int : 1-based index of receive in P_DESTTRACK or 0 if not a send/receive




C: bool GetEnvelopeName(TrackEnvelope* env, char* bufOut, int bufOut_sz)

EEL2: bool GetEnvelopeName(TrackEnvelope env, #buf)

Lua: boolean retval, string buf = reaper.GetEnvelopeName(TrackEnvelope env)

Python: (Boolean retval, TrackEnvelope env, String bufOut, Int bufOut_sz) = RPR_GetEnvelopeName(env, bufOut, bufOut_sz)



C: bool GetEnvelopePoint(TrackEnvelope* envelope, int ptidx, double* timeOut, double* valueOut, int* shapeOut, double* tensionOut, bool* selectedOut)

EEL2: bool GetEnvelopePoint(TrackEnvelope envelope, int ptidx, &time, &value, int &shape, &tension, bool &selected)

Lua: boolean retval, number time, number value, integer shape, number tension, boolean selected = reaper.GetEnvelopePoint(TrackEnvelope envelope, integer ptidx)

Python: (Boolean retval, TrackEnvelope envelope, Int ptidx, Float timeOut, Float valueOut, Int shapeOut, Float tensionOut, Boolean selectedOut) = RPR_GetEnvelopePoint(envelope, ptidx, timeOut, valueOut, shapeOut, tensionOut, selectedOut)

Get the attributes of an envelope point. See GetEnvelopePointEx.



C: int GetEnvelopePointByTime(TrackEnvelope* envelope, double time)

EEL2: int GetEnvelopePointByTime(TrackEnvelope envelope, time)

Lua: integer reaper.GetEnvelopePointByTime(TrackEnvelope envelope, number time)

Python: Int RPR_GetEnvelopePointByTime(TrackEnvelope envelope, Float time)

Returns the envelope point at or immediately prior to the given time position. See GetEnvelopePointByTimeEx.



C: int GetEnvelopePointByTimeEx(TrackEnvelope* envelope, int autoitem_idx, double time)

EEL2: int GetEnvelopePointByTimeEx(TrackEnvelope envelope, int autoitem_idx, time)

Lua: integer reaper.GetEnvelopePointByTimeEx(TrackEnvelope envelope, integer autoitem_idx, number time)

Python: Int RPR_GetEnvelopePointByTimeEx(TrackEnvelope envelope, Int autoitem_idx, Float time)

Returns the envelope point at or immediately prior to the given time position.
autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.
For automation items, pass autoitem_idx|0x10000000 to base ptidx on the number of points in one full loop iteration,
even if the automation item is trimmed so that not all points are visible.
Otherwise, ptidx will be based on the number of visible points in the automation item, including all loop iterations.
See GetEnvelopePointEx, SetEnvelopePointEx, InsertEnvelopePointEx, DeleteEnvelopePointEx.



C: bool GetEnvelopePointEx(TrackEnvelope* envelope, int autoitem_idx, int ptidx, double* timeOut, double* valueOut, int* shapeOut, double* tensionOut, bool* selectedOut)

EEL2: bool GetEnvelopePointEx(TrackEnvelope envelope, int autoitem_idx, int ptidx, &time, &value, int &shape, &tension, bool &selected)

Lua: boolean retval, number time, number value, integer shape, number tension, boolean selected = reaper.GetEnvelopePointEx(TrackEnvelope envelope, integer autoitem_idx, integer ptidx)

Python: (Boolean retval, TrackEnvelope envelope, Int autoitem_idx, Int ptidx, Float timeOut, Float valueOut, Int shapeOut, Float tensionOut, Boolean selectedOut) = RPR_GetEnvelopePointEx(envelope, autoitem_idx, ptidx, timeOut, valueOut, shapeOut, tensionOut, selectedOut)

Get the attributes of an envelope point.
autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.
For automation items, pass autoitem_idx|0x10000000 to base ptidx on the number of points in one full loop iteration,
even if the automation item is trimmed so that not all points are visible.
Otherwise, ptidx will be based on the number of visible points in the automation item, including all loop iterations.
See CountEnvelopePointsEx, SetEnvelopePointEx, InsertEnvelopePointEx, DeleteEnvelopePointEx.



C: int GetEnvelopeScalingMode(TrackEnvelope* env)

EEL2: int GetEnvelopeScalingMode(TrackEnvelope env)

Lua: integer reaper.GetEnvelopeScalingMode(TrackEnvelope env)

Python: Int RPR_GetEnvelopeScalingMode(TrackEnvelope env)

Returns the envelope scaling mode: 0=no scaling, 1=fader scaling. All API functions deal with raw envelope point values, to convert raw from/to scaled values see ScaleFromEnvelopeMode, ScaleToEnvelopeMode.



C: bool GetEnvelopeStateChunk(TrackEnvelope* env, char* strNeedBig, int strNeedBig_sz, bool isundoOptional)

EEL2: bool GetEnvelopeStateChunk(TrackEnvelope env, #str, bool isundo)

Lua: boolean retval, string str = reaper.GetEnvelopeStateChunk(TrackEnvelope env, string str, boolean isundo)

Python: (Boolean retval, TrackEnvelope env, String strNeedBig, Int strNeedBig_sz, Boolean isundoOptional) = RPR_GetEnvelopeStateChunk(env, strNeedBig, strNeedBig_sz, isundoOptional)

Gets the RPPXML state of an envelope, returns true if successful. Undo flag is a performance/caching hint.



C: int GetEnvelopeUIState(TrackEnvelope* env)

EEL2: int GetEnvelopeUIState(TrackEnvelope env)

Lua: integer reaper.GetEnvelopeUIState(TrackEnvelope env)

Python: Int RPR_GetEnvelopeUIState(TrackEnvelope env)

gets information on the UI state of an envelope: returns &1 if automation/modulation is playing back, &2 if automation is being actively written, &4 if the envelope recently had an effective automation mode change



C: const char* GetExePath()

EEL2: bool GetExePath(#retval)

Lua: string reaper.GetExePath()

Python: String RPR_GetExePath()

returns path of REAPER.exe (not including EXE), i.e. C:\Program Files\REAPER



C: const char* GetExtState(const char* section, const char* key)

EEL2: bool GetExtState(#retval, "section", "key")

Lua: string reaper.GetExtState(string section, string key)

Python: String RPR_GetExtState(String section, String key)

Get the extended state value for a specific section and key. See SetExtState, DeleteExtState, HasExtState.



C: int GetFocusedFX(int* tracknumberOut, int* itemnumberOut, int* fxnumberOut)

EEL2: int GetFocusedFX(int &tracknumber, int &itemnumber, int &fxnumber)

Lua: integer retval, integer tracknumber, integer itemnumber, integer fxnumber = reaper.GetFocusedFX()

Python: (Int retval, Int tracknumberOut, Int itemnumberOut, Int fxnumberOut) = RPR_GetFocusedFX(tracknumberOut, itemnumberOut, fxnumberOut)

This function is deprecated (returns GetFocusedFX2()&3), see GetTouchedOrFocusedFX.



C: int GetFocusedFX2(int* tracknumberOut, int* itemnumberOut, int* fxnumberOut)

EEL2: int GetFocusedFX2(int &tracknumber, int &itemnumber, int &fxnumber)

Lua: integer retval, integer tracknumber, integer itemnumber, integer fxnumber = reaper.GetFocusedFX2()

Python: (Int retval, Int tracknumberOut, Int itemnumberOut, Int fxnumberOut) = RPR_GetFocusedFX2(tracknumberOut, itemnumberOut, fxnumberOut)

Return value has 1 set if track FX, 2 if take/item FX, 4 set if FX is no longer focused but still open. tracknumber==0 means the master track, 1 means track 1, etc. itemnumber is zero-based (or -1 if not an item). For interpretation of fxnumber, see GetLastTouchedFX. Deprecated, see GetTouchedOrFocusedFX



C: int GetFreeDiskSpaceForRecordPath(ReaProject* proj, int pathidx)

EEL2: int GetFreeDiskSpaceForRecordPath(ReaProject proj, int pathidx)

Lua: integer reaper.GetFreeDiskSpaceForRecordPath(ReaProject proj, integer pathidx)

Python: Int RPR_GetFreeDiskSpaceForRecordPath(ReaProject proj, Int pathidx)

returns free disk space in megabytes, pathIdx 0 for normal, 1 for alternate.



C: TrackEnvelope* GetFXEnvelope(MediaTrack* track, int fxindex, int parameterindex, bool create)

EEL2: TrackEnvelope GetFXEnvelope(MediaTrack track, int fxindex, int parameterindex, bool create)

Lua: TrackEnvelope reaper.GetFXEnvelope(MediaTrack track, integer fxindex, integer parameterindex, boolean create)

Python: TrackEnvelope RPR_GetFXEnvelope(MediaTrack track, Int fxindex, Int parameterindex, Boolean create)

Returns the FX parameter envelope. If the envelope does not exist and create=true, the envelope will be created. If the envelope already exists and is bypassed and create=true, then the envelope will be unbypassed.



C: int GetGlobalAutomationOverride()

EEL2: int GetGlobalAutomationOverride()

Lua: integer reaper.GetGlobalAutomationOverride()

Python: Int RPR_GetGlobalAutomationOverride()

return -1=no override, 0=trim/read, 1=read, 2=touch, 3=write, 4=latch, 5=bypass



C: double GetHZoomLevel()

EEL2: double GetHZoomLevel()

Lua: number reaper.GetHZoomLevel()

Python: Float RPR_GetHZoomLevel()

returns pixels/second



C: double GetInputActivityLevel(int input_id)

EEL2: double GetInputActivityLevel(int input_id)

Lua: number reaper.GetInputActivityLevel(integer input_id)

Python: Float RPR_GetInputActivityLevel(Int input_id)

returns approximate input level if available, 0-511 mono inputs, |1024 for stereo pairs, 4096+devidx*32 for MIDI devices



C: const char* GetInputChannelName(int channelIndex)

EEL2: bool GetInputChannelName(#retval, int channelIndex)

Lua: string reaper.GetInputChannelName(integer channelIndex)

Python: String RPR_GetInputChannelName(Int channelIndex)



C: void GetInputOutputLatency(int* inputlatencyOut, int* outputLatencyOut)

EEL2: GetInputOutputLatency(int &inputlatency, int &outputLatency)

Lua: integer inputlatency, integer outputLatency = reaper.GetInputOutputLatency()

Python: (Int inputlatencyOut, Int outputLatencyOut) = RPR_GetInputOutputLatency(inputlatencyOut, outputLatencyOut)

Gets the audio device input/output latency in samples



C: double GetItemEditingTime2(PCM_source** which_itemOut, int* flagsOut)

EEL2: double GetItemEditingTime2(PCM_source &which_item, int &flags)

Lua: number, PCM_source which_item, integer flags = reaper.GetItemEditingTime2()

Python: (Float retval, PCM_source* which_itemOut, Int flagsOut) = RPR_GetItemEditingTime2(which_itemOut, flagsOut)

returns time of relevant edit, set which_item to the pcm_source (if applicable), flags (if specified) will be set to 1 for edge resizing, 2 for fade change, 4 for item move, 8 for item slip edit (edit cursor time or start of item)



C: MediaItem* GetItemFromPoint(int screen_x, int screen_y, bool allow_locked, MediaItem_Take** takeOutOptional)

EEL2: MediaItem GetItemFromPoint(int screen_x, int screen_y, bool allow_locked, MediaItem_Take &take)

Lua: MediaItem, MediaItem_Take take = reaper.GetItemFromPoint(integer screen_x, integer screen_y, boolean allow_locked)

Python: MediaItem RPR_GetItemFromPoint(Int screen_x, Int screen_y, Boolean allow_locked, MediaItem_Take* takeOutOptional)

Returns the first item at the screen coordinates specified. If allow_locked is false, locked items are ignored. If takeOutOptional specified, returns the take hit. See GetThingFromPoint.



C: ReaProject* GetItemProjectContext(MediaItem* item)

EEL2: ReaProject GetItemProjectContext(MediaItem item)

Lua: ReaProject reaper.GetItemProjectContext(MediaItem item)

Python: ReaProject RPR_GetItemProjectContext(MediaItem item)



C: bool GetItemStateChunk(MediaItem* item, char* strNeedBig, int strNeedBig_sz, bool isundoOptional)

EEL2: bool GetItemStateChunk(MediaItem item, #str, bool isundo)

Lua: boolean retval, string str = reaper.GetItemStateChunk(MediaItem item, string str, boolean isundo)

Python: (Boolean retval, MediaItem item, String strNeedBig, Int strNeedBig_sz, Boolean isundoOptional) = RPR_GetItemStateChunk(item, strNeedBig, strNeedBig_sz, isundoOptional)

Gets the RPPXML state of an item, returns true if successful. Undo flag is a performance/caching hint.



C: const char* GetLastColorThemeFile()

EEL2: bool GetLastColorThemeFile(#retval)

Lua: string reaper.GetLastColorThemeFile()

Python: String RPR_GetLastColorThemeFile()



C: void GetLastMarkerAndCurRegion(ReaProject* proj, double time, int* markeridxOut, int* regionidxOut)

EEL2: GetLastMarkerAndCurRegion(ReaProject proj, time, int &markeridx, int &regionidx)

Lua: integer markeridx, integer regionidx = reaper.GetLastMarkerAndCurRegion(ReaProject proj, number time)

Python: (ReaProject proj, Float time, Int markeridxOut, Int regionidxOut) = RPR_GetLastMarkerAndCurRegion(proj, time, markeridxOut, regionidxOut)

Get the last project marker before time, and/or the project region that includes time. markeridx and regionidx are returned not necessarily as the displayed marker/region index, but as the index that can be passed to EnumProjectMarkers. Either or both of markeridx and regionidx may be NULL. See EnumProjectMarkers.



C: bool GetLastTouchedFX(int* tracknumberOut, int* fxnumberOut, int* paramnumberOut)

EEL2: bool GetLastTouchedFX(int &tracknumber, int &fxnumber, int &paramnumber)

Lua: boolean retval, integer tracknumber, integer fxnumber, integer paramnumber = reaper.GetLastTouchedFX()

Python: (Boolean retval, Int tracknumberOut, Int fxnumberOut, Int paramnumberOut) = RPR_GetLastTouchedFX(tracknumberOut, fxnumberOut, paramnumberOut)

Returns true if the last touched FX parameter is valid, false otherwise. The low word of tracknumber is the 1-based track index -- 0 means the master track, 1 means track 1, etc. If the high word of tracknumber is nonzero, it refers to the 1-based item index (1 is the first item on the track, etc). For track FX, the low 24 bits of fxnumber refer to the FX index in the chain, and if the next 8 bits are 01, then the FX is record FX. For item FX, the low word defines the FX index in the chain, and the high word defines the take number. Deprecated, see GetTouchedOrFocusedFX.



C: MediaTrack* GetLastTouchedTrack()

EEL2: MediaTrack GetLastTouchedTrack()

Lua: MediaTrack reaper.GetLastTouchedTrack()

Python: MediaTrack RPR_GetLastTouchedTrack()



C: HWND GetMainHwnd()

EEL2: HWND GetMainHwnd()

Lua: HWND reaper.GetMainHwnd()

Python: HWND RPR_GetMainHwnd()



C: int GetMasterMuteSoloFlags()

EEL2: int GetMasterMuteSoloFlags()

Lua: integer reaper.GetMasterMuteSoloFlags()

Python: Int RPR_GetMasterMuteSoloFlags()

&1=master mute,&2=master solo. This is deprecated as you can just query the master track as well.



C: MediaTrack* GetMasterTrack(ReaProject* proj)

EEL2: MediaTrack GetMasterTrack(ReaProject proj)

Lua: MediaTrack reaper.GetMasterTrack(ReaProject proj)

Python: MediaTrack RPR_GetMasterTrack(ReaProject proj)



C: int GetMasterTrackVisibility()

EEL2: int GetMasterTrackVisibility()

Lua: integer reaper.GetMasterTrackVisibility()

Python: Int RPR_GetMasterTrackVisibility()

returns &1 if the master track is visible in the TCP, &2 if NOT visible in the mixer. See SetMasterTrackVisibility.



C: int GetMaxMidiInputs()

EEL2: int GetMaxMidiInputs()

Lua: integer reaper.GetMaxMidiInputs()

Python: Int RPR_GetMaxMidiInputs()

returns max dev for midi inputs/outputs



C: int GetMaxMidiOutputs()

EEL2: int GetMaxMidiOutputs()

Lua: integer reaper.GetMaxMidiOutputs()

Python: Int RPR_GetMaxMidiOutputs()



C: int GetMediaFileMetadata(PCM_source* mediaSource, const char* identifier, char* bufOutNeedBig, int bufOutNeedBig_sz)

EEL2: int GetMediaFileMetadata(PCM_source mediaSource, "identifier", #buf)

Lua: integer retval, string buf = reaper.GetMediaFileMetadata(PCM_source mediaSource, string identifier)

Python: (Int retval, PCM_source mediaSource, String identifier, String bufOutNeedBig, Int bufOutNeedBig_sz) = RPR_GetMediaFileMetadata(mediaSource, identifier, bufOutNeedBig, bufOutNeedBig_sz)

Get text-based metadata from a media file for a given identifier. Call with identifier="" to list all identifiers contained in the file, separated by newlines. May return "[Binary data]" for metadata that REAPER doesn't handle.



C: MediaItem* GetMediaItem(ReaProject* proj, int itemidx)

EEL2: MediaItem GetMediaItem(ReaProject proj, int itemidx)

Lua: MediaItem reaper.GetMediaItem(ReaProject proj, integer itemidx)

Python: MediaItem RPR_GetMediaItem(ReaProject proj, Int itemidx)

get an item from a project by item count (zero-based) (proj=0 for active project)



C: MediaTrack* GetMediaItem_Track(MediaItem* item)

EEL2: MediaTrack GetMediaItem_Track(MediaItem item)

Lua: MediaTrack reaper.GetMediaItem_Track(MediaItem item)

Python: MediaTrack RPR_GetMediaItem_Track(MediaItem item)

Get parent track of media item



C: double GetMediaItemInfo_Value(MediaItem* item, const char* parmname)

EEL2: double GetMediaItemInfo_Value(MediaItem item, "parmname")

Lua: number reaper.GetMediaItemInfo_Value(MediaItem item, string parmname)

Python: Float RPR_GetMediaItemInfo_Value(MediaItem item, String parmname)

Get media item numerical-value attributes.
B_MUTE : bool * : muted (item solo overrides). setting this value will clear C_MUTE_SOLO.
B_MUTE_ACTUAL : bool * : muted (ignores solo). setting this value will not affect C_MUTE_SOLO.
C_LANEPLAYS : char * : in fixed lane tracks, 0=this item lane does not play, 1=this item lane plays exclusively, 2=this item lane plays and other lanes also play, -1=this item is on a non-visible, non-playing lane on a non-fixed-lane track (read-only)
C_MUTE_SOLO : char * : solo override (-1=soloed, 0=no override, 1=unsoloed). note that this API does not automatically unsolo other items when soloing (nor clear the unsolos when clearing the last soloed item), it must be done by the caller via action or via this API.
B_LOOPSRC : bool * : loop source
B_ALLTAKESPLAY : bool * : all takes play
B_UISEL : bool * : selected in arrange view
C_BEATATTACHMODE : char * : item timebase, -1=track or project default, 1=beats (position, length, rate), 2=beats (position only). for auto-stretch timebase: C_BEATATTACHMODE=1, C_AUTOSTRETCH=1
C_AUTOSTRETCH: : char * : auto-stretch at project tempo changes, 1=enabled, requires C_BEATATTACHMODE=1
C_LOCK : char * : locked, &1=locked
D_VOL : double * : item volume, 0=-inf, 0.5=-6dB, 1=+0dB, 2=+6dB, etc
D_POSITION : double * : item position in seconds
D_LENGTH : double * : item length in seconds
D_SNAPOFFSET : double * : item snap offset in seconds
D_FADEINLEN : double * : item manual fadein length in seconds
D_FADEOUTLEN : double * : item manual fadeout length in seconds
D_FADEINDIR : double * : item fadein curvature, -1..1
D_FADEOUTDIR : double * : item fadeout curvature, -1..1
D_FADEINLEN_AUTO : double * : item auto-fadein length in seconds, -1=no auto-fadein
D_FADEOUTLEN_AUTO : double * : item auto-fadeout length in seconds, -1=no auto-fadeout
C_FADEINSHAPE : int * : fadein shape, 0..6, 0=linear
C_FADEOUTSHAPE : int * : fadeout shape, 0..6, 0=linear
I_GROUPID : int * : group ID, 0=no group
I_LASTY : int * : Y-position (relative to top of track) in pixels (read-only)
I_LASTH : int * : height in pixels (read-only)
I_CUSTOMCOLOR : int * : custom color, OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). If you do not |0x1000000, then it will not be used, but will store the color
I_CURTAKE : int * : active take number
IP_ITEMNUMBER : int : item number on this track (read-only, returns the item number directly)
F_FREEMODE_Y : float * : free item positioning or fixed lane Y-position. 0=top of track, 1.0=bottom of track
F_FREEMODE_H : float * : free item positioning or fixed lane height. 0.5=half the track height, 1.0=full track height
I_FIXEDLANE : int * : fixed lane of item (fine to call with setNewValue, but returned value is read-only)
B_FIXEDLANE_HIDDEN : bool * : true if displaying only one fixed lane and this item is in a different lane (read-only)
P_TRACK : MediaTrack * : (read-only)




C: int GetMediaItemNumTakes(MediaItem* item)

EEL2: int GetMediaItemNumTakes(MediaItem item)

Lua: integer reaper.GetMediaItemNumTakes(MediaItem item)

Python: Int RPR_GetMediaItemNumTakes(MediaItem item)



C: MediaItem_Take* GetMediaItemTake(MediaItem* item, int tk)

EEL2: MediaItem_Take GetMediaItemTake(MediaItem item, int tk)

Lua: MediaItem_Take reaper.GetMediaItemTake(MediaItem item, integer tk)

Python: MediaItem_Take RPR_GetMediaItemTake(MediaItem item, Int tk)



C: MediaItem* GetMediaItemTake_Item(MediaItem_Take* take)

EEL2: MediaItem GetMediaItemTake_Item(MediaItem_Take take)

Lua: MediaItem reaper.GetMediaItemTake_Item(MediaItem_Take take)

Python: MediaItem RPR_GetMediaItemTake_Item(MediaItem_Take take)

Get parent item of media item take



C: int GetMediaItemTake_Peaks(MediaItem_Take* take, double peakrate, double starttime, int numchannels, int numsamplesperchannel, int want_extra_type, double* buf)

EEL2: int GetMediaItemTake_Peaks(MediaItem_Take take, peakrate, starttime, int numchannels, int numsamplesperchannel, int want_extra_type, buffer_ptr buf)

Lua: integer reaper.GetMediaItemTake_Peaks(MediaItem_Take take, number peakrate, number starttime, integer numchannels, integer numsamplesperchannel, integer want_extra_type, reaper.array buf)

Python: (Int retval, MediaItem_Take take, Float peakrate, Float starttime, Int numchannels, Int numsamplesperchannel, Int want_extra_type, Float buf) = RPR_GetMediaItemTake_Peaks(take, peakrate, starttime, numchannels, numsamplesperchannel, want_extra_type, buf)

Gets block of peak samples to buf. Note that the peak samples are interleaved, but in two or three blocks (maximums, then minimums, then extra). Return value has 20 bits of returned sample count, then 4 bits of output_mode (0xf00000), then a bit to signify whether extra_type was available (0x1000000). extra_type can be 115 ('s') for spectral information, which will return peak samples as integers with the low 15 bits frequency, next 14 bits tonality.



C: PCM_source* GetMediaItemTake_Source(MediaItem_Take* take)

EEL2: PCM_source GetMediaItemTake_Source(MediaItem_Take take)

Lua: PCM_source reaper.GetMediaItemTake_Source(MediaItem_Take take)

Python: PCM_source RPR_GetMediaItemTake_Source(MediaItem_Take take)

Get media source of media item take



C: MediaTrack* GetMediaItemTake_Track(MediaItem_Take* take)

EEL2: MediaTrack GetMediaItemTake_Track(MediaItem_Take take)

Lua: MediaTrack reaper.GetMediaItemTake_Track(MediaItem_Take take)

Python: MediaTrack RPR_GetMediaItemTake_Track(MediaItem_Take take)

Get parent track of media item take



C: MediaItem_Take* GetMediaItemTakeByGUID(ReaProject* project, const GUID* guid)

EEL2: MediaItem_Take GetMediaItemTakeByGUID(ReaProject project, "guidGUID")

Lua: MediaItem_Take reaper.GetMediaItemTakeByGUID(ReaProject project, string guidGUID)

Python: MediaItem_Take RPR_GetMediaItemTakeByGUID(ReaProject project, const GUID guid)



C: double GetMediaItemTakeInfo_Value(MediaItem_Take* take, const char* parmname)

EEL2: double GetMediaItemTakeInfo_Value(MediaItem_Take take, "parmname")

Lua: number reaper.GetMediaItemTakeInfo_Value(MediaItem_Take take, string parmname)

Python: Float RPR_GetMediaItemTakeInfo_Value(MediaItem_Take take, String parmname)

Get media item take numerical-value attributes.
D_STARTOFFS : double * : start offset in source media, in seconds
D_VOL : double * : take volume, 0=-inf, 0.5=-6dB, 1=+0dB, 2=+6dB, etc, negative if take polarity is flipped
D_PAN : double * : take pan, -1..1
D_PANLAW : double * : take pan law, -1=default, 0.5=-6dB, 1.0=+0dB, etc
D_PLAYRATE : double * : take playback rate, 0.5=half speed, 1=normal, 2=double speed, etc
D_PITCH : double * : take pitch adjustment in semitones, -12=one octave down, 0=normal, +12=one octave up, etc
B_PPITCH : bool * : preserve pitch when changing playback rate
I_LASTY : int * : Y-position (relative to top of track) in pixels (read-only)
I_LASTH : int * : height in pixels (read-only)
I_CHANMODE : int * : channel mode, 0=normal, 1=reverse stereo, 2=downmix, 3=left, 4=right
I_PITCHMODE : int * : pitch shifter mode, -1=project default, otherwise high 2 bytes=shifter, low 2 bytes=parameter
I_STRETCHFLAGS : int * : stretch marker flags (&7 mask for mode override: 0=default, 1=balanced, 2/3/6=tonal, 4=transient, 5=no pre-echo)
F_STRETCHFADESIZE : float * : stretch marker fade size in seconds (0.0025 default)
I_RECPASSID : int * : record pass ID
I_TAKEFX_NCH : int * : number of internal audio channels for per-take FX to use (OK to call with setNewValue, but the returned value is read-only)
I_CUSTOMCOLOR : int * : custom color, OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). If you do not |0x1000000, then it will not be used, but will store the color
IP_TAKENUMBER : int : take number (read-only, returns the take number directly)
P_TRACK : pointer to MediaTrack (read-only)
P_ITEM : pointer to MediaItem (read-only)
P_SOURCE : PCM_source *. Note that if setting this, you should first retrieve the old source, set the new, THEN delete the old.




C: MediaTrack* GetMediaItemTrack(MediaItem* item)

EEL2: MediaTrack GetMediaItemTrack(MediaItem item)

Lua: MediaTrack reaper.GetMediaItemTrack(MediaItem item)

Python: MediaTrack RPR_GetMediaItemTrack(MediaItem item)



C: void GetMediaSourceFileName(PCM_source* source, char* filenamebufOut, int filenamebufOut_sz)

EEL2: GetMediaSourceFileName(PCM_source source, #filenamebuf)

Lua: string filenamebuf = reaper.GetMediaSourceFileName(PCM_source source)

Python: (PCM_source source, String filenamebufOut, Int filenamebufOut_sz) = RPR_GetMediaSourceFileName(source, filenamebufOut, filenamebufOut_sz)

Copies the media source filename to filenamebuf. Note that in-project MIDI media sources have no associated filename. See GetMediaSourceParent.



C: double GetMediaSourceLength(PCM_source* source, bool* lengthIsQNOut)

EEL2: double GetMediaSourceLength(PCM_source source, bool &lengthIsQN)

Lua: number retval, boolean lengthIsQN = reaper.GetMediaSourceLength(PCM_source source)

Python: (Float retval, PCM_source source, Boolean lengthIsQNOut) = RPR_GetMediaSourceLength(source, lengthIsQNOut)

Returns the length of the source media. If the media source is beat-based, the length will be in quarter notes, otherwise it will be in seconds.



C: int GetMediaSourceNumChannels(PCM_source* source)

EEL2: int GetMediaSourceNumChannels(PCM_source source)

Lua: integer reaper.GetMediaSourceNumChannels(PCM_source source)

Python: Int RPR_GetMediaSourceNumChannels(PCM_source source)

Returns the number of channels in the source media.



C: PCM_source* GetMediaSourceParent(PCM_source* src)

EEL2: PCM_source GetMediaSourceParent(PCM_source src)

Lua: PCM_source reaper.GetMediaSourceParent(PCM_source src)

Python: PCM_source RPR_GetMediaSourceParent(PCM_source src)

Returns the parent source, or NULL if src is the root source. This can be used to retrieve the parent properties of sections or reversed sources for example.



C: int GetMediaSourceSampleRate(PCM_source* source)

EEL2: int GetMediaSourceSampleRate(PCM_source source)

Lua: integer reaper.GetMediaSourceSampleRate(PCM_source source)

Python: Int RPR_GetMediaSourceSampleRate(PCM_source source)

Returns the sample rate. MIDI source media will return zero.



C: void GetMediaSourceType(PCM_source* source, char* typebufOut, int typebufOut_sz)

EEL2: GetMediaSourceType(PCM_source source, #typebuf)

Lua: string typebuf = reaper.GetMediaSourceType(PCM_source source)

Python: (PCM_source source, String typebufOut, Int typebufOut_sz) = RPR_GetMediaSourceType(source, typebufOut, typebufOut_sz)

copies the media source type ("WAV", "MIDI", etc) to typebuf



C: double GetMediaTrackInfo_Value(MediaTrack* tr, const char* parmname)

EEL2: double GetMediaTrackInfo_Value(MediaTrack tr, "parmname")

Lua: number reaper.GetMediaTrackInfo_Value(MediaTrack tr, string parmname)

Python: Float RPR_GetMediaTrackInfo_Value(MediaTrack tr, String parmname)

Get track numerical-value attributes.
B_MUTE : bool * : muted
B_PHASE : bool * : track phase inverted
B_RECMON_IN_EFFECT : bool * : record monitoring in effect (current audio-thread playback state, read-only)
IP_TRACKNUMBER : int : track number 1-based, 0=not found, -1=master track (read-only, returns the int directly)
I_SOLO : int * : soloed, 0=not soloed, 1=soloed, 2=soloed in place, 5=safe soloed, 6=safe soloed in place
B_SOLO_DEFEAT : bool * : when set, if anything else is soloed and this track is not muted, this track acts soloed
I_FXEN : int * : fx enabled, 0=bypassed, !0=fx active
I_RECARM : int * : record armed, 0=not record armed, 1=record armed
I_RECINPUT : int * : record input, <0=no input. if 4096 set, input is MIDI and low 5 bits represent channel (0=all, 1-16=only chan), next 6 bits represent physical input (63=all, 62=VKB). If 4096 is not set, low 10 bits (0..1023) are input start channel (ReaRoute/Loopback start at 512). If 2048 is set, input is multichannel input (using track channel count), or if 1024 is set, input is stereo input, otherwise input is mono.
I_RECMODE : int * : record mode, 0=input, 1=stereo out, 2=none, 3=stereo out w/latency compensation, 4=midi output, 5=mono out, 6=mono out w/ latency compensation, 7=midi overdub, 8=midi replace
I_RECMODE_FLAGS : int * : record mode flags, &3=output recording mode (0=post fader, 1=pre-fx, 2=post-fx/pre-fader)
I_RECMON : int * : record monitoring, 0=off, 1=normal, 2=not when playing (tape style)
I_RECMONITEMS : int * : monitor items while recording, 0=off, 1=on
B_AUTO_RECARM : bool * : automatically set record arm when selected (does not immediately affect recarm state, script should set directly if desired)
I_VUMODE : int * : track vu mode, &1:disabled, &30==0:stereo peaks, &30==2:multichannel peaks, &30==4:stereo RMS, &30==8:combined RMS, &30==12:LUFS-M, &30==16:LUFS-S (readout=max), &30==20:LUFS-S (readout=current), &32:LUFS calculation on channels 1+2 only
I_AUTOMODE : int * : track automation mode, 0=trim/off, 1=read, 2=touch, 3=write, 4=latch
I_NCHAN : int * : number of track channels, 2-128, even numbers only
I_SELECTED : int * : track selected, 0=unselected, 1=selected
I_WNDH : int * : current TCP window height in pixels including envelopes (read-only)
I_TCPH : int * : current TCP window height in pixels not including envelopes (read-only)
I_TCPY : int * : current TCP window Y-position in pixels relative to top of arrange view (read-only)
I_MCPX : int * : current MCP X-position in pixels relative to mixer container (read-only)
I_MCPY : int * : current MCP Y-position in pixels relative to mixer container (read-only)
I_MCPW : int * : current MCP width in pixels (read-only)
I_MCPH : int * : current MCP height in pixels (read-only)
I_FOLDERDEPTH : int * : folder depth change, 0=normal, 1=track is a folder parent, -1=track is the last in the innermost folder, -2=track is the last in the innermost and next-innermost folders, etc
I_FOLDERCOMPACT : int * : folder collapsed state (only valid on folders), 0=normal, 1=collapsed, 2=fully collapsed
I_MIDIHWOUT : int * : track midi hardware output index, <0=disabled, low 5 bits are which channels (0=all, 1-16), next 5 bits are output device index (0-31)
I_PERFFLAGS : int * : track performance flags, &1=no media buffering, &2=no anticipative FX
I_CUSTOMCOLOR : int * : custom color, OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). If you do not |0x1000000, then it will not be used, but will store the color
I_HEIGHTOVERRIDE : int * : custom height override for TCP window, 0 for none, otherwise size in pixels
I_SPACER : int * : 1=TCP track spacer above this trackB_HEIGHTLOCK : bool * : track height lock (must set I_HEIGHTOVERRIDE before locking)
D_VOL : double * : trim volume of track, 0=-inf, 0.5=-6dB, 1=+0dB, 2=+6dB, etc
D_PAN : double * : trim pan of track, -1..1
D_WIDTH : double * : width of track, -1..1
D_DUALPANL : double * : dualpan position 1, -1..1, only if I_PANMODE==6
D_DUALPANR : double * : dualpan position 2, -1..1, only if I_PANMODE==6
I_PANMODE : int * : pan mode, 0=classic 3.x, 3=new balance, 5=stereo pan, 6=dual pan
D_PANLAW : double * : pan law of track, <0=project default, 0.5=-6dB, 0.707..=-3dB, 1=+0dB, 1.414..=-3dB with gain compensation, 2=-6dB with gain compensation, etc
I_PANLAW_FLAGS : int * : pan law flags, 0=sine taper, 1=hybrid taper with deprecated behavior when gain compensation enabled, 2=linear taper, 3=hybrid taper
P_ENV:<envchunkname or P_ENV:{GUID... : TrackEnvelope * : (read-only) chunkname can be <VOLENV, <PANENV, etc; GUID is the stringified envelope GUID.
B_SHOWINMIXER : bool * : track control panel visible in mixer (do not use on master track)
B_SHOWINTCP : bool * : track control panel visible in arrange view (do not use on master track)
B_MAINSEND : bool * : track sends audio to parent
C_MAINSEND_OFFS : char * : channel offset of track send to parent
C_MAINSEND_NCH : char * : channel count of track send to parent (0=use all child track channels, 1=use one channel only)
I_FREEMODE : int * : 1=track free item positioning enabled, 2=track fixed lanes enabled (call UpdateTimeline() after changing)
I_NUMFIXEDLANES : int * : number of track fixed lanes (fine to call with setNewValue, but returned value is read-only)
C_LANESCOLLAPSED : char * : fixed lane collapse state (1=lanes collapsed, 2=track displays as non-fixed-lanes but hidden lanes exist)
C_LANEPLAYS:N : char * : on fixed lane tracks, 0=lane N does not play, 1=lane N plays exclusively, 2=lane N plays and other lanes also play (fine to call with setNewValue, but returned value is read-only)
C_ALLLANESPLAY : char * : on fixed lane tracks, 0=no lanes play, 1=all lanes play, 2=some lanes play (fine to call with setNewValue 0 or 1, but returned value is read-only)
C_BEATATTACHMODE : char * : track timebase, -1=project default, 0=time, 1=beats (position, length, rate), 2=beats (position only)
F_MCP_FXSEND_SCALE : float * : scale of fx+send area in MCP (0=minimum allowed, 1=maximum allowed)
F_MCP_FXPARM_SCALE : float * : scale of fx parameter area in MCP (0=minimum allowed, 1=maximum allowed)
F_MCP_SENDRGN_SCALE : float * : scale of send area as proportion of the fx+send total area (0=minimum allowed, 1=maximum allowed)
F_TCP_FXPARM_SCALE : float * : scale of TCP parameter area when TCP FX are embedded (0=min allowed, default, 1=max allowed)
I_PLAY_OFFSET_FLAG : int * : track media playback offset state, &1=bypassed, &2=offset value is measured in samples (otherwise measured in seconds)
D_PLAY_OFFSET : double * : track media playback offset, units depend on I_PLAY_OFFSET_FLAG
P_PARTRACK : MediaTrack * : parent track (read-only)
P_PROJECT : ReaProject * : parent project (read-only)




C: bool GetMIDIInputName(int dev, char* nameout, int nameout_sz)

EEL2: bool GetMIDIInputName(int dev, #nameout)

Lua: boolean retval, string nameout = reaper.GetMIDIInputName(integer dev, string nameout)

Python: (Boolean retval, Int dev, String nameout, Int nameout_sz) = RPR_GetMIDIInputName(dev, nameout, nameout_sz)

returns true if device present



C: bool GetMIDIOutputName(int dev, char* nameout, int nameout_sz)

EEL2: bool GetMIDIOutputName(int dev, #nameout)

Lua: boolean retval, string nameout = reaper.GetMIDIOutputName(integer dev, string nameout)

Python: (Boolean retval, Int dev, String nameout, Int nameout_sz) = RPR_GetMIDIOutputName(dev, nameout, nameout_sz)

returns true if device present



C: MediaTrack* GetMixerScroll()

EEL2: MediaTrack GetMixerScroll()

Lua: MediaTrack reaper.GetMixerScroll()

Python: MediaTrack RPR_GetMixerScroll()

Get the leftmost track visible in the mixer



C: void GetMouseModifier(const char* context, int modifier_flag, char* actionOut, int actionOut_sz)

EEL2: GetMouseModifier("context", int modifier_flag, #action)

Lua: string action = reaper.GetMouseModifier(string context, integer modifier_flag)

Python: (String context, Int modifier_flag, String actionOut, Int actionOut_sz) = RPR_GetMouseModifier(context, modifier_flag, actionOut, actionOut_sz)

Get the current mouse modifier assignment for a specific modifier key assignment, in a specific context.
action will be filled in with the command ID number for a built-in mouse modifier
or built-in REAPER command ID, or the custom action ID string.
Note: the action string may have a space and 'c' or 'm' appended to it to specify command ID vs mouse modifier ID.
See SetMouseModifier for more information.




C: void GetMousePosition(int* xOut, int* yOut)

EEL2: GetMousePosition(int &x, int &y)

Lua: integer x, integer y = reaper.GetMousePosition()

Python: (Int xOut, Int yOut) = RPR_GetMousePosition(xOut, yOut)

get mouse position in screen coordinates



C: int GetNumAudioInputs()

EEL2: int GetNumAudioInputs()

Lua: integer reaper.GetNumAudioInputs()

Python: Int RPR_GetNumAudioInputs()

Return number of normal audio hardware inputs available



C: int GetNumAudioOutputs()

EEL2: int GetNumAudioOutputs()

Lua: integer reaper.GetNumAudioOutputs()

Python: Int RPR_GetNumAudioOutputs()

Return number of normal audio hardware outputs available



C: int GetNumMIDIInputs()

EEL2: int GetNumMIDIInputs()

Lua: integer reaper.GetNumMIDIInputs()

Python: Int RPR_GetNumMIDIInputs()

returns max number of real midi hardware inputs



C: int GetNumMIDIOutputs()

EEL2: int GetNumMIDIOutputs()

Lua: integer reaper.GetNumMIDIOutputs()

Python: Int RPR_GetNumMIDIOutputs()

returns max number of real midi hardware outputs



C: int GetNumTakeMarkers(MediaItem_Take* take)

EEL2: int GetNumTakeMarkers(MediaItem_Take take)

Lua: integer reaper.GetNumTakeMarkers(MediaItem_Take take)

Python: Int RPR_GetNumTakeMarkers(MediaItem_Take take)

Returns number of take markers. See GetTakeMarker, SetTakeMarker, DeleteTakeMarker



C: int GetNumTracks()

EEL2: int GetNumTracks()

Lua: integer reaper.GetNumTracks()

Python: Int RPR_GetNumTracks()



C: const char* GetOS()

EEL2: bool GetOS(#retval)

Lua: string reaper.GetOS()

Python: String RPR_GetOS()

Returns "Win32", "Win64", "OSX32", "OSX64", "macOS-arm64", or "Other".



C: const char* GetOutputChannelName(int channelIndex)

EEL2: bool GetOutputChannelName(#retval, int channelIndex)

Lua: string reaper.GetOutputChannelName(integer channelIndex)

Python: String RPR_GetOutputChannelName(Int channelIndex)



C: double GetOutputLatency()

EEL2: double GetOutputLatency()

Lua: number reaper.GetOutputLatency()

Python: Float RPR_GetOutputLatency()

returns output latency in seconds



C: MediaTrack* GetParentTrack(MediaTrack* track)

EEL2: MediaTrack GetParentTrack(MediaTrack track)

Lua: MediaTrack reaper.GetParentTrack(MediaTrack track)

Python: MediaTrack RPR_GetParentTrack(MediaTrack track)



C: void GetPeakFileName(const char* fn, char* bufOut, int bufOut_sz)

EEL2: GetPeakFileName("fn", #buf)

Lua: string buf = reaper.GetPeakFileName(string fn)

Python: (String fn, String bufOut, Int bufOut_sz) = RPR_GetPeakFileName(fn, bufOut, bufOut_sz)

get the peak file name for a given file (can be either filename.reapeaks,or a hashed filename in another path)



C: void GetPeakFileNameEx(const char* fn, char* buf, int buf_sz, bool forWrite)

EEL2: GetPeakFileNameEx("fn", #buf, bool forWrite)

Lua: string buf = reaper.GetPeakFileNameEx(string fn, string buf, boolean forWrite)

Python: (String fn, String buf, Int buf_sz, Boolean forWrite) = RPR_GetPeakFileNameEx(fn, buf, buf_sz, forWrite)

get the peak file name for a given file (can be either filename.reapeaks,or a hashed filename in another path)



C: void GetPeakFileNameEx2(const char* fn, char* buf, int buf_sz, bool forWrite, const char* peaksfileextension)

EEL2: GetPeakFileNameEx2("fn", #buf, bool forWrite, "peaksfileextension")

Lua: string buf = reaper.GetPeakFileNameEx2(string fn, string buf, boolean forWrite, string peaksfileextension)

Python: (String fn, String buf, Int buf_sz, Boolean forWrite, String peaksfileextension) = RPR_GetPeakFileNameEx2(fn, buf, buf_sz, forWrite, peaksfileextension)

Like GetPeakFileNameEx, but you can specify peaksfileextension such as ".reapeaks"



C: double GetPlayPosition()

EEL2: double GetPlayPosition()

Lua: number reaper.GetPlayPosition()

Python: Float RPR_GetPlayPosition()

returns latency-compensated actual-what-you-hear position



C: double GetPlayPosition2()

EEL2: double GetPlayPosition2()

Lua: number reaper.GetPlayPosition2()

Python: Float RPR_GetPlayPosition2()

returns position of next audio block being processed



C: double GetPlayPosition2Ex(ReaProject* proj)

EEL2: double GetPlayPosition2Ex(ReaProject proj)

Lua: number reaper.GetPlayPosition2Ex(ReaProject proj)

Python: Float RPR_GetPlayPosition2Ex(ReaProject proj)

returns position of next audio block being processed



C: double GetPlayPositionEx(ReaProject* proj)

EEL2: double GetPlayPositionEx(ReaProject proj)

Lua: number reaper.GetPlayPositionEx(ReaProject proj)

Python: Float RPR_GetPlayPositionEx(ReaProject proj)

returns latency-compensated actual-what-you-hear position



C: int GetPlayState()

EEL2: int GetPlayState()

Lua: integer reaper.GetPlayState()

Python: Int RPR_GetPlayState()

&1=playing, &2=paused, &4=is recording



C: int GetPlayStateEx(ReaProject* proj)

EEL2: int GetPlayStateEx(ReaProject proj)

Lua: integer reaper.GetPlayStateEx(ReaProject proj)

Python: Int RPR_GetPlayStateEx(ReaProject proj)

&1=playing, &2=paused, &4=is recording



C: double GetProjectLength(ReaProject* proj)

EEL2: double GetProjectLength(ReaProject proj)

Lua: number reaper.GetProjectLength(ReaProject proj)

Python: Float RPR_GetProjectLength(ReaProject proj)

returns length of project (maximum of end of media item, markers, end of regions, tempo map



C: void GetProjectName(ReaProject* proj, char* bufOut, int bufOut_sz)

EEL2: GetProjectName(ReaProject proj, #buf)

Lua: string buf = reaper.GetProjectName(ReaProject proj)

Python: (ReaProject proj, String bufOut, Int bufOut_sz) = RPR_GetProjectName(proj, bufOut, bufOut_sz)



C: void GetProjectPath(char* bufOut, int bufOut_sz)

EEL2: GetProjectPath(#buf)

Lua: string buf = reaper.GetProjectPath()

Python: (String bufOut, Int bufOut_sz) = RPR_GetProjectPath(bufOut, bufOut_sz)

Get the project recording path.



C: void GetProjectPathEx(ReaProject* proj, char* bufOut, int bufOut_sz)

EEL2: GetProjectPathEx(ReaProject proj, #buf)

Lua: string buf = reaper.GetProjectPathEx(ReaProject proj)

Python: (ReaProject proj, String bufOut, Int bufOut_sz) = RPR_GetProjectPathEx(proj, bufOut, bufOut_sz)

Get the project recording path.



C: int GetProjectStateChangeCount(ReaProject* proj)

EEL2: int GetProjectStateChangeCount(ReaProject proj)

Lua: integer reaper.GetProjectStateChangeCount(ReaProject proj)

Python: Int RPR_GetProjectStateChangeCount(ReaProject proj)

returns an integer that changes when the project state changes



C: double GetProjectTimeOffset(ReaProject* proj, bool rndframe)

EEL2: double GetProjectTimeOffset(ReaProject proj, bool rndframe)

Lua: number reaper.GetProjectTimeOffset(ReaProject proj, boolean rndframe)

Python: Float RPR_GetProjectTimeOffset(ReaProject proj, Boolean rndframe)

Gets project time offset in seconds (project settings - project start time). If rndframe is true, the offset is rounded to a multiple of the project frame size.



C: void GetProjectTimeSignature(double* bpmOut, double* bpiOut)

EEL2: GetProjectTimeSignature(&bpm, &bpi)

Lua: number bpm, number bpi = reaper.GetProjectTimeSignature()

Python: (Float bpmOut, Float bpiOut) = RPR_GetProjectTimeSignature(bpmOut, bpiOut)

deprecated



C: void GetProjectTimeSignature2(ReaProject* proj, double* bpmOut, double* bpiOut)

EEL2: GetProjectTimeSignature2(ReaProject proj, &bpm, &bpi)

Lua: number bpm, number bpi = reaper.GetProjectTimeSignature2(ReaProject proj)

Python: (ReaProject proj, Float bpmOut, Float bpiOut) = RPR_GetProjectTimeSignature2(proj, bpmOut, bpiOut)

Gets basic time signature (beats per minute, numerator of time signature in bpi)
this does not reflect tempo envelopes but is purely what is set in the project settings.



C: int GetProjExtState(ReaProject* proj, const char* extname, const char* key, char* valOutNeedBig, int valOutNeedBig_sz)

EEL2: int GetProjExtState(ReaProject proj, "extname", "key", #val)

Lua: integer retval, string val = reaper.GetProjExtState(ReaProject proj, string extname, string key)

Python: (Int retval, ReaProject proj, String extname, String key, String valOutNeedBig, Int valOutNeedBig_sz) = RPR_GetProjExtState(proj, extname, key, valOutNeedBig, valOutNeedBig_sz)

Get the value previously associated with this extname and key, the last time the project was saved. See SetProjExtState, EnumProjExtState.



C: const char* GetResourcePath()

EEL2: bool GetResourcePath(#retval)

Lua: string reaper.GetResourcePath()

Python: String RPR_GetResourcePath()

returns path where ini files are stored, other things are in subdirectories.



C: TrackEnvelope* GetSelectedEnvelope(ReaProject* proj)

EEL2: TrackEnvelope GetSelectedEnvelope(ReaProject proj)

Lua: TrackEnvelope reaper.GetSelectedEnvelope(ReaProject proj)

Python: TrackEnvelope RPR_GetSelectedEnvelope(ReaProject proj)

get the currently selected envelope, returns NULL/nil if no envelope is selected



C: MediaItem* GetSelectedMediaItem(ReaProject* proj, int selitem)

EEL2: MediaItem GetSelectedMediaItem(ReaProject proj, int selitem)

Lua: MediaItem reaper.GetSelectedMediaItem(ReaProject proj, integer selitem)

Python: MediaItem RPR_GetSelectedMediaItem(ReaProject proj, Int selitem)

get a selected item by selected item count (zero-based) (proj=0 for active project)



C: MediaTrack* GetSelectedTrack(ReaProject* proj, int seltrackidx)

EEL2: MediaTrack GetSelectedTrack(ReaProject proj, int seltrackidx)

Lua: MediaTrack reaper.GetSelectedTrack(ReaProject proj, integer seltrackidx)

Python: MediaTrack RPR_GetSelectedTrack(ReaProject proj, Int seltrackidx)

Get a selected track from a project (proj=0 for active project) by selected track count (zero-based). This function ignores the master track, see GetSelectedTrack2.



C: MediaTrack* GetSelectedTrack2(ReaProject* proj, int seltrackidx, bool wantmaster)

EEL2: MediaTrack GetSelectedTrack2(ReaProject proj, int seltrackidx, bool wantmaster)

Lua: MediaTrack reaper.GetSelectedTrack2(ReaProject proj, integer seltrackidx, boolean wantmaster)

Python: MediaTrack RPR_GetSelectedTrack2(ReaProject proj, Int seltrackidx, Boolean wantmaster)

Get a selected track from a project (proj=0 for active project) by selected track count (zero-based).



C: TrackEnvelope* GetSelectedTrackEnvelope(ReaProject* proj)

EEL2: TrackEnvelope GetSelectedTrackEnvelope(ReaProject proj)

Lua: TrackEnvelope reaper.GetSelectedTrackEnvelope(ReaProject proj)

Python: TrackEnvelope RPR_GetSelectedTrackEnvelope(ReaProject proj)

get the currently selected track envelope, returns NULL/nil if no envelope is selected



C: void GetSet_ArrangeView2(ReaProject* proj, bool isSet, int screen_x_start, int screen_x_end, double* start_timeInOut, double* end_timeInOut)

EEL2: GetSet_ArrangeView2(ReaProject proj, bool isSet, int screen_x_start, int screen_x_end, &start_time, &end_time)

Lua: number start_time, number end_time = reaper.GetSet_ArrangeView2(ReaProject proj, boolean isSet, integer screen_x_start, integer screen_x_end, number start_time, number end_time)

Python: (ReaProject proj, Boolean isSet, Int screen_x_start, Int screen_x_end, Float start_timeInOut, Float end_timeInOut) = RPR_GetSet_ArrangeView2(proj, isSet, screen_x_start, screen_x_end, start_timeInOut, end_timeInOut)

Gets or sets the arrange view start/end time for screen coordinates. use screen_x_start=screen_x_end=0 to use the full arrange view's start/end time



C: void GetSet_LoopTimeRange(bool isSet, bool isLoop, double* startOut, double* endOut, bool allowautoseek)

EEL2: GetSet_LoopTimeRange(bool isSet, bool isLoop, &start, &end, bool allowautoseek)

Lua: number start, number end = reaper.GetSet_LoopTimeRange(boolean isSet, boolean isLoop, number start, number end, boolean allowautoseek)

Python: (Boolean isSet, Boolean isLoop, Float startOut, Float endOut, Boolean allowautoseek) = RPR_GetSet_LoopTimeRange(isSet, isLoop, startOut, endOut, allowautoseek)



C: void GetSet_LoopTimeRange2(ReaProject* proj, bool isSet, bool isLoop, double* startOut, double* endOut, bool allowautoseek)

EEL2: GetSet_LoopTimeRange2(ReaProject proj, bool isSet, bool isLoop, &start, &end, bool allowautoseek)

Lua: number start, number end = reaper.GetSet_LoopTimeRange2(ReaProject proj, boolean isSet, boolean isLoop, number start, number end, boolean allowautoseek)

Python: (ReaProject proj, Boolean isSet, Boolean isLoop, Float startOut, Float endOut, Boolean allowautoseek) = RPR_GetSet_LoopTimeRange2(proj, isSet, isLoop, startOut, endOut, allowautoseek)



C: double GetSetAutomationItemInfo(TrackEnvelope* env, int autoitem_idx, const char* desc, double value, bool is_set)

EEL2: double GetSetAutomationItemInfo(TrackEnvelope env, int autoitem_idx, "desc", value, bool is_set)

Lua: number reaper.GetSetAutomationItemInfo(TrackEnvelope env, integer autoitem_idx, string desc, number value, boolean is_set)

Python: Float RPR_GetSetAutomationItemInfo(TrackEnvelope env, Int autoitem_idx, String desc, Float value, Boolean is_set)

Get or set automation item information. autoitem_idx=0 for the first automation item on an envelope, 1 for the second item, etc. desc can be any of the following:
D_POOL_ID : double * : automation item pool ID (as an integer); edits are propagated to all other automation items that share a pool ID
D_POSITION : double * : automation item timeline position in seconds
D_LENGTH : double * : automation item length in seconds
D_STARTOFFS : double * : automation item start offset in seconds
D_PLAYRATE : double * : automation item playback rate
D_BASELINE : double * : automation item baseline value in the range [0,1]
D_AMPLITUDE : double * : automation item amplitude in the range [-1,1]
D_LOOPSRC : double * : nonzero if the automation item contents are looped
D_UISEL : double * : nonzero if the automation item is selected in the arrange view
D_POOL_QNLEN : double * : automation item pooled source length in quarter notes (setting will affect all pooled instances)




C: bool GetSetAutomationItemInfo_String(TrackEnvelope* env, int autoitem_idx, const char* desc, char* valuestrNeedBig, bool is_set)

EEL2: bool GetSetAutomationItemInfo_String(TrackEnvelope env, int autoitem_idx, "desc", #valuestrNeedBig, bool is_set)

Lua: boolean retval, string valuestrNeedBig = reaper.GetSetAutomationItemInfo_String(TrackEnvelope env, integer autoitem_idx, string desc, string valuestrNeedBig, boolean is_set)

Python: (Boolean retval, TrackEnvelope env, Int autoitem_idx, String desc, String valuestrNeedBig, Boolean is_set) = RPR_GetSetAutomationItemInfo_String(env, autoitem_idx, desc, valuestrNeedBig, is_set)

Get or set automation item information. autoitem_idx=0 for the first automation item on an envelope, 1 for the second item, etc. returns true on success. desc can be any of the following:
P_POOL_NAME : char * : name of the underlying automation item pool
P_POOL_EXT:xyz : char * : extension-specific persistent data




C: bool GetSetEnvelopeInfo_String(TrackEnvelope* env, const char* parmname, char* stringNeedBig, bool setNewValue)

EEL2: bool GetSetEnvelopeInfo_String(TrackEnvelope env, "parmname", #stringNeedBig, bool setNewValue)

Lua: boolean retval, string stringNeedBig = reaper.GetSetEnvelopeInfo_String(TrackEnvelope env, string parmname, string stringNeedBig, boolean setNewValue)

Python: (Boolean retval, TrackEnvelope env, String parmname, String stringNeedBig, Boolean setNewValue) = RPR_GetSetEnvelopeInfo_String(env, parmname, stringNeedBig, setNewValue)

Gets/sets an attribute string:
P_EXT:xyz : char * : extension-specific persistent data
GUID : GUID * : 16-byte GUID, can query only, not set. If using a _String() function, GUID is a string {xyz-...}.




C: bool GetSetEnvelopeState(TrackEnvelope* env, char* str, int str_sz)

EEL2: bool GetSetEnvelopeState(TrackEnvelope env, #str)

Lua: boolean retval, string str = reaper.GetSetEnvelopeState(TrackEnvelope env, string str)

Python: (Boolean retval, TrackEnvelope env, String str, Int str_sz) = RPR_GetSetEnvelopeState(env, str, str_sz)

deprecated -- see SetEnvelopeStateChunk, GetEnvelopeStateChunk



C: bool GetSetEnvelopeState2(TrackEnvelope* env, char* str, int str_sz, bool isundo)

EEL2: bool GetSetEnvelopeState2(TrackEnvelope env, #str, bool isundo)

Lua: boolean retval, string str = reaper.GetSetEnvelopeState2(TrackEnvelope env, string str, boolean isundo)

Python: (Boolean retval, TrackEnvelope env, String str, Int str_sz, Boolean isundo) = RPR_GetSetEnvelopeState2(env, str, str_sz, isundo)

deprecated -- see SetEnvelopeStateChunk, GetEnvelopeStateChunk



C: bool GetSetItemState(MediaItem* item, char* str, int str_sz)

EEL2: bool GetSetItemState(MediaItem item, #str)

Lua: boolean retval, string str = reaper.GetSetItemState(MediaItem item, string str)

Python: (Boolean retval, MediaItem item, String str, Int str_sz) = RPR_GetSetItemState(item, str, str_sz)

deprecated -- see SetItemStateChunk, GetItemStateChunk



C: bool GetSetItemState2(MediaItem* item, char* str, int str_sz, bool isundo)

EEL2: bool GetSetItemState2(MediaItem item, #str, bool isundo)

Lua: boolean retval, string str = reaper.GetSetItemState2(MediaItem item, string str, boolean isundo)

Python: (Boolean retval, MediaItem item, String str, Int str_sz, Boolean isundo) = RPR_GetSetItemState2(item, str, str_sz, isundo)

deprecated -- see SetItemStateChunk, GetItemStateChunk



C: bool GetSetMediaItemInfo_String(MediaItem* item, const char* parmname, char* stringNeedBig, bool setNewValue)

EEL2: bool GetSetMediaItemInfo_String(MediaItem item, "parmname", #stringNeedBig, bool setNewValue)

Lua: boolean retval, string stringNeedBig = reaper.GetSetMediaItemInfo_String(MediaItem item, string parmname, string stringNeedBig, boolean setNewValue)

Python: (Boolean retval, MediaItem item, String parmname, String stringNeedBig, Boolean setNewValue) = RPR_GetSetMediaItemInfo_String(item, parmname, stringNeedBig, setNewValue)

Gets/sets an item attribute string:
P_NOTES : char * : item note text (do not write to returned pointer, use setNewValue to update)
P_EXT:xyz : char * : extension-specific persistent data
GUID : GUID * : 16-byte GUID, can query or update. If using a _String() function, GUID is a string {xyz-...}.




C: bool GetSetMediaItemTakeInfo_String(MediaItem_Take* tk, const char* parmname, char* stringNeedBig, bool setNewValue)

EEL2: bool GetSetMediaItemTakeInfo_String(MediaItem_Take tk, "parmname", #stringNeedBig, bool setNewValue)

Lua: boolean retval, string stringNeedBig = reaper.GetSetMediaItemTakeInfo_String(MediaItem_Take tk, string parmname, string stringNeedBig, boolean setNewValue)

Python: (Boolean retval, MediaItem_Take tk, String parmname, String stringNeedBig, Boolean setNewValue) = RPR_GetSetMediaItemTakeInfo_String(tk, parmname, stringNeedBig, setNewValue)

Gets/sets a take attribute string:
P_NAME : char * : take name
P_EXT:xyz : char * : extension-specific persistent data
GUID : GUID * : 16-byte GUID, can query or update. If using a _String() function, GUID is a string {xyz-...}.




C: bool GetSetMediaTrackInfo_String(MediaTrack* tr, const char* parmname, char* stringNeedBig, bool setNewValue)

EEL2: bool GetSetMediaTrackInfo_String(MediaTrack tr, "parmname", #stringNeedBig, bool setNewValue)

Lua: boolean retval, string stringNeedBig = reaper.GetSetMediaTrackInfo_String(MediaTrack tr, string parmname, string stringNeedBig, boolean setNewValue)

Python: (Boolean retval, MediaTrack tr, String parmname, String stringNeedBig, Boolean setNewValue) = RPR_GetSetMediaTrackInfo_String(tr, parmname, stringNeedBig, setNewValue)

Get or set track string attributes.
P_NAME : char * : track name (on master returns NULL)
P_ICON : const char * : track icon (full filename, or relative to resource_path/data/track_icons)
P_LANENAME:n : char * : lane name (returns NULL for non-fixed-lane-tracks)
P_MCP_LAYOUT : const char * : layout name
P_RAZOREDITS : const char * : list of razor edit areas, as space-separated triples of start time, end time, and envelope GUID string.
Example: "0.0 1.0 \"\" 0.0 1.0 "{xyz-...}"
P_RAZOREDITS_EXT : const char * : list of razor edit areas, as comma-separated sets of space-separated tuples of start time, end time, optional: envelope GUID string, fixed/fipm top y-position, fixed/fipm bottom y-position.
Example: "0.0 1.0,0.0 1.0 "{xyz-...}",1.0 2.0 "" 0.25 0.75"
P_TCP_LAYOUT : const char * : layout name
P_EXT:xyz : char * : extension-specific persistent data
P_UI_RECT:tcp.mute : char * : read-only, allows querying screen position + size of track WALTER elements (tcp.size queries screen position and size of entire TCP, etc).
GUID : GUID * : 16-byte GUID, can query or update. If using a _String() function, GUID is a string {xyz-...}.




C: void GetSetProjectAuthor(ReaProject* proj, bool set, char* author, int author_sz)

EEL2: GetSetProjectAuthor(ReaProject proj, bool set, #author)

Lua: string author = reaper.GetSetProjectAuthor(ReaProject proj, boolean set, string author)

Python: (ReaProject proj, Boolean set, String author, Int author_sz) = RPR_GetSetProjectAuthor(proj, set, author, author_sz)

deprecated, see GetSetProjectInfo_String with desc="PROJECT_AUTHOR"



C: int GetSetProjectGrid(ReaProject* project, bool set, double* divisionInOutOptional, int* swingmodeInOutOptional, double* swingamtInOutOptional)

EEL2: int GetSetProjectGrid(ReaProject project, bool set, optional &division, optional int &swingmode, optional &swingamt)

Lua: integer retval, optional number division, optional integer swingmode, optional number swingamt = reaper.GetSetProjectGrid(ReaProject project, boolean set, optional number division, optional integer swingmode, optional number swingamt)

Python: (Int retval, ReaProject project, Boolean set, Float divisionInOutOptional, Int swingmodeInOutOptional, Float swingamtInOutOptional) = RPR_GetSetProjectGrid(project, set, divisionInOutOptional, swingmodeInOutOptional, swingamtInOutOptional)

Get or set the arrange view grid division. 0.25=quarter note, 1.0/3.0=half note triplet, etc. swingmode can be 1 for swing enabled, swingamt is -1..1. swingmode can be 3 for measure-grid. Returns grid configuration flags



C: double GetSetProjectInfo(ReaProject* project, const char* desc, double value, bool is_set)

EEL2: double GetSetProjectInfo(ReaProject project, "desc", value, bool is_set)

Lua: number reaper.GetSetProjectInfo(ReaProject project, string desc, number value, boolean is_set)

Python: Float RPR_GetSetProjectInfo(ReaProject project, String desc, Float value, Boolean is_set)

Get or set project information.
RENDER_SETTINGS : &(1|2)=0:master mix, &1=stems+master mix, &2=stems only, &4=multichannel tracks to multichannel files, &8=use render matrix, &16=tracks with only mono media to mono files, &32=selected media items, &64=selected media items via master, &128=selected tracks via master, &256=embed transients if format supports, &512=embed metadata if format supports, &1024=embed take markers if format supports, &2048=2nd pass render
RENDER_BOUNDSFLAG : 0=custom time bounds, 1=entire project, 2=time selection, 3=all project regions, 4=selected media items, 5=selected project regions, 6=all project markers, 7=selected project markers
RENDER_CHANNELS : number of channels in rendered file
RENDER_SRATE : sample rate of rendered file (or 0 for project sample rate)
RENDER_STARTPOS : render start time when RENDER_BOUNDSFLAG=0
RENDER_ENDPOS : render end time when RENDER_BOUNDSFLAG=0
RENDER_TAILFLAG : apply render tail setting when rendering: &1=custom time bounds, &2=entire project, &4=time selection, &8=all project markers/regions, &16=selected media items, &32=selected project markers/regions
RENDER_TAILMS : tail length in ms to render (only used if RENDER_BOUNDSFLAG and RENDER_TAILFLAG are set)
RENDER_ADDTOPROJ : &1=add rendered files to project, &2=do not render files that are likely silent
RENDER_DITHER : &1=dither, &2=noise shaping, &4=dither stems, &8=noise shaping on stems
RENDER_NORMALIZE: &1=enable, (&14==0)=LUFS-I, (&14==2)=RMS, (&14==4)=peak, (&14==6)=true peak, (&14==8)=LUFS-M max, (&14==10)=LUFS-S max, &32=normalize stems to common gain based on master, &64=enable brickwall limit, &128=brickwall limit true peak, (&2304==256)=only normalize files that are too loud, (&2304==2048)=only normalize files that are too quiet, &512=apply fade-in, &1024=apply fade-out
RENDER_NORMALIZE_TARGET: render normalization target as amplitude, so 0.5 means -6.02dB, 0.25 means -12.04dB, etc
RENDER_BRICKWALL: render brickwall limit as amplitude, so 0.5 means -6.02dB, 0.25 means -12.04dB, etc
RENDER_FADEIN: render fade-in (0.001 means 1 ms, requires RENDER_NORMALIZE&512)
RENDER_FADEOUT: render fade-out (0.001 means 1 ms, requires RENDER_NORMALIZE&1024)
RENDER_FADEINSHAPE: render fade-in shape
RENDER_FADEOUTSHAPE: render fade-out shape
PROJECT_SRATE : samplerate (ignored unless PROJECT_SRATE_USE set)
PROJECT_SRATE_USE : set to 1 if project samplerate is used




C: bool GetSetProjectInfo_String(ReaProject* project, const char* desc, char* valuestrNeedBig, bool is_set)

EEL2: bool GetSetProjectInfo_String(ReaProject project, "desc", #valuestrNeedBig, bool is_set)

Lua: boolean retval, string valuestrNeedBig = reaper.GetSetProjectInfo_String(ReaProject project, string desc, string valuestrNeedBig, boolean is_set)

Python: (Boolean retval, ReaProject project, String desc, String valuestrNeedBig, Boolean is_set) = RPR_GetSetProjectInfo_String(project, desc, valuestrNeedBig, is_set)

Get or set project information.
PROJECT_NAME : project file name (read-only, is_set will be ignored)
PROJECT_TITLE : title field from Project Settings/Notes dialog
PROJECT_AUTHOR : author field from Project Settings/Notes dialog
TRACK_GROUP_NAME:X : track group name, X should be 1..64
MARKER_GUID:X : get the GUID (unique ID) of the marker or region with index X, where X is the index passed to EnumProjectMarkers, not necessarily the displayed number (read-only)
MARKER_INDEX_FROM_GUID:{GUID} : get the GUID index of the marker or region with GUID {GUID} (read-only)
OPENCOPY_CFGIDX : integer for the configuration of format to use when creating copies/applying FX. 0=wave (auto-depth), 1=APPLYFX_FORMAT, 2=RECORD_FORMAT
RECORD_PATH : recording directory -- may be blank or a relative path, to get the effective path see GetProjectPathEx()
RECORD_PATH_SECONDARY : secondary recording directory
RECORD_FORMAT : base64-encoded sink configuration (see project files, etc). Callers can also pass a simple 4-byte string (non-base64-encoded), e.g. "evaw" or "l3pm", to use default settings for that sink type.
APPLYFX_FORMAT : base64-encoded sink configuration (see project files, etc). Used only if RECFMT_OPENCOPY is set to 1. Callers can also pass a simple 4-byte string (non-base64-encoded), e.g. "evaw" or "l3pm", to use default settings for that sink type.
RENDER_FILE : render directory
RENDER_PATTERN : render file name (may contain wildcards)
RENDER_METADATA : get or set the metadata saved with the project (not metadata embedded in project media). Example, ID3 album name metadata: valuestr="ID3:TALB" to get, valuestr="ID3:TALB|my album name" to set. Call with valuestr="" and is_set=false to get a semicolon-separated list of defined project metadata identifiers.
RENDER_TARGETS : semicolon separated list of files that would be written if the project is rendered using the most recent render settings
RENDER_STATS : (read-only) semicolon separated list of statistics for the most recently rendered files. call with valuestr="XXX" to run an action (for example, "42437"=dry run render selected items) before returning statistics.
RENDER_FORMAT : base64-encoded sink configuration (see project files, etc). Callers can also pass a simple 4-byte string (non-base64-encoded), e.g. "evaw" or "l3pm", to use default settings for that sink type.
RENDER_FORMAT2 : base64-encoded secondary sink configuration. Callers can also pass a simple 4-byte string (non-base64-encoded), e.g. "evaw" or "l3pm", to use default settings for that sink type, or "" to disable secondary render.
    Formats available on this machine:
    "wave" "aiff" "caff" "raw " "mp3l" "wvpk" "OggS" "flac" "ddp " "iso " "oggv" "FFMP" "XAVF" "GIF " "LCF "



C: void GetSetProjectNotes(ReaProject* proj, bool set, char* notesNeedBig, int notesNeedBig_sz)

EEL2: GetSetProjectNotes(ReaProject proj, bool set, #notes)

Lua: string notes = reaper.GetSetProjectNotes(ReaProject proj, boolean set, string notes)

Python: (ReaProject proj, Boolean set, String notesNeedBig, Int notesNeedBig_sz) = RPR_GetSetProjectNotes(proj, set, notesNeedBig, notesNeedBig_sz)

gets or sets project notes, notesNeedBig_sz is ignored when setting



C: int GetSetRepeat(int val)

EEL2: int GetSetRepeat(int val)

Lua: integer reaper.GetSetRepeat(integer val)

Python: Int RPR_GetSetRepeat(Int val)

-1 == query,0=clear,1=set,>1=toggle . returns new value



C: int GetSetRepeatEx(ReaProject* proj, int val)

EEL2: int GetSetRepeatEx(ReaProject proj, int val)

Lua: integer reaper.GetSetRepeatEx(ReaProject proj, integer val)

Python: Int RPR_GetSetRepeatEx(ReaProject proj, Int val)

-1 == query,0=clear,1=set,>1=toggle . returns new value



C: unsigned int GetSetTrackGroupMembership(MediaTrack* tr, const char* groupname, unsigned int setmask, unsigned int setvalue)

EEL2: uint GetSetTrackGroupMembership(MediaTrack tr, "groupname", uint setmask, uint setvalue)

Lua: integer reaper.GetSetTrackGroupMembership(MediaTrack tr, string groupname, integer setmask, integer setvalue)

Python: Unknown RPR_GetSetTrackGroupMembership(MediaTrack tr, String groupname, Unknown setmask, Unknown setvalue)

Gets or modifies the group membership for a track. Returns group state prior to call (each bit represents one of the 32 group numbers). if setmask has bits set, those bits in setvalue will be applied to group. Group can be one of:
MEDIA_EDIT_LEAD
MEDIA_EDIT_FOLLOW
VOLUME_LEAD
VOLUME_FOLLOW
VOLUME_VCA_LEAD
VOLUME_VCA_FOLLOW
PAN_LEAD
PAN_FOLLOW
WIDTH_LEAD
WIDTH_FOLLOW
MUTE_LEAD
MUTE_FOLLOW
SOLO_LEAD
SOLO_FOLLOW
RECARM_LEAD
RECARM_FOLLOW
POLARITY_LEAD
POLARITY_FOLLOW
AUTOMODE_LEAD
AUTOMODE_FOLLOW
VOLUME_REVERSE
PAN_REVERSE
WIDTH_REVERSE
NO_LEAD_WHEN_FOLLOW
VOLUME_VCA_FOLLOW_ISPREFX

Note: REAPER v6.11 and earlier used _MASTER and _SLAVE rather than _LEAD and _FOLLOW, which is deprecated but still supported (scripts that must support v6.11 and earlier can use the deprecated strings).




C: unsigned int GetSetTrackGroupMembershipHigh(MediaTrack* tr, const char* groupname, unsigned int setmask, unsigned int setvalue)

EEL2: uint GetSetTrackGroupMembershipHigh(MediaTrack tr, "groupname", uint setmask, uint setvalue)

Lua: integer reaper.GetSetTrackGroupMembershipHigh(MediaTrack tr, string groupname, integer setmask, integer setvalue)

Python: Unknown RPR_GetSetTrackGroupMembershipHigh(MediaTrack tr, String groupname, Unknown setmask, Unknown setvalue)

Gets or modifies the group membership for a track. Returns group state prior to call (each bit represents one of the high 32 group numbers). if setmask has bits set, those bits in setvalue will be applied to group. Group can be one of:
MEDIA_EDIT_LEAD
MEDIA_EDIT_FOLLOW
VOLUME_LEAD
VOLUME_FOLLOW
VOLUME_VCA_LEAD
VOLUME_VCA_FOLLOW
PAN_LEAD
PAN_FOLLOW
WIDTH_LEAD
WIDTH_FOLLOW
MUTE_LEAD
MUTE_FOLLOW
SOLO_LEAD
SOLO_FOLLOW
RECARM_LEAD
RECARM_FOLLOW
POLARITY_LEAD
POLARITY_FOLLOW
AUTOMODE_LEAD
AUTOMODE_FOLLOW
VOLUME_REVERSE
PAN_REVERSE
WIDTH_REVERSE
NO_LEAD_WHEN_FOLLOW
VOLUME_VCA_FOLLOW_ISPREFX

Note: REAPER v6.11 and earlier used _MASTER and _SLAVE rather than _LEAD and _FOLLOW, which is deprecated but still supported (scripts that must support v6.11 and earlier can use the deprecated strings).




C: bool GetSetTrackSendInfo_String(MediaTrack* tr, int category, int sendidx, const char* parmname, char* stringNeedBig, bool setNewValue)

EEL2: bool GetSetTrackSendInfo_String(MediaTrack tr, int category, int sendidx, "parmname", #stringNeedBig, bool setNewValue)

Lua: boolean retval, string stringNeedBig = reaper.GetSetTrackSendInfo_String(MediaTrack tr, integer category, integer sendidx, string parmname, string stringNeedBig, boolean setNewValue)

Python: (Boolean retval, MediaTrack tr, Int category, Int sendidx, String parmname, String stringNeedBig, Boolean setNewValue) = RPR_GetSetTrackSendInfo_String(tr, category, sendidx, parmname, stringNeedBig, setNewValue)

Gets/sets a send attribute string:
P_EXT:xyz : char * : extension-specific persistent data




C: bool GetSetTrackState(MediaTrack* track, char* str, int str_sz)

EEL2: bool GetSetTrackState(MediaTrack track, #str)

Lua: boolean retval, string str = reaper.GetSetTrackState(MediaTrack track, string str)

Python: (Boolean retval, MediaTrack track, String str, Int str_sz) = RPR_GetSetTrackState(track, str, str_sz)

deprecated -- see SetTrackStateChunk, GetTrackStateChunk



C: bool GetSetTrackState2(MediaTrack* track, char* str, int str_sz, bool isundo)

EEL2: bool GetSetTrackState2(MediaTrack track, #str, bool isundo)

Lua: boolean retval, string str = reaper.GetSetTrackState2(MediaTrack track, string str, boolean isundo)

Python: (Boolean retval, MediaTrack track, String str, Int str_sz, Boolean isundo) = RPR_GetSetTrackState2(track, str, str_sz, isundo)

deprecated -- see SetTrackStateChunk, GetTrackStateChunk



C: ReaProject* GetSubProjectFromSource(PCM_source* src)

EEL2: ReaProject GetSubProjectFromSource(PCM_source src)

Lua: ReaProject reaper.GetSubProjectFromSource(PCM_source src)

Python: ReaProject RPR_GetSubProjectFromSource(PCM_source src)



C: MediaItem_Take* GetTake(MediaItem* item, int takeidx)

EEL2: MediaItem_Take GetTake(MediaItem item, int takeidx)

Lua: MediaItem_Take reaper.GetTake(MediaItem item, integer takeidx)

Python: MediaItem_Take RPR_GetTake(MediaItem item, Int takeidx)

get a take from an item by take count (zero-based)



C: TrackEnvelope* GetTakeEnvelope(MediaItem_Take* take, int envidx)

EEL2: TrackEnvelope GetTakeEnvelope(MediaItem_Take take, int envidx)

Lua: TrackEnvelope reaper.GetTakeEnvelope(MediaItem_Take take, integer envidx)

Python: TrackEnvelope RPR_GetTakeEnvelope(MediaItem_Take take, Int envidx)



C: TrackEnvelope* GetTakeEnvelopeByName(MediaItem_Take* take, const char* envname)

EEL2: TrackEnvelope GetTakeEnvelopeByName(MediaItem_Take take, "envname")

Lua: TrackEnvelope reaper.GetTakeEnvelopeByName(MediaItem_Take take, string envname)

Python: TrackEnvelope RPR_GetTakeEnvelopeByName(MediaItem_Take take, String envname)



C: double GetTakeMarker(MediaItem_Take* take, int idx, char* nameOut, int nameOut_sz, int* colorOutOptional)

EEL2: double GetTakeMarker(MediaItem_Take take, int idx, #name, optional int &color)

Lua: number retval, string name, optional integer color = reaper.GetTakeMarker(MediaItem_Take take, integer idx)

Python: (Float retval, MediaItem_Take take, Int idx, String nameOut, Int nameOut_sz, Int colorOutOptional) = RPR_GetTakeMarker(take, idx, nameOut, nameOut_sz, colorOutOptional)

Get information about a take marker. Returns the position in media item source time, or -1 if the take marker does not exist. See GetNumTakeMarkers, SetTakeMarker, DeleteTakeMarker



C: const char* GetTakeName(MediaItem_Take* take)

EEL2: bool GetTakeName(#retval, MediaItem_Take take)

Lua: string reaper.GetTakeName(MediaItem_Take take)

Python: String RPR_GetTakeName(MediaItem_Take take)

returns NULL if the take is not valid



C: int GetTakeNumStretchMarkers(MediaItem_Take* take)

EEL2: int GetTakeNumStretchMarkers(MediaItem_Take take)

Lua: integer reaper.GetTakeNumStretchMarkers(MediaItem_Take take)

Python: Int RPR_GetTakeNumStretchMarkers(MediaItem_Take take)

Returns number of stretch markers in take



C: int GetTakeStretchMarker(MediaItem_Take* take, int idx, double* posOut, double* srcposOutOptional)

EEL2: int GetTakeStretchMarker(MediaItem_Take take, int idx, &pos, optional &srcpos)

Lua: integer retval, number pos, optional number srcpos = reaper.GetTakeStretchMarker(MediaItem_Take take, integer idx)

Python: (Int retval, MediaItem_Take take, Int idx, Float posOut, Float srcposOutOptional) = RPR_GetTakeStretchMarker(take, idx, posOut, srcposOutOptional)

Gets information on a stretch marker, idx is 0..n. Returns -1 if stretch marker not valid. posOut will be set to position in item, srcposOutOptional will be set to source media position. Returns index. if input index is -1, the following marker is found using position (or source position if position is -1). If position/source position are used to find marker position, their values are not updated.



C: double GetTakeStretchMarkerSlope(MediaItem_Take* take, int idx)

EEL2: double GetTakeStretchMarkerSlope(MediaItem_Take take, int idx)

Lua: number reaper.GetTakeStretchMarkerSlope(MediaItem_Take take, integer idx)

Python: Float RPR_GetTakeStretchMarkerSlope(MediaItem_Take take, Int idx)

See SetTakeStretchMarkerSlope



C: bool GetTCPFXParm(ReaProject* project, MediaTrack* track, int index, int* fxindexOut, int* parmidxOut)

EEL2: bool GetTCPFXParm(ReaProject project, MediaTrack track, int index, int &fxindex, int &parmidx)

Lua: boolean retval, integer fxindex, integer parmidx = reaper.GetTCPFXParm(ReaProject project, MediaTrack track, integer index)

Python: (Boolean retval, ReaProject project, MediaTrack track, Int index, Int fxindexOut, Int parmidxOut) = RPR_GetTCPFXParm(project, track, index, fxindexOut, parmidxOut)

Get information about a specific FX parameter knob (see CountTCPFXParms).



C: bool GetTempoMatchPlayRate(PCM_source* source, double srcscale, double position, double mult, double* rateOut, double* targetlenOut)

EEL2: bool GetTempoMatchPlayRate(PCM_source source, srcscale, position, mult, &rate, &targetlen)

Lua: boolean retval, number rate, number targetlen = reaper.GetTempoMatchPlayRate(PCM_source source, number srcscale, number position, number mult)

Python: (Boolean retval, PCM_source source, Float srcscale, Float position, Float mult, Float rateOut, Float targetlenOut) = RPR_GetTempoMatchPlayRate(source, srcscale, position, mult, rateOut, targetlenOut)

finds the playrate and target length to insert this item stretched to a round power-of-2 number of bars, between 1/8 and 256



C: bool GetTempoTimeSigMarker(ReaProject* proj, int ptidx, double* timeposOut, int* measureposOut, double* beatposOut, double* bpmOut, int* timesig_numOut, int* timesig_denomOut, bool* lineartempoOut)

EEL2: bool GetTempoTimeSigMarker(ReaProject proj, int ptidx, &timepos, int &measurepos, &beatpos, &bpm, int &timesig_num, int &timesig_denom, bool &lineartempo)

Lua: boolean retval, number timepos, integer measurepos, number beatpos, number bpm, integer timesig_num, integer timesig_denom, boolean lineartempo = reaper.GetTempoTimeSigMarker(ReaProject proj, integer ptidx)

Python: (Boolean retval, ReaProject proj, Int ptidx, Float timeposOut, Int measureposOut, Float beatposOut, Float bpmOut, Int timesig_numOut, Int timesig_denomOut, Boolean lineartempoOut) = RPR_GetTempoTimeSigMarker(proj, ptidx, timeposOut, measureposOut, beatposOut, bpmOut, timesig_numOut, timesig_denomOut, lineartempoOut)

Get information about a tempo/time signature marker. See CountTempoTimeSigMarkers, SetTempoTimeSigMarker, AddTempoTimeSigMarker.



C: int GetThemeColor(const char* ini_key, int flagsOptional)

EEL2: int GetThemeColor("ini_key", int flags)

Lua: integer reaper.GetThemeColor(string ini_key, integer flags)

Python: Int RPR_GetThemeColor(String ini_key, Int flagsOptional)

Returns the theme color specified, or -1 on failure. If the low bit of flags is set, the color as originally specified by the theme (before any transformations) is returned, otherwise the current (possibly transformed and modified) color is returned. See SetThemeColor for a list of valid ini_key.



C: MediaTrack* GetThingFromPoint(int screen_x, int screen_y, char* infoOut, int infoOut_sz)

EEL2: MediaTrack GetThingFromPoint(int screen_x, int screen_y, #info)

Lua: MediaTrack retval, string info = reaper.GetThingFromPoint(integer screen_x, integer screen_y)

Python: (MediaTrack retval, Int screen_x, Int screen_y, String infoOut, Int infoOut_sz) = RPR_GetThingFromPoint(screen_x, screen_y, infoOut, infoOut_sz)

Hit tests a point in screen coordinates. Updates infoOut with information such as "arrange", "fx_chain", "fx_0" (first FX in chain, floating), "spacer_0" (spacer before first track). If a track panel is hit, string will begin with "tcp" or "mcp" or "tcp.mute" etc (future versions may append additional information). May return NULL with valid info string to indicate non-track thing.



C: int GetToggleCommandState(int command_id)

EEL2: int GetToggleCommandState(int command_id)

Lua: integer reaper.GetToggleCommandState(integer command_id)

Python: Int RPR_GetToggleCommandState(Int command_id)

See GetToggleCommandStateEx.



C: int GetToggleCommandStateEx(int section_id, int command_id)

EEL2: int GetToggleCommandStateEx(int section_id, int command_id)

Lua: integer reaper.GetToggleCommandStateEx(integer section_id, integer command_id)

Python: Int RPR_GetToggleCommandStateEx(Int section_id, Int command_id)

For the main action context, the MIDI editor, or the media explorer, returns the toggle state of the action. 0=off, 1=on, -1=NA because the action does not have on/off states. For the MIDI editor, the action state for the most recently focused window will be returned.



C: HWND GetTooltipWindow()

EEL2: HWND GetTooltipWindow()

Lua: HWND reaper.GetTooltipWindow()

Python: HWND RPR_GetTooltipWindow()

gets a tooltip window,in case you want to ask it for font information. Can return NULL.



C: bool GetTouchedOrFocusedFX(int mode, int* trackidxOut, int* itemidxOut, int* takeidxOut, int* fxidxOut, int* parmOut)

EEL2: bool GetTouchedOrFocusedFX(int mode, int &trackidx, int &itemidx, int &takeidx, int &fxidx, int &parm)

Lua: boolean retval, integer trackidx, integer itemidx, integer takeidx, integer fxidx, integer parm = reaper.GetTouchedOrFocusedFX(integer mode)

Python: (Boolean retval, Int mode, Int trackidxOut, Int itemidxOut, Int takeidxOut, Int fxidxOut, Int parmOut) = RPR_GetTouchedOrFocusedFX(mode, trackidxOut, itemidxOut, takeidxOut, fxidxOut, parmOut)

mode can be 0 to query last touched parameter, or 1 to query currently focused FX. Returns false if failed. If successful, trackIdxOut will be track index (-1 is master track, 0 is first track). itemidxOut will be 0-based item index if an item, or -1 if not an item. takeidxOut will be 0-based take index. fxidxOut will be FX index, potentially with 0x2000000 set to signify container-addressing, or with 0x1000000 set to signify record-input FX. parmOut will be set to the parameter index if querying last-touched. parmOut will have 1 set if querying focused state and FX is no longer focused but still open.



C: MediaTrack* GetTrack(ReaProject* proj, int trackidx)

EEL2: MediaTrack GetTrack(ReaProject proj, int trackidx)

Lua: MediaTrack reaper.GetTrack(ReaProject proj, integer trackidx)

Python: MediaTrack RPR_GetTrack(ReaProject proj, Int trackidx)

get a track from a project by track count (zero-based) (proj=0 for active project)



C: int GetTrackAutomationMode(MediaTrack* tr)

EEL2: int GetTrackAutomationMode(MediaTrack tr)

Lua: integer reaper.GetTrackAutomationMode(MediaTrack tr)

Python: Int RPR_GetTrackAutomationMode(MediaTrack tr)

return the track mode, regardless of global override



C: int GetTrackColor(MediaTrack* track)

EEL2: int GetTrackColor(MediaTrack track)

Lua: integer reaper.GetTrackColor(MediaTrack track)

Python: Int RPR_GetTrackColor(MediaTrack track)

Returns the track custom color as OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). Black is returned as 0x1000000, no color setting is returned as 0.



C: int GetTrackDepth(MediaTrack* track)

EEL2: int GetTrackDepth(MediaTrack track)

Lua: integer reaper.GetTrackDepth(MediaTrack track)

Python: Int RPR_GetTrackDepth(MediaTrack track)



C: TrackEnvelope* GetTrackEnvelope(MediaTrack* track, int envidx)

EEL2: TrackEnvelope GetTrackEnvelope(MediaTrack track, int envidx)

Lua: TrackEnvelope reaper.GetTrackEnvelope(MediaTrack track, integer envidx)

Python: TrackEnvelope RPR_GetTrackEnvelope(MediaTrack track, Int envidx)



C: TrackEnvelope* GetTrackEnvelopeByChunkName(MediaTrack* tr, const char* cfgchunkname_or_guid)

EEL2: TrackEnvelope GetTrackEnvelopeByChunkName(MediaTrack tr, "cfgchunkname_or_guid")

Lua: TrackEnvelope reaper.GetTrackEnvelopeByChunkName(MediaTrack tr, string cfgchunkname_or_guid)

Python: TrackEnvelope RPR_GetTrackEnvelopeByChunkName(MediaTrack tr, String cfgchunkname_or_guid)

Gets a built-in track envelope by configuration chunk name, like "<VOLENV", or GUID string, like "{B577250D-146F-B544-9B34-F24FBE488F1F}".




C: TrackEnvelope* GetTrackEnvelopeByName(MediaTrack* track, const char* envname)

EEL2: TrackEnvelope GetTrackEnvelopeByName(MediaTrack track, "envname")

Lua: TrackEnvelope reaper.GetTrackEnvelopeByName(MediaTrack track, string envname)

Python: TrackEnvelope RPR_GetTrackEnvelopeByName(MediaTrack track, String envname)



C: MediaTrack* GetTrackFromPoint(int screen_x, int screen_y, int* infoOutOptional)

EEL2: MediaTrack GetTrackFromPoint(int screen_x, int screen_y, optional int &info)

Lua: MediaTrack retval, optional integer info = reaper.GetTrackFromPoint(integer screen_x, integer screen_y)

Python: (MediaTrack retval, Int screen_x, Int screen_y, Int infoOutOptional) = RPR_GetTrackFromPoint(screen_x, screen_y, infoOutOptional)

Returns the track from the screen coordinates specified. If the screen coordinates refer to a window associated to the track (such as FX), the track will be returned. infoOutOptional will be set to 1 if it is likely an envelope, 2 if it is likely a track FX. For a free item positioning or fixed lane track, the second byte of infoOutOptional will be set to the (approximate, for fipm tracks) item lane underneath the mouse. See GetThingFromPoint.



C: GUID* GetTrackGUID(MediaTrack* tr)

EEL2: bool GetTrackGUID(#retguid, MediaTrack tr)

Lua: string GUID = reaper.GetTrackGUID(MediaTrack tr)

Python: GUID RPR_GetTrackGUID(MediaTrack tr)



C: MediaItem* GetTrackMediaItem(MediaTrack* tr, int itemidx)

EEL2: MediaItem GetTrackMediaItem(MediaTrack tr, int itemidx)

Lua: MediaItem reaper.GetTrackMediaItem(MediaTrack tr, integer itemidx)

Python: MediaItem RPR_GetTrackMediaItem(MediaTrack tr, Int itemidx)



C: bool GetTrackMIDILyrics(MediaTrack* track, int flag, char* bufOutWantNeedBig, int* bufOutWantNeedBig_sz)

EEL2: bool GetTrackMIDILyrics(MediaTrack track, int flag, #buf)

Lua: boolean retval, string buf = reaper.GetTrackMIDILyrics(MediaTrack track, integer flag)

Python: (Boolean retval, MediaTrack track, Int flag, String bufOutWantNeedBig, Int bufOutWantNeedBig_sz) = RPR_GetTrackMIDILyrics(track, flag, bufOutWantNeedBig, bufOutWantNeedBig_sz)

Get all MIDI lyrics on the track. Lyrics will be returned as one string with tabs between each word. flag&1: double tabs at the end of each measure and triple tabs when skipping measures, flag&2: each lyric is preceded by its beat position in the project (example with flag=2: "1.1.2\tLyric for measure 1 beat 2\t2.1.1\tLyric for measure 2 beat 1 "). See SetTrackMIDILyrics



C: const char* GetTrackMIDINoteName(int track, int pitch, int chan)

EEL2: bool GetTrackMIDINoteName(#retval, int track, int pitch, int chan)

Lua: string reaper.GetTrackMIDINoteName(integer track, integer pitch, integer chan)

Python: String RPR_GetTrackMIDINoteName(Int track, Int pitch, Int chan)

see GetTrackMIDINoteNameEx



C: const char* GetTrackMIDINoteNameEx(ReaProject* proj, MediaTrack* track, int pitch, int chan)

EEL2: bool GetTrackMIDINoteNameEx(#retval, ReaProject proj, MediaTrack track, int pitch, int chan)

Lua: string reaper.GetTrackMIDINoteNameEx(ReaProject proj, MediaTrack track, integer pitch, integer chan)

Python: String RPR_GetTrackMIDINoteNameEx(ReaProject proj, MediaTrack track, Int pitch, Int chan)

Get note/CC name. pitch 128 for CC0 name, 129 for CC1 name, etc. See SetTrackMIDINoteNameEx



C: void GetTrackMIDINoteRange(ReaProject* proj, MediaTrack* track, int* note_loOut, int* note_hiOut)

EEL2: GetTrackMIDINoteRange(ReaProject proj, MediaTrack track, int &note_lo, int &note_hi)

Lua: integer note_lo, integer note_hi = reaper.GetTrackMIDINoteRange(ReaProject proj, MediaTrack track)

Python: (ReaProject proj, MediaTrack track, Int note_loOut, Int note_hiOut) = RPR_GetTrackMIDINoteRange(proj, track, note_loOut, note_hiOut)



C: bool GetTrackName(MediaTrack* track, char* bufOut, int bufOut_sz)

EEL2: bool GetTrackName(MediaTrack track, #buf)

Lua: boolean retval, string buf = reaper.GetTrackName(MediaTrack track)

Python: (Boolean retval, MediaTrack track, String bufOut, Int bufOut_sz) = RPR_GetTrackName(track, bufOut, bufOut_sz)

Returns "MASTER" for master track, "Track N" if track has no name.



C: int GetTrackNumMediaItems(MediaTrack* tr)

EEL2: int GetTrackNumMediaItems(MediaTrack tr)

Lua: integer reaper.GetTrackNumMediaItems(MediaTrack tr)

Python: Int RPR_GetTrackNumMediaItems(MediaTrack tr)



C: int GetTrackNumSends(MediaTrack* tr, int category)

EEL2: int GetTrackNumSends(MediaTrack tr, int category)

Lua: integer reaper.GetTrackNumSends(MediaTrack tr, integer category)

Python: Int RPR_GetTrackNumSends(MediaTrack tr, Int category)

returns number of sends/receives/hardware outputs - category is <0 for receives, 0=sends, >0 for hardware outputs



C: bool GetTrackReceiveName(MediaTrack* track, int recv_index, char* bufOut, int bufOut_sz)

EEL2: bool GetTrackReceiveName(MediaTrack track, int recv_index, #buf)

Lua: boolean retval, string buf = reaper.GetTrackReceiveName(MediaTrack track, integer recv_index)

Python: (Boolean retval, MediaTrack track, Int recv_index, String bufOut, Int bufOut_sz) = RPR_GetTrackReceiveName(track, recv_index, bufOut, bufOut_sz)

See GetTrackSendName.



C: bool GetTrackReceiveUIMute(MediaTrack* track, int recv_index, bool* muteOut)

EEL2: bool GetTrackReceiveUIMute(MediaTrack track, int recv_index, bool &mute)

Lua: boolean retval, boolean mute = reaper.GetTrackReceiveUIMute(MediaTrack track, integer recv_index)

Python: (Boolean retval, MediaTrack track, Int recv_index, Boolean muteOut) = RPR_GetTrackReceiveUIMute(track, recv_index, muteOut)

See GetTrackSendUIMute.



C: bool GetTrackReceiveUIVolPan(MediaTrack* track, int recv_index, double* volumeOut, double* panOut)

EEL2: bool GetTrackReceiveUIVolPan(MediaTrack track, int recv_index, &volume, &pan)

Lua: boolean retval, number volume, number pan = reaper.GetTrackReceiveUIVolPan(MediaTrack track, integer recv_index)

Python: (Boolean retval, MediaTrack track, Int recv_index, Float volumeOut, Float panOut) = RPR_GetTrackReceiveUIVolPan(track, recv_index, volumeOut, panOut)

See GetTrackSendUIVolPan.



C: double GetTrackSendInfo_Value(MediaTrack* tr, int category, int sendidx, const char* parmname)

EEL2: double GetTrackSendInfo_Value(MediaTrack tr, int category, int sendidx, "parmname")

Lua: number reaper.GetTrackSendInfo_Value(MediaTrack tr, integer category, integer sendidx, string parmname)

Python: Float RPR_GetTrackSendInfo_Value(MediaTrack tr, Int category, Int sendidx, String parmname)

Get send/receive/hardware output numerical-value attributes.
category is <0 for receives, 0=sends, >0 for hardware outputs
parameter names:
B_MUTE : bool *
B_PHASE : bool * : true to flip phase
B_MONO : bool *
D_VOL : double * : 1.0 = +0dB etc
D_PAN : double * : -1..+1
D_PANLAW : double * : 1.0=+0.0db, 0.5=-6dB, -1.0 = projdef etc
I_SENDMODE : int * : 0=post-fader, 1=pre-fx, 2=post-fx (deprecated), 3=post-fx
I_AUTOMODE : int * : automation mode (-1=use track automode, 0=trim/off, 1=read, 2=touch, 3=write, 4=latch)
I_SRCCHAN : int * : -1 for no audio send. Low 10 bits specify channel offset, and higher bits specify channel count. (srcchan>>10) == 0 for stereo, 1 for mono, 2 for 4 channel, 3 for 6 channel, etc.
I_DSTCHAN : int * : low 10 bits are destination index, &1024 set to mix to mono.
I_MIDIFLAGS : int * : low 5 bits=source channel 0=all, 1-16, next 5 bits=dest channel, 0=orig, 1-16=chan
P_DESTTRACK : MediaTrack * : destination track, only applies for sends/recvs (read-only)
P_SRCTRACK : MediaTrack * : source track, only applies for sends/recvs (read-only)
P_ENV:<envchunkname : TrackEnvelope * : call with :<VOLENV, :<PANENV, etc appended (read-only)
See CreateTrackSend, RemoveTrackSend, GetTrackNumSends.



C: bool GetTrackSendName(MediaTrack* track, int send_index, char* bufOut, int bufOut_sz)

EEL2: bool GetTrackSendName(MediaTrack track, int send_index, #buf)

Lua: boolean retval, string buf = reaper.GetTrackSendName(MediaTrack track, integer send_index)

Python: (Boolean retval, MediaTrack track, Int send_index, String bufOut, Int bufOut_sz) = RPR_GetTrackSendName(track, send_index, bufOut, bufOut_sz)

send_idx>=0 for hw ouputs, >=nb_of_hw_ouputs for sends. See GetTrackReceiveName.



C: bool GetTrackSendUIMute(MediaTrack* track, int send_index, bool* muteOut)

EEL2: bool GetTrackSendUIMute(MediaTrack track, int send_index, bool &mute)

Lua: boolean retval, boolean mute = reaper.GetTrackSendUIMute(MediaTrack track, integer send_index)

Python: (Boolean retval, MediaTrack track, Int send_index, Boolean muteOut) = RPR_GetTrackSendUIMute(track, send_index, muteOut)

send_idx>=0 for hw ouputs, >=nb_of_hw_ouputs for sends. See GetTrackReceiveUIMute.



C: bool GetTrackSendUIVolPan(MediaTrack* track, int send_index, double* volumeOut, double* panOut)

EEL2: bool GetTrackSendUIVolPan(MediaTrack track, int send_index, &volume, &pan)

Lua: boolean retval, number volume, number pan = reaper.GetTrackSendUIVolPan(MediaTrack track, integer send_index)

Python: (Boolean retval, MediaTrack track, Int send_index, Float volumeOut, Float panOut) = RPR_GetTrackSendUIVolPan(track, send_index, volumeOut, panOut)

send_idx>=0 for hw ouputs, >=nb_of_hw_ouputs for sends. See GetTrackReceiveUIVolPan.



C: const char* GetTrackState(MediaTrack* track, int* flagsOut)

EEL2: bool GetTrackState(#retval, MediaTrack track, int &flags)

Lua: string retval, integer flags = reaper.GetTrackState(MediaTrack track)

Python: (String retval, MediaTrack track, Int flagsOut) = RPR_GetTrackState(track, flagsOut)

Gets track state, returns track name.
flags will be set to:
&1=folder
&2=selected
&4=has fx enabled
&8=muted
&16=soloed
&32=SIP'd (with &16)
&64=rec armed
&128=rec monitoring on
&256=rec monitoring auto
&512=hide from TCP
&1024=hide from MCP



C: bool GetTrackStateChunk(MediaTrack* track, char* strNeedBig, int strNeedBig_sz, bool isundoOptional)

EEL2: bool GetTrackStateChunk(MediaTrack track, #str, bool isundo)

Lua: boolean retval, string str = reaper.GetTrackStateChunk(MediaTrack track, string str, boolean isundo)

Python: (Boolean retval, MediaTrack track, String strNeedBig, Int strNeedBig_sz, Boolean isundoOptional) = RPR_GetTrackStateChunk(track, strNeedBig, strNeedBig_sz, isundoOptional)

Gets the RPPXML state of a track, returns true if successful. Undo flag is a performance/caching hint.



C: bool GetTrackUIMute(MediaTrack* track, bool* muteOut)

EEL2: bool GetTrackUIMute(MediaTrack track, bool &mute)

Lua: boolean retval, boolean mute = reaper.GetTrackUIMute(MediaTrack track)

Python: (Boolean retval, MediaTrack track, Boolean muteOut) = RPR_GetTrackUIMute(track, muteOut)



C: bool GetTrackUIPan(MediaTrack* track, double* pan1Out, double* pan2Out, int* panmodeOut)

EEL2: bool GetTrackUIPan(MediaTrack track, &pan1, &pan2, int &panmode)

Lua: boolean retval, number pan1, number pan2, integer panmode = reaper.GetTrackUIPan(MediaTrack track)

Python: (Boolean retval, MediaTrack track, Float pan1Out, Float pan2Out, Int panmodeOut) = RPR_GetTrackUIPan(track, pan1Out, pan2Out, panmodeOut)



C: bool GetTrackUIVolPan(MediaTrack* track, double* volumeOut, double* panOut)

EEL2: bool GetTrackUIVolPan(MediaTrack track, &volume, &pan)

Lua: boolean retval, number volume, number pan = reaper.GetTrackUIVolPan(MediaTrack track)

Python: (Boolean retval, MediaTrack track, Float volumeOut, Float panOut) = RPR_GetTrackUIVolPan(track, volumeOut, panOut)



C: void GetUnderrunTime(unsigned int* audio_xrunOut, unsigned int* media_xrunOut, unsigned int* curtimeOut)

EEL2: GetUnderrunTime(unsigned int &audio_xrun, unsigned int &media_xrun, unsigned int &curtime)

Lua: integer audio_xrun, integer media_xrun, integer curtime = reaper.GetUnderrunTime()

Python: RPR_GetUnderrunTime(unsigned int audio_xrunOut, unsigned int media_xrunOut, unsigned int curtimeOut)

retrieves the last timestamps of audio xrun (yellow-flash, if available), media xrun (red-flash), and the current time stamp (all milliseconds)



C: bool GetUserFileNameForRead(char* filenameNeed4096, const char* title, const char* defext)

EEL2: bool GetUserFileNameForRead(#filenameNeed4096, "title", "defext")

Lua: boolean retval, string filenameNeed4096 = reaper.GetUserFileNameForRead(string filenameNeed4096, string title, string defext)

Python: (Boolean retval, String filenameNeed4096, String title, String defext) = RPR_GetUserFileNameForRead(filenameNeed4096, title, defext)

returns true if the user selected a valid file, false if the user canceled the dialog



C: bool GetUserInputs(const char* title, int num_inputs, const char* captions_csv, char* retvals_csv, int retvals_csv_sz)

EEL2: bool GetUserInputs("title", int num_inputs, "captions_csv", #retvals_csv)

Lua: boolean retval, string retvals_csv = reaper.GetUserInputs(string title, integer num_inputs, string captions_csv, string retvals_csv)

Python: (Boolean retval, String title, Int num_inputs, String captions_csv, String retvals_csv, Int retvals_csv_sz) = RPR_GetUserInputs(title, num_inputs, captions_csv, retvals_csv, retvals_csv_sz)

Get values from the user.
If a caption begins with *, for example "*password", the edit field will not display the input text.
Maximum fields is 16. Values are returned as a comma-separated string. Returns false if the user canceled the dialog. You can supply special extra information via additional caption fields: extrawidth=XXX to increase text field width, separator=X to use a different separator for returned fields.



C: void GoToMarker(ReaProject* proj, int marker_index, bool use_timeline_order)

EEL2: GoToMarker(ReaProject proj, int marker_index, bool use_timeline_order)

Lua: reaper.GoToMarker(ReaProject proj, integer marker_index, boolean use_timeline_order)

Python: RPR_GoToMarker(ReaProject proj, Int marker_index, Boolean use_timeline_order)

Go to marker. If use_timeline_order==true, marker_index 1 refers to the first marker on the timeline. If use_timeline_order==false, marker_index 1 refers to the first marker with the user-editable index of 1.



C: void GoToRegion(ReaProject* proj, int region_index, bool use_timeline_order)

EEL2: GoToRegion(ReaProject proj, int region_index, bool use_timeline_order)

Lua: reaper.GoToRegion(ReaProject proj, integer region_index, boolean use_timeline_order)

Python: RPR_GoToRegion(ReaProject proj, Int region_index, Boolean use_timeline_order)

Seek to region after current region finishes playing (smooth seek). If use_timeline_order==true, region_index 1 refers to the first region on the timeline. If use_timeline_order==false, region_index 1 refers to the first region with the user-editable index of 1.



C: int GR_SelectColor(HWND hwnd, int* colorOut)

EEL2: int GR_SelectColor(HWND hwnd, int &color)

Lua: integer retval, integer color = reaper.GR_SelectColor(HWND hwnd)

Python: (Int retval, HWND hwnd, Int colorOut) = RPR_GR_SelectColor(hwnd, colorOut)

Runs the system color chooser dialog. Returns 0 if the user cancels the dialog.



C: int GSC_mainwnd(int t)

EEL2: int GSC_mainwnd(int t)

Lua: integer reaper.GSC_mainwnd(integer t)

Python: Int RPR_GSC_mainwnd(Int t)

this is just like win32 GetSysColor() but can have overrides.



C: void guidToString(const GUID* g, char* destNeed64)

EEL2: guidToString("gGUID", #destNeed64)

Lua: string destNeed64 = reaper.guidToString(string gGUID, string destNeed64)

Python: (const GUID g, String destNeed64) = RPR_guidToString(g, destNeed64)

dest should be at least 64 chars long to be safe



C: bool HasExtState(const char* section, const char* key)

EEL2: bool HasExtState("section", "key")

Lua: boolean reaper.HasExtState(string section, string key)

Python: Boolean RPR_HasExtState(String section, String key)

Returns true if there exists an extended state value for a specific section and key. See SetExtState, GetExtState, DeleteExtState.



C: const char* HasTrackMIDIPrograms(int track)

EEL2: bool HasTrackMIDIPrograms(#retval, int track)

Lua: string reaper.HasTrackMIDIPrograms(integer track)

Python: String RPR_HasTrackMIDIPrograms(Int track)

returns name of track plugin that is supplying MIDI programs,or NULL if there is none



C: const char* HasTrackMIDIProgramsEx(ReaProject* proj, MediaTrack* track)

EEL2: bool HasTrackMIDIProgramsEx(#retval, ReaProject proj, MediaTrack track)

Lua: string reaper.HasTrackMIDIProgramsEx(ReaProject proj, MediaTrack track)

Python: String RPR_HasTrackMIDIProgramsEx(ReaProject proj, MediaTrack track)

returns name of track plugin that is supplying MIDI programs,or NULL if there is none



C: void Help_Set(const char* helpstring, bool is_temporary_help)

EEL2: Help_Set("helpstring", bool is_temporary_help)

Lua: reaper.Help_Set(string helpstring, boolean is_temporary_help)

Python: RPR_Help_Set(String helpstring, Boolean is_temporary_help)



C: void image_resolve_fn(const char* in, char* out, int out_sz)

EEL2: image_resolve_fn("in", #out)

Lua: string out = reaper.image_resolve_fn(string in, string out)

Python: (String in, String out, Int out_sz) = RPR_image_resolve_fn(in, out, out_sz)



C: int InsertAutomationItem(TrackEnvelope* env, int pool_id, double position, double length)

EEL2: int InsertAutomationItem(TrackEnvelope env, int pool_id, position, length)

Lua: integer reaper.InsertAutomationItem(TrackEnvelope env, integer pool_id, number position, number length)

Python: Int RPR_InsertAutomationItem(TrackEnvelope env, Int pool_id, Float position, Float length)

Insert a new automation item. pool_id < 0 collects existing envelope points into the automation item; if pool_id is >= 0 the automation item will be a new instance of that pool (which will be created as an empty instance if it does not exist). Returns the index of the item, suitable for passing to other automation item API functions. See GetSetAutomationItemInfo.



C: bool InsertEnvelopePoint(TrackEnvelope* envelope, double time, double value, int shape, double tension, bool selected, bool* noSortInOptional)

EEL2: bool InsertEnvelopePoint(TrackEnvelope envelope, time, value, int shape, tension, bool selected, optional bool noSortIn)

Lua: boolean reaper.InsertEnvelopePoint(TrackEnvelope envelope, number time, number value, integer shape, number tension, boolean selected, optional boolean noSortIn)

Python: (Boolean retval, TrackEnvelope envelope, Float time, Float value, Int shape, Float tension, Boolean selected, Boolean noSortInOptional) = RPR_InsertEnvelopePoint(envelope, time, value, shape, tension, selected, noSortInOptional)

Insert an envelope point. If setting multiple points at once, set noSort=true, and call Envelope_SortPoints when done. See InsertEnvelopePointEx.



C: bool InsertEnvelopePointEx(TrackEnvelope* envelope, int autoitem_idx, double time, double value, int shape, double tension, bool selected, bool* noSortInOptional)

EEL2: bool InsertEnvelopePointEx(TrackEnvelope envelope, int autoitem_idx, time, value, int shape, tension, bool selected, optional bool noSortIn)

Lua: boolean reaper.InsertEnvelopePointEx(TrackEnvelope envelope, integer autoitem_idx, number time, number value, integer shape, number tension, boolean selected, optional boolean noSortIn)

Python: (Boolean retval, TrackEnvelope envelope, Int autoitem_idx, Float time, Float value, Int shape, Float tension, Boolean selected, Boolean noSortInOptional) = RPR_InsertEnvelopePointEx(envelope, autoitem_idx, time, value, shape, tension, selected, noSortInOptional)

Insert an envelope point. If setting multiple points at once, set noSort=true, and call Envelope_SortPoints when done.
autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.
For automation items, pass autoitem_idx|0x10000000 to base ptidx on the number of points in one full loop iteration,
even if the automation item is trimmed so that not all points are visible.
Otherwise, ptidx will be based on the number of visible points in the automation item, including all loop iterations.
See CountEnvelopePointsEx, GetEnvelopePointEx, SetEnvelopePointEx, DeleteEnvelopePointEx.



C: int InsertMedia(const char* file, int mode)

EEL2: int InsertMedia("file", int mode)

Lua: integer reaper.InsertMedia(string file, integer mode)

Python: Int RPR_InsertMedia(String file, Int mode)

mode: 0=add to current track, 1=add new track, 3=add to selected items as takes, &4=stretch/loop to fit time sel, &8=try to match tempo 1x, &16=try to match tempo 0.5x, &32=try to match tempo 2x, &64=don't preserve pitch when matching tempo, &128=no loop/section if startpct/endpct set, &256=force loop regardless of global preference for looping imported items, &512=use high word as absolute track index if mode&3==0 or mode&2048, &1024=insert into reasamplomatic on a new track (add 1 to insert on last selected track), &2048=insert into open reasamplomatic instance (add 512 to use high word as absolute track index), &4096=move to source preferred position (BWF start offset), &8192=reverse



C: int InsertMediaSection(const char* file, int mode, double startpct, double endpct, double pitchshift)

EEL2: int InsertMediaSection("file", int mode, startpct, endpct, pitchshift)

Lua: integer reaper.InsertMediaSection(string file, integer mode, number startpct, number endpct, number pitchshift)

Python: Int RPR_InsertMediaSection(String file, Int mode, Float startpct, Float endpct, Float pitchshift)

See InsertMedia.



C: void InsertTrackAtIndex(int idx, bool wantDefaults)

EEL2: InsertTrackAtIndex(int idx, bool wantDefaults)

Lua: reaper.InsertTrackAtIndex(integer idx, boolean wantDefaults)

Python: RPR_InsertTrackAtIndex(Int idx, Boolean wantDefaults)

inserts a track at idx,of course this will be clamped to 0..GetNumTracks(). wantDefaults=TRUE for default envelopes/FX,otherwise no enabled fx/env



C: bool IsMediaExtension(const char* ext, bool wantOthers)

EEL2: bool IsMediaExtension("ext", bool wantOthers)

Lua: boolean reaper.IsMediaExtension(string ext, boolean wantOthers)

Python: Boolean RPR_IsMediaExtension(String ext, Boolean wantOthers)

Tests a file extension (i.e. "wav" or "mid") to see if it's a media extension.
If wantOthers is set, then "RPP", "TXT" and other project-type formats will also pass.



C: bool IsMediaItemSelected(MediaItem* item)

EEL2: bool IsMediaItemSelected(MediaItem item)

Lua: boolean reaper.IsMediaItemSelected(MediaItem item)

Python: Boolean RPR_IsMediaItemSelected(MediaItem item)



C: int IsProjectDirty(ReaProject* proj)

EEL2: int IsProjectDirty(ReaProject proj)

Lua: integer reaper.IsProjectDirty(ReaProject proj)

Python: Int RPR_IsProjectDirty(ReaProject proj)

Is the project dirty (needing save)? Always returns 0 if 'undo/prompt to save' is disabled in preferences.



C: bool IsTrackSelected(MediaTrack* track)

EEL2: bool IsTrackSelected(MediaTrack track)

Lua: boolean reaper.IsTrackSelected(MediaTrack track)

Python: Boolean RPR_IsTrackSelected(MediaTrack track)



C: bool IsTrackVisible(MediaTrack* track, bool mixer)

EEL2: bool IsTrackVisible(MediaTrack track, bool mixer)

Lua: boolean reaper.IsTrackVisible(MediaTrack track, boolean mixer)

Python: Boolean RPR_IsTrackVisible(MediaTrack track, Boolean mixer)

If mixer==true, returns true if the track is visible in the mixer. If mixer==false, returns true if the track is visible in the track control panel.



C: joystick_device* joystick_create(const GUID* guid)

EEL2: joystick_device joystick_create("guidGUID")

Lua: joystick_device reaper.joystick_create(string guidGUID)

Python: joystick_device RPR_joystick_create(const GUID guid)

creates a joystick device



C: void joystick_destroy(joystick_device* device)

EEL2: joystick_destroy(joystick_device device)

Lua: reaper.joystick_destroy(joystick_device device)

Python: RPR_joystick_destroy(joystick_device device)

destroys a joystick device



C: const char* joystick_enum(int index, const char** namestrOutOptional)

EEL2: bool joystick_enum(#retval, int index, optional #namestr)

Lua: string retval, optional string namestr = reaper.joystick_enum(integer index)

Python: String RPR_joystick_enum(Int index, String namestrOutOptional)

enumerates installed devices, returns GUID as a string



C: double joystick_getaxis(joystick_device* dev, int axis)

EEL2: double joystick_getaxis(joystick_device dev, int axis)

Lua: number reaper.joystick_getaxis(joystick_device dev, integer axis)

Python: Float RPR_joystick_getaxis(joystick_device dev, Int axis)

returns axis value (-1..1)



C: unsigned int joystick_getbuttonmask(joystick_device* dev)

EEL2: uint joystick_getbuttonmask(joystick_device dev)

Lua: integer reaper.joystick_getbuttonmask(joystick_device dev)

Python: Unknown RPR_joystick_getbuttonmask(joystick_device dev)

returns button pressed mask, 1=first button, 2=second...



C: int joystick_getinfo(joystick_device* dev, int* axesOutOptional, int* povsOutOptional)

EEL2: int joystick_getinfo(joystick_device dev, optional int &axes, optional int &povs)

Lua: integer retval, optional integer axes, optional integer povs = reaper.joystick_getinfo(joystick_device dev)

Python: (Int retval, joystick_device dev, Int axesOutOptional, Int povsOutOptional) = RPR_joystick_getinfo(dev, axesOutOptional, povsOutOptional)

returns button count



C: double joystick_getpov(joystick_device* dev, int pov)

EEL2: double joystick_getpov(joystick_device dev, int pov)

Lua: number reaper.joystick_getpov(joystick_device dev, integer pov)

Python: Float RPR_joystick_getpov(joystick_device dev, Int pov)

returns POV value (usually 0..655.35, or 655.35 on error)



C: bool joystick_update(joystick_device* dev)

EEL2: bool joystick_update(joystick_device dev)

Lua: boolean reaper.joystick_update(joystick_device dev)

Python: Boolean RPR_joystick_update(joystick_device dev)

Updates joystick state from hardware, returns true if successful (joystick_get* will not be valid until joystick_update() is called successfully)



C: int kbd_enumerateActions(KbdSectionInfo* section, int idx, const char** nameOut)

EEL2: int kbd_enumerateActions(KbdSectionInfo section, int idx, #name)

Lua: integer retval, string name = reaper.kbd_enumerateActions(KbdSectionInfo section, integer idx)

Python: Int RPR_kbd_enumerateActions(KbdSectionInfo section, Int idx, String nameOut)



C: const char* kbd_getTextFromCmd(int cmd, KbdSectionInfo* section)

EEL2: bool kbd_getTextFromCmd(#retval, int cmd, KbdSectionInfo section)

Lua: string reaper.kbd_getTextFromCmd(integer cmd, KbdSectionInfo section)

Python: String RPR_kbd_getTextFromCmd(Int cmd, KbdSectionInfo section)



C: bool LICE_ClipLine(int* pX1Out, int* pY1Out, int* pX2Out, int* pY2Out, int xLo, int yLo, int xHi, int yHi)

EEL2: bool LICE_ClipLine(int &pX1, int &pY1, int &pX2, int &pY2, int xLo, int yLo, int xHi, int yHi)

Lua: boolean retval, integer pX1, integer pY1, integer pX2, integer pY2 = reaper.LICE_ClipLine(integer pX1, integer pY1, integer pX2, integer pY2, integer xLo, integer yLo, integer xHi, integer yHi)

Python: (Boolean retval, Int pX1Out, Int pY1Out, Int pX2Out, Int pY2Out, Int xLo, Int yLo, Int xHi, Int yHi) = RPR_LICE_ClipLine(pX1Out, pY1Out, pX2Out, pY2Out, xLo, yLo, xHi, yHi)

Returns false if the line is entirely offscreen.



C: const char* LocalizeString(const char* src_string, const char* section, int flagsOptional)

EEL2: bool LocalizeString(#retval, "src_string", "section", int flags)

Lua: string reaper.LocalizeString(string src_string, string section, integer flags)

Python: String RPR_LocalizeString(String src_string, String section, Int flagsOptional)

Returns a localized version of src_string, in section section. flags can have 1 set to only localize if sprintf-style formatting matches the original.



C: bool Loop_OnArrow(ReaProject* project, int direction)

EEL2: bool Loop_OnArrow(ReaProject project, int direction)

Lua: boolean reaper.Loop_OnArrow(ReaProject project, integer direction)

Python: Boolean RPR_Loop_OnArrow(ReaProject project, Int direction)

Move the loop selection left or right. Returns true if snap is enabled.



C: void Main_OnCommand(int command, int flag)

EEL2: Main_OnCommand(int command, int flag)

Lua: reaper.Main_OnCommand(integer command, integer flag)

Python: RPR_Main_OnCommand(Int command, Int flag)

See Main_OnCommandEx.



C: void Main_OnCommandEx(int command, int flag, ReaProject* proj)

EEL2: Main_OnCommandEx(int command, int flag, ReaProject proj)

Lua: reaper.Main_OnCommandEx(integer command, integer flag, ReaProject proj)

Python: RPR_Main_OnCommandEx(Int command, Int flag, ReaProject proj)

Performs an action belonging to the main action section. To perform non-native actions (ReaScripts, custom or extension plugins' actions) safely, see NamedCommandLookup().



C: void Main_openProject(const char* name)

EEL2: Main_openProject("name")

Lua: reaper.Main_openProject(string name)

Python: RPR_Main_openProject(String name)

opens a project. will prompt the user to save unless name is prefixed with 'noprompt:'. If name is prefixed with 'template:', project file will be loaded as a template.
If passed a .RTrackTemplate file, adds the template to the existing project.



C: void Main_SaveProject(ReaProject* proj, bool forceSaveAsInOptional)

EEL2: Main_SaveProject(ReaProject proj, bool forceSaveAsIn)

Lua: reaper.Main_SaveProject(ReaProject proj, boolean forceSaveAsIn)

Python: RPR_Main_SaveProject(ReaProject proj, Boolean forceSaveAsInOptional)

Save the project.



C: void Main_SaveProjectEx(ReaProject* proj, const char* filename, int options)

EEL2: Main_SaveProjectEx(ReaProject proj, "filename", int options)

Lua: reaper.Main_SaveProjectEx(ReaProject proj, string filename, integer options)

Python: RPR_Main_SaveProjectEx(ReaProject proj, String filename, Int options)

Save the project. options: &1=save selected tracks as track template, &2=include media with track template, &4=include envelopes with track template. See Main_openProject, Main_SaveProject.



C: void Main_UpdateLoopInfo(int ignoremask)

EEL2: Main_UpdateLoopInfo(int ignoremask)

Lua: reaper.Main_UpdateLoopInfo(integer ignoremask)

Python: RPR_Main_UpdateLoopInfo(Int ignoremask)



C: void MarkProjectDirty(ReaProject* proj)

EEL2: MarkProjectDirty(ReaProject proj)

Lua: reaper.MarkProjectDirty(ReaProject proj)

Python: RPR_MarkProjectDirty(ReaProject proj)

Marks project as dirty (needing save) if 'undo/prompt to save' is enabled in preferences.



C: void MarkTrackItemsDirty(MediaTrack* track, MediaItem* item)

EEL2: MarkTrackItemsDirty(MediaTrack track, MediaItem item)

Lua: reaper.MarkTrackItemsDirty(MediaTrack track, MediaItem item)

Python: RPR_MarkTrackItemsDirty(MediaTrack track, MediaItem item)

If track is supplied, item is ignored



C: double Master_GetPlayRate(ReaProject* project)

EEL2: double Master_GetPlayRate(ReaProject project)

Lua: number reaper.Master_GetPlayRate(ReaProject project)

Python: Float RPR_Master_GetPlayRate(ReaProject project)



C: double Master_GetPlayRateAtTime(double time_s, ReaProject* proj)

EEL2: double Master_GetPlayRateAtTime(time_s, ReaProject proj)

Lua: number reaper.Master_GetPlayRateAtTime(number time_s, ReaProject proj)

Python: Float RPR_Master_GetPlayRateAtTime(Float time_s, ReaProject proj)



C: double Master_GetTempo()

EEL2: double Master_GetTempo()

Lua: number reaper.Master_GetTempo()

Python: Float RPR_Master_GetTempo()



C: double Master_NormalizePlayRate(double playrate, bool isnormalized)

EEL2: double Master_NormalizePlayRate(playrate, bool isnormalized)

Lua: number reaper.Master_NormalizePlayRate(number playrate, boolean isnormalized)

Python: Float RPR_Master_NormalizePlayRate(Float playrate, Boolean isnormalized)

Convert play rate to/from a value between 0 and 1, representing the position on the project playrate slider.



C: double Master_NormalizeTempo(double bpm, bool isnormalized)

EEL2: double Master_NormalizeTempo(bpm, bool isnormalized)

Lua: number reaper.Master_NormalizeTempo(number bpm, boolean isnormalized)

Python: Float RPR_Master_NormalizeTempo(Float bpm, Boolean isnormalized)

Convert the tempo to/from a value between 0 and 1, representing bpm in the range of 40-296 bpm.



C: int MB(const char* msg, const char* title, int type)

EEL2: int MB("msg", "title", int type)

Lua: integer reaper.MB(string msg, string title, integer type)

Python: Int RPR_MB(String msg, String title, Int type)

type 0=OK,1=OKCANCEL,2=ABORTRETRYIGNORE,3=YESNOCANCEL,4=YESNO,5=RETRYCANCEL : ret 1=OK,2=CANCEL,3=ABORT,4=RETRY,5=IGNORE,6=YES,7=NO



C: int MediaItemDescendsFromTrack(MediaItem* item, MediaTrack* track)

EEL2: int MediaItemDescendsFromTrack(MediaItem item, MediaTrack track)

Lua: integer reaper.MediaItemDescendsFromTrack(MediaItem item, MediaTrack track)

Python: Int RPR_MediaItemDescendsFromTrack(MediaItem item, MediaTrack track)

Returns 1 if the track holds the item, 2 if the track is a folder containing the track that holds the item, etc.



C: int MIDI_CountEvts(MediaItem_Take* take, int* notecntOut, int* ccevtcntOut, int* textsyxevtcntOut)

EEL2: int MIDI_CountEvts(MediaItem_Take take, int &notecnt, int &ccevtcnt, int &textsyxevtcnt)

Lua: integer retval, integer notecnt, integer ccevtcnt, integer textsyxevtcnt = reaper.MIDI_CountEvts(MediaItem_Take take)

Python: (Int retval, MediaItem_Take take, Int notecntOut, Int ccevtcntOut, Int textsyxevtcntOut) = RPR_MIDI_CountEvts(take, notecntOut, ccevtcntOut, textsyxevtcntOut)

Count the number of notes, CC events, and text/sysex events in a given MIDI item.



C: bool MIDI_DeleteCC(MediaItem_Take* take, int ccidx)

EEL2: bool MIDI_DeleteCC(MediaItem_Take take, int ccidx)

Lua: boolean reaper.MIDI_DeleteCC(MediaItem_Take take, integer ccidx)

Python: Boolean RPR_MIDI_DeleteCC(MediaItem_Take take, Int ccidx)

Delete a MIDI CC event.



C: bool MIDI_DeleteEvt(MediaItem_Take* take, int evtidx)

EEL2: bool MIDI_DeleteEvt(MediaItem_Take take, int evtidx)

Lua: boolean reaper.MIDI_DeleteEvt(MediaItem_Take take, integer evtidx)

Python: Boolean RPR_MIDI_DeleteEvt(MediaItem_Take take, Int evtidx)

Delete a MIDI event.



C: bool MIDI_DeleteNote(MediaItem_Take* take, int noteidx)

EEL2: bool MIDI_DeleteNote(MediaItem_Take take, int noteidx)

Lua: boolean reaper.MIDI_DeleteNote(MediaItem_Take take, integer noteidx)

Python: Boolean RPR_MIDI_DeleteNote(MediaItem_Take take, Int noteidx)

Delete a MIDI note.



C: bool MIDI_DeleteTextSysexEvt(MediaItem_Take* take, int textsyxevtidx)

EEL2: bool MIDI_DeleteTextSysexEvt(MediaItem_Take take, int textsyxevtidx)

Lua: boolean reaper.MIDI_DeleteTextSysexEvt(MediaItem_Take take, integer textsyxevtidx)

Python: Boolean RPR_MIDI_DeleteTextSysexEvt(MediaItem_Take take, Int textsyxevtidx)

Delete a MIDI text or sysex event.



C: void MIDI_DisableSort(MediaItem_Take* take)

EEL2: MIDI_DisableSort(MediaItem_Take take)

Lua: reaper.MIDI_DisableSort(MediaItem_Take take)

Python: RPR_MIDI_DisableSort(MediaItem_Take take)

Disable sorting for all MIDI insert, delete, get and set functions, until MIDI_Sort is called.



C: int MIDI_EnumSelCC(MediaItem_Take* take, int ccidx)

EEL2: int MIDI_EnumSelCC(MediaItem_Take take, int ccidx)

Lua: integer reaper.MIDI_EnumSelCC(MediaItem_Take take, integer ccidx)

Python: Int RPR_MIDI_EnumSelCC(MediaItem_Take take, Int ccidx)

Returns the index of the next selected MIDI CC event after ccidx (-1 if there are no more selected events).



C: int MIDI_EnumSelEvts(MediaItem_Take* take, int evtidx)

EEL2: int MIDI_EnumSelEvts(MediaItem_Take take, int evtidx)

Lua: integer reaper.MIDI_EnumSelEvts(MediaItem_Take take, integer evtidx)

Python: Int RPR_MIDI_EnumSelEvts(MediaItem_Take take, Int evtidx)

Returns the index of the next selected MIDI event after evtidx (-1 if there are no more selected events).



C: int MIDI_EnumSelNotes(MediaItem_Take* take, int noteidx)

EEL2: int MIDI_EnumSelNotes(MediaItem_Take take, int noteidx)

Lua: integer reaper.MIDI_EnumSelNotes(MediaItem_Take take, integer noteidx)

Python: Int RPR_MIDI_EnumSelNotes(MediaItem_Take take, Int noteidx)

Returns the index of the next selected MIDI note after noteidx (-1 if there are no more selected events).



C: int MIDI_EnumSelTextSysexEvts(MediaItem_Take* take, int textsyxidx)

EEL2: int MIDI_EnumSelTextSysexEvts(MediaItem_Take take, int textsyxidx)

Lua: integer reaper.MIDI_EnumSelTextSysexEvts(MediaItem_Take take, integer textsyxidx)

Python: Int RPR_MIDI_EnumSelTextSysexEvts(MediaItem_Take take, Int textsyxidx)

Returns the index of the next selected MIDI text/sysex event after textsyxidx (-1 if there are no more selected events).



C: bool MIDI_GetAllEvts(MediaItem_Take* take, char* bufOutNeedBig, int* bufOutNeedBig_sz)

EEL2: bool MIDI_GetAllEvts(MediaItem_Take take, #buf)

Lua: boolean retval, string buf = reaper.MIDI_GetAllEvts(MediaItem_Take take)

Python: (Boolean retval, MediaItem_Take take, String bufOutNeedBig, Int bufOutNeedBig_sz) = RPR_MIDI_GetAllEvts(take, bufOutNeedBig, bufOutNeedBig_sz)

Get all MIDI data. MIDI buffer is returned as a list of { int offset, char flag, int msglen, unsigned char msg[] }.
offset: MIDI ticks from previous event
flag: &1=selected &2=muted
flag high 4 bits for CC shape: &16=linear, &32=slow start/end, &16|32=fast start, &64=fast end, &64|16=bezier
msg: the MIDI message.
A meta-event of type 0xF followed by 'CCBZ ' and 5 more bytes represents bezier curve data for the previous MIDI event: 1 byte for the bezier type (usually 0) and 4 bytes for the bezier tension as a float.
For tick intervals longer than a 32 bit word can represent, zero-length meta events may be placed between valid events.
See MIDI_SetAllEvts.



C: bool MIDI_GetCC(MediaItem_Take* take, int ccidx, bool* selectedOut, bool* mutedOut, double* ppqposOut, int* chanmsgOut, int* chanOut, int* msg2Out, int* msg3Out)

EEL2: bool MIDI_GetCC(MediaItem_Take take, int ccidx, bool &selected, bool &muted, &ppqpos, int &chanmsg, int &chan, int &msg2, int &msg3)

Lua: boolean retval, boolean selected, boolean muted, number ppqpos, integer chanmsg, integer chan, integer msg2, integer msg3 = reaper.MIDI_GetCC(MediaItem_Take take, integer ccidx)

Python: (Boolean retval, MediaItem_Take take, Int ccidx, Boolean selectedOut, Boolean mutedOut, Float ppqposOut, Int chanmsgOut, Int chanOut, Int msg2Out, Int msg3Out) = RPR_MIDI_GetCC(take, ccidx, selectedOut, mutedOut, ppqposOut, chanmsgOut, chanOut, msg2Out, msg3Out)

Get MIDI CC event properties.



C: bool MIDI_GetCCShape(MediaItem_Take* take, int ccidx, int* shapeOut, double* beztensionOut)

EEL2: bool MIDI_GetCCShape(MediaItem_Take take, int ccidx, int &shape, &beztension)

Lua: boolean retval, integer shape, number beztension = reaper.MIDI_GetCCShape(MediaItem_Take take, integer ccidx)

Python: (Boolean retval, MediaItem_Take take, Int ccidx, Int shapeOut, Float beztensionOut) = RPR_MIDI_GetCCShape(take, ccidx, shapeOut, beztensionOut)

Get CC shape and bezier tension. See MIDI_GetCC, MIDI_SetCCShape



C: bool MIDI_GetEvt(MediaItem_Take* take, int evtidx, bool* selectedOut, bool* mutedOut, double* ppqposOut, char* msgOut, int* msgOut_sz)

EEL2: bool MIDI_GetEvt(MediaItem_Take take, int evtidx, bool &selected, bool &muted, &ppqpos, #msg)

Lua: boolean retval, boolean selected, boolean muted, number ppqpos, string msg = reaper.MIDI_GetEvt(MediaItem_Take take, integer evtidx)

Python: (Boolean retval, MediaItem_Take take, Int evtidx, Boolean selectedOut, Boolean mutedOut, Float ppqposOut, String msgOut, Int msgOut_sz) = RPR_MIDI_GetEvt(take, evtidx, selectedOut, mutedOut, ppqposOut, msgOut, msgOut_sz)

Get MIDI event properties.



C: double MIDI_GetGrid(MediaItem_Take* take, double* swingOutOptional, double* noteLenOutOptional)

EEL2: double MIDI_GetGrid(MediaItem_Take take, optional &swing, optional &noteLen)

Lua: number retval, optional number swing, optional number noteLen = reaper.MIDI_GetGrid(MediaItem_Take take)

Python: (Float retval, MediaItem_Take take, Float swingOutOptional, Float noteLenOutOptional) = RPR_MIDI_GetGrid(take, swingOutOptional, noteLenOutOptional)

Returns the most recent MIDI editor grid size for this MIDI take, in QN. Swing is between 0 and 1. Note length is 0 if it follows the grid size.



C: bool MIDI_GetHash(MediaItem_Take* take, bool notesonly, char* hashOut, int hashOut_sz)

EEL2: bool MIDI_GetHash(MediaItem_Take take, bool notesonly, #hash)

Lua: boolean retval, string hash = reaper.MIDI_GetHash(MediaItem_Take take, boolean notesonly)

Python: (Boolean retval, MediaItem_Take take, Boolean notesonly, String hashOut, Int hashOut_sz) = RPR_MIDI_GetHash(take, notesonly, hashOut, hashOut_sz)

Get a string that only changes when the MIDI data changes. If notesonly==true, then the string changes only when the MIDI notes change. See MIDI_GetTrackHash



C: bool MIDI_GetNote(MediaItem_Take* take, int noteidx, bool* selectedOut, bool* mutedOut, double* startppqposOut, double* endppqposOut, int* chanOut, int* pitchOut, int* velOut)

EEL2: bool MIDI_GetNote(MediaItem_Take take, int noteidx, bool &selected, bool &muted, &startppqpos, &endppqpos, int &chan, int &pitch, int &vel)

Lua: boolean retval, boolean selected, boolean muted, number startppqpos, number endppqpos, integer chan, integer pitch, integer vel = reaper.MIDI_GetNote(MediaItem_Take take, integer noteidx)

Python: (Boolean retval, MediaItem_Take take, Int noteidx, Boolean selectedOut, Boolean mutedOut, Float startppqposOut, Float endppqposOut, Int chanOut, Int pitchOut, Int velOut) = RPR_MIDI_GetNote(take, noteidx, selectedOut, mutedOut, startppqposOut, endppqposOut, chanOut, pitchOut, velOut)

Get MIDI note properties.



C: double MIDI_GetPPQPos_EndOfMeasure(MediaItem_Take* take, double ppqpos)

EEL2: double MIDI_GetPPQPos_EndOfMeasure(MediaItem_Take take, ppqpos)

Lua: number reaper.MIDI_GetPPQPos_EndOfMeasure(MediaItem_Take take, number ppqpos)

Python: Float RPR_MIDI_GetPPQPos_EndOfMeasure(MediaItem_Take take, Float ppqpos)

Returns the MIDI tick (ppq) position corresponding to the end of the measure.



C: double MIDI_GetPPQPos_StartOfMeasure(MediaItem_Take* take, double ppqpos)

EEL2: double MIDI_GetPPQPos_StartOfMeasure(MediaItem_Take take, ppqpos)

Lua: number reaper.MIDI_GetPPQPos_StartOfMeasure(MediaItem_Take take, number ppqpos)

Python: Float RPR_MIDI_GetPPQPos_StartOfMeasure(MediaItem_Take take, Float ppqpos)

Returns the MIDI tick (ppq) position corresponding to the start of the measure.



C: double MIDI_GetPPQPosFromProjQN(MediaItem_Take* take, double projqn)

EEL2: double MIDI_GetPPQPosFromProjQN(MediaItem_Take take, projqn)

Lua: number reaper.MIDI_GetPPQPosFromProjQN(MediaItem_Take take, number projqn)

Python: Float RPR_MIDI_GetPPQPosFromProjQN(MediaItem_Take take, Float projqn)

Returns the MIDI tick (ppq) position corresponding to a specific project time in quarter notes.



C: double MIDI_GetPPQPosFromProjTime(MediaItem_Take* take, double projtime)

EEL2: double MIDI_GetPPQPosFromProjTime(MediaItem_Take take, projtime)

Lua: number reaper.MIDI_GetPPQPosFromProjTime(MediaItem_Take take, number projtime)

Python: Float RPR_MIDI_GetPPQPosFromProjTime(MediaItem_Take take, Float projtime)

Returns the MIDI tick (ppq) position corresponding to a specific project time in seconds.



C: double MIDI_GetProjQNFromPPQPos(MediaItem_Take* take, double ppqpos)

EEL2: double MIDI_GetProjQNFromPPQPos(MediaItem_Take take, ppqpos)

Lua: number reaper.MIDI_GetProjQNFromPPQPos(MediaItem_Take take, number ppqpos)

Python: Float RPR_MIDI_GetProjQNFromPPQPos(MediaItem_Take take, Float ppqpos)

Returns the project time in quarter notes corresponding to a specific MIDI tick (ppq) position.



C: double MIDI_GetProjTimeFromPPQPos(MediaItem_Take* take, double ppqpos)

EEL2: double MIDI_GetProjTimeFromPPQPos(MediaItem_Take take, ppqpos)

Lua: number reaper.MIDI_GetProjTimeFromPPQPos(MediaItem_Take take, number ppqpos)

Python: Float RPR_MIDI_GetProjTimeFromPPQPos(MediaItem_Take take, Float ppqpos)

Returns the project time in seconds corresponding to a specific MIDI tick (ppq) position.



C: int MIDI_GetRecentInputEvent(int idx, char* bufOut, int* bufOut_sz, int* tsOut, int* devIdxOut, double* projPosOut, int* projLoopCntOut)

EEL2: int MIDI_GetRecentInputEvent(int idx, #buf, int &ts, int &devIdx, &projPos, int &projLoopCnt)

Lua: integer retval, string buf, integer ts, integer devIdx, number projPos, integer projLoopCnt = reaper.MIDI_GetRecentInputEvent(integer idx)

Python: (Int retval, Int idx, String bufOut, Int bufOut_sz, Int tsOut, Int devIdxOut, Float projPosOut, Int projLoopCntOut) = RPR_MIDI_GetRecentInputEvent(idx, bufOut, bufOut_sz, tsOut, devIdxOut, projPosOut, projLoopCntOut)

Gets a recent MIDI input event from the global history. idx=0 for the most recent event, which also latches to the latest MIDI event state (to get a more recent list, calling with idx=0 is necessary). idx=1 next most recent event, returns a non-zero sequence number for the event, or zero if no more events. tsOut will be set to the timestamp in samples relative to the current position (0 is current, -48000 is one second ago, etc). devIdxOut will have the low 16 bits set to the input device index, and 0x10000 will be set if device was enabled only for control. projPosOut will be set to project position in seconds if project was playing back at time of event, otherwise -1. Large SysEx events will not be included in this event list.



C: bool MIDI_GetScale(MediaItem_Take* take, int* rootOut, int* scaleOut, char* nameOut, int nameOut_sz)

EEL2: bool MIDI_GetScale(MediaItem_Take take, int &root, int &scale, #name)

Lua: boolean retval, integer root, integer scale, string name = reaper.MIDI_GetScale(MediaItem_Take take)

Python: (Boolean retval, MediaItem_Take take, Int rootOut, Int scaleOut, String nameOut, Int nameOut_sz) = RPR_MIDI_GetScale(take, rootOut, scaleOut, nameOut, nameOut_sz)

Get the active scale in the media source, if any. root 0=C, 1=C#, etc. scale &0x1=root, &0x2=minor 2nd, &0x4=major 2nd, &0x8=minor 3rd, &0xF=fourth, etc.



C: bool MIDI_GetTextSysexEvt(MediaItem_Take* take, int textsyxevtidx, bool* selectedOutOptional, bool* mutedOutOptional, double* ppqposOutOptional, int* typeOutOptional, char* msgOptional, int* msgOptional_sz)

EEL2: bool MIDI_GetTextSysexEvt(MediaItem_Take take, int textsyxevtidx, optional bool &selected, optional bool &muted, optional &ppqpos, optional int &type, optional #msg)

Lua: boolean retval, optional boolean selected, optional boolean muted, optional number ppqpos, optional integer type, optional string msg = reaper.MIDI_GetTextSysexEvt(MediaItem_Take take, integer textsyxevtidx, optional boolean selected, optional boolean muted, optional number ppqpos, optional integer type, optional string msg)

Python: (Boolean retval, MediaItem_Take take, Int textsyxevtidx, Boolean selectedOutOptional, Boolean mutedOutOptional, Float ppqposOutOptional, Int typeOutOptional, String msgOptional, Int msgOptional_sz) = RPR_MIDI_GetTextSysexEvt(take, textsyxevtidx, selectedOutOptional, mutedOutOptional, ppqposOutOptional, typeOutOptional, msgOptional, msgOptional_sz)

Get MIDI meta-event properties. Allowable types are -1:sysex (msg should not include bounding F0..F7), 1-14:MIDI text event types, 15=REAPER notation event. For all other meta-messages, type is returned as -2 and msg returned as all zeroes. See MIDI_GetEvt.



C: bool MIDI_GetTrackHash(MediaTrack* track, bool notesonly, char* hashOut, int hashOut_sz)

EEL2: bool MIDI_GetTrackHash(MediaTrack track, bool notesonly, #hash)

Lua: boolean retval, string hash = reaper.MIDI_GetTrackHash(MediaTrack track, boolean notesonly)

Python: (Boolean retval, MediaTrack track, Boolean notesonly, String hashOut, Int hashOut_sz) = RPR_MIDI_GetTrackHash(track, notesonly, hashOut, hashOut_sz)

Get a string that only changes when the MIDI data changes. If notesonly==true, then the string changes only when the MIDI notes change. See MIDI_GetHash



C: void midi_init(int force_reinit_input, int force_reinit_output)

EEL2: midi_init(int force_reinit_input, int force_reinit_output)

Lua: reaper.midi_init(integer force_reinit_input, integer force_reinit_output)

Python: RPR_midi_init(Int force_reinit_input, Int force_reinit_output)

Opens MIDI devices as configured in preferences. force_reinit_input and force_reinit_output force a particular device index to close/re-open (pass -1 to not force any devices to reopen).



C: bool MIDI_InsertCC(MediaItem_Take* take, bool selected, bool muted, double ppqpos, int chanmsg, int chan, int msg2, int msg3)

EEL2: bool MIDI_InsertCC(MediaItem_Take take, bool selected, bool muted, ppqpos, int chanmsg, int chan, int msg2, int msg3)

Lua: boolean reaper.MIDI_InsertCC(MediaItem_Take take, boolean selected, boolean muted, number ppqpos, integer chanmsg, integer chan, integer msg2, integer msg3)

Python: Boolean RPR_MIDI_InsertCC(MediaItem_Take take, Boolean selected, Boolean muted, Float ppqpos, Int chanmsg, Int chan, Int msg2, Int msg3)

Insert a new MIDI CC event.



C: bool MIDI_InsertEvt(MediaItem_Take* take, bool selected, bool muted, double ppqpos, const char* bytestr, int bytestr_sz)

EEL2: bool MIDI_InsertEvt(MediaItem_Take take, bool selected, bool muted, ppqpos, "bytestr")

Lua: boolean reaper.MIDI_InsertEvt(MediaItem_Take take, boolean selected, boolean muted, number ppqpos, string bytestr)

Python: Boolean RPR_MIDI_InsertEvt(MediaItem_Take take, Boolean selected, Boolean muted, Float ppqpos, String bytestr, Int bytestr_sz)

Insert a new MIDI event.



C: bool MIDI_InsertNote(MediaItem_Take* take, bool selected, bool muted, double startppqpos, double endppqpos, int chan, int pitch, int vel, const bool* noSortInOptional)

EEL2: bool MIDI_InsertNote(MediaItem_Take take, bool selected, bool muted, startppqpos, endppqpos, int chan, int pitch, int vel, optional bool noSortIn)

Lua: boolean reaper.MIDI_InsertNote(MediaItem_Take take, boolean selected, boolean muted, number startppqpos, number endppqpos, integer chan, integer pitch, integer vel, optional boolean noSortIn)

Python: Boolean RPR_MIDI_InsertNote(MediaItem_Take take, Boolean selected, Boolean muted, Float startppqpos, Float endppqpos, Int chan, Int pitch, Int vel, const bool noSortInOptional)

Insert a new MIDI note. Set noSort if inserting multiple events, then call MIDI_Sort when done.



C: bool MIDI_InsertTextSysexEvt(MediaItem_Take* take, bool selected, bool muted, double ppqpos, int type, const char* bytestr, int bytestr_sz)

EEL2: bool MIDI_InsertTextSysexEvt(MediaItem_Take take, bool selected, bool muted, ppqpos, int type, "bytestr")

Lua: boolean reaper.MIDI_InsertTextSysexEvt(MediaItem_Take take, boolean selected, boolean muted, number ppqpos, integer type, string bytestr)

Python: Boolean RPR_MIDI_InsertTextSysexEvt(MediaItem_Take take, Boolean selected, Boolean muted, Float ppqpos, Int type, String bytestr, Int bytestr_sz)

Insert a new MIDI text or sysex event. Allowable types are -1:sysex (msg should not include bounding F0..F7), 1-14:MIDI text event types, 15=REAPER notation event.



C: void midi_reinit()

EEL2: midi_reinit()

Lua: reaper.midi_reinit()

Python: RPR_midi_reinit()

Reset (close and re-open) all MIDI devices



C: void MIDI_SelectAll(MediaItem_Take* take, bool select)

EEL2: MIDI_SelectAll(MediaItem_Take take, bool select)

Lua: reaper.MIDI_SelectAll(MediaItem_Take take, boolean select)

Python: RPR_MIDI_SelectAll(MediaItem_Take take, Boolean select)

Select or deselect all MIDI content.



C: bool MIDI_SetAllEvts(MediaItem_Take* take, const char* buf, int buf_sz)

EEL2: bool MIDI_SetAllEvts(MediaItem_Take take, "buf")

Lua: boolean reaper.MIDI_SetAllEvts(MediaItem_Take take, string buf)

Python: Boolean RPR_MIDI_SetAllEvts(MediaItem_Take take, String buf, Int buf_sz)

Set all MIDI data. MIDI buffer is passed in as a list of { int offset, char flag, int msglen, unsigned char msg[] }.
offset: MIDI ticks from previous event
flag: &1=selected &2=muted
flag high 4 bits for CC shape: &16=linear, &32=slow start/end, &16|32=fast start, &64=fast end, &64|16=bezier
msg: the MIDI message.
A meta-event of type 0xF followed by 'CCBZ ' and 5 more bytes represents bezier curve data for the previous MIDI event: 1 byte for the bezier type (usually 0) and 4 bytes for the bezier tension as a float.
For tick intervals longer than a 32 bit word can represent, zero-length meta events may be placed between valid events.
See MIDI_GetAllEvts.



C: bool MIDI_SetCC(MediaItem_Take* take, int ccidx, const bool* selectedInOptional, const bool* mutedInOptional, const double* ppqposInOptional, const int* chanmsgInOptional, const int* chanInOptional, const int* msg2InOptional, const int* msg3InOptional, const bool* noSortInOptional)

EEL2: bool MIDI_SetCC(MediaItem_Take take, int ccidx, optional bool selectedIn, optional bool mutedIn, optional ppqposIn, optional int chanmsgIn, optional int chanIn, optional int msg2In, optional int msg3In, optional bool noSortIn)

Lua: boolean reaper.MIDI_SetCC(MediaItem_Take take, integer ccidx, optional boolean selectedIn, optional boolean mutedIn, optional number ppqposIn, optional integer chanmsgIn, optional integer chanIn, optional integer msg2In, optional integer msg3In, optional boolean noSortIn)

Python: Boolean RPR_MIDI_SetCC(MediaItem_Take take, Int ccidx, const bool selectedInOptional, const bool mutedInOptional, const double ppqposInOptional, const int chanmsgInOptional, const int chanInOptional, const int msg2InOptional, const int msg3InOptional, const bool noSortInOptional)

Set MIDI CC event properties. Properties passed as NULL will not be set. set noSort if setting multiple events, then call MIDI_Sort when done.



C: bool MIDI_SetCCShape(MediaItem_Take* take, int ccidx, int shape, double beztension, const bool* noSortInOptional)

EEL2: bool MIDI_SetCCShape(MediaItem_Take take, int ccidx, int shape, beztension, optional bool noSortIn)

Lua: boolean reaper.MIDI_SetCCShape(MediaItem_Take take, integer ccidx, integer shape, number beztension, optional boolean noSortIn)

Python: Boolean RPR_MIDI_SetCCShape(MediaItem_Take take, Int ccidx, Int shape, Float beztension, const bool noSortInOptional)

Set CC shape and bezier tension. set noSort if setting multiple events, then call MIDI_Sort when done. See MIDI_SetCC, MIDI_GetCCShape



C: bool MIDI_SetEvt(MediaItem_Take* take, int evtidx, const bool* selectedInOptional, const bool* mutedInOptional, const double* ppqposInOptional, const char* msgOptional, int msgOptional_sz, const bool* noSortInOptional)

EEL2: bool MIDI_SetEvt(MediaItem_Take take, int evtidx, optional bool selectedIn, optional bool mutedIn, optional ppqposIn, optional "msg", optional bool noSortIn)

Lua: boolean reaper.MIDI_SetEvt(MediaItem_Take take, integer evtidx, optional boolean selectedIn, optional boolean mutedIn, optional number ppqposIn, optional string msg, optional boolean noSortIn)

Python: Boolean RPR_MIDI_SetEvt(MediaItem_Take take, Int evtidx, const bool selectedInOptional, const bool mutedInOptional, const double ppqposInOptional, String msgOptional, Int msgOptional_sz, const bool noSortInOptional)

Set MIDI event properties. Properties passed as NULL will not be set. set noSort if setting multiple events, then call MIDI_Sort when done.



C: bool MIDI_SetItemExtents(MediaItem* item, double startQN, double endQN)

EEL2: bool MIDI_SetItemExtents(MediaItem item, startQN, endQN)

Lua: boolean reaper.MIDI_SetItemExtents(MediaItem item, number startQN, number endQN)

Python: Boolean RPR_MIDI_SetItemExtents(MediaItem item, Float startQN, Float endQN)

Set the start/end positions of a media item that contains a MIDI take.



C: bool MIDI_SetNote(MediaItem_Take* take, int noteidx, const bool* selectedInOptional, const bool* mutedInOptional, const double* startppqposInOptional, const double* endppqposInOptional, const int* chanInOptional, const int* pitchInOptional, const int* velInOptional, const bool* noSortInOptional)

EEL2: bool MIDI_SetNote(MediaItem_Take take, int noteidx, optional bool selectedIn, optional bool mutedIn, optional startppqposIn, optional endppqposIn, optional int chanIn, optional int pitchIn, optional int velIn, optional bool noSortIn)

Lua: boolean reaper.MIDI_SetNote(MediaItem_Take take, integer noteidx, optional boolean selectedIn, optional boolean mutedIn, optional number startppqposIn, optional number endppqposIn, optional integer chanIn, optional integer pitchIn, optional integer velIn, optional boolean noSortIn)

Python: Boolean RPR_MIDI_SetNote(MediaItem_Take take, Int noteidx, const bool selectedInOptional, const bool mutedInOptional, const double startppqposInOptional, const double endppqposInOptional, const int chanInOptional, const int pitchInOptional, const int velInOptional, const bool noSortInOptional)

Set MIDI note properties. Properties passed as NULL (or negative values) will not be set. Set noSort if setting multiple events, then call MIDI_Sort when done. Setting multiple note start positions at once is done more safely by deleting and re-inserting the notes.



C: bool MIDI_SetTextSysexEvt(MediaItem_Take* take, int textsyxevtidx, const bool* selectedInOptional, const bool* mutedInOptional, const double* ppqposInOptional, const int* typeInOptional, const char* msgOptional, int msgOptional_sz, const bool* noSortInOptional)

EEL2: bool MIDI_SetTextSysexEvt(MediaItem_Take take, int textsyxevtidx, optional bool selectedIn, optional bool mutedIn, optional ppqposIn, optional int typeIn, optional "msg", optional bool noSortIn)

Lua: boolean reaper.MIDI_SetTextSysexEvt(MediaItem_Take take, integer textsyxevtidx, optional boolean selectedIn, optional boolean mutedIn, optional number ppqposIn, optional integer typeIn, optional string msg, optional boolean noSortIn)

Python: Boolean RPR_MIDI_SetTextSysexEvt(MediaItem_Take take, Int textsyxevtidx, const bool selectedInOptional, const bool mutedInOptional, const double ppqposInOptional, const int typeInOptional, String msgOptional, Int msgOptional_sz, const bool noSortInOptional)

Set MIDI text or sysex event properties. Properties passed as NULL will not be set. Allowable types are -1:sysex (msg should not include bounding F0..F7), 1-14:MIDI text event types, 15=REAPER notation event. set noSort if setting multiple events, then call MIDI_Sort when done.



C: void MIDI_Sort(MediaItem_Take* take)

EEL2: MIDI_Sort(MediaItem_Take take)

Lua: reaper.MIDI_Sort(MediaItem_Take take)

Python: RPR_MIDI_Sort(MediaItem_Take take)

Sort MIDI events after multiple calls to MIDI_SetNote, MIDI_SetCC, etc.



C: MediaItem_Take* MIDIEditor_EnumTakes(HWND midieditor, int takeindex, bool editable_only)

EEL2: MediaItem_Take MIDIEditor_EnumTakes(HWND midieditor, int takeindex, bool editable_only)

Lua: MediaItem_Take reaper.MIDIEditor_EnumTakes(HWND midieditor, integer takeindex, boolean editable_only)

Python: MediaItem_Take RPR_MIDIEditor_EnumTakes(HWND midieditor, Int takeindex, Boolean editable_only)

list the takes that are currently being edited in this MIDI editor, starting with the active take. See MIDIEditor_GetTake



C: HWND MIDIEditor_GetActive()

EEL2: HWND MIDIEditor_GetActive()

Lua: HWND reaper.MIDIEditor_GetActive()

Python: HWND RPR_MIDIEditor_GetActive()

get a pointer to the focused MIDI editor window
see MIDIEditor_GetMode, MIDIEditor_OnCommand



C: int MIDIEditor_GetMode(HWND midieditor)

EEL2: int MIDIEditor_GetMode(HWND midieditor)

Lua: integer reaper.MIDIEditor_GetMode(HWND midieditor)

Python: Int RPR_MIDIEditor_GetMode(HWND midieditor)

get the mode of a MIDI editor (0=piano roll, 1=event list, -1=invalid editor)
see MIDIEditor_GetActive, MIDIEditor_OnCommand



C: int MIDIEditor_GetSetting_int(HWND midieditor, const char* setting_desc)

EEL2: int MIDIEditor_GetSetting_int(HWND midieditor, "setting_desc")

Lua: integer reaper.MIDIEditor_GetSetting_int(HWND midieditor, string setting_desc)

Python: Int RPR_MIDIEditor_GetSetting_int(HWND midieditor, String setting_desc)

Get settings from a MIDI editor. setting_desc can be:
snap_enabled: returns 0 or 1
active_note_row: returns 0-127
last_clicked_cc_lane: returns 0-127=CC, 0x100|(0-31)=14-bit CC, 0x200=velocity, 0x201=pitch, 0x202=program, 0x203=channel pressure, 0x204=bank/program select, 0x205=text, 0x206=sysex, 0x207=off velocity, 0x208=notation events, 0x210=media item lane
default_note_vel: returns 0-127
default_note_chan: returns 0-15
default_note_len: returns default length in MIDI ticks
scale_enabled: returns 0-1
scale_root: returns 0-12 (0=C)
list_cnt: if viewing list view, returns event count
if setting_desc is unsupported, the function returns -1.
See MIDIEditor_SetSetting_int, MIDIEditor_GetActive, MIDIEditor_GetSetting_str




C: bool MIDIEditor_GetSetting_str(HWND midieditor, const char* setting_desc, char* bufOut, int bufOut_sz)

EEL2: bool MIDIEditor_GetSetting_str(HWND midieditor, "setting_desc", #buf)

Lua: boolean retval, string buf = reaper.MIDIEditor_GetSetting_str(HWND midieditor, string setting_desc)

Python: (Boolean retval, HWND midieditor, String setting_desc, String bufOut, Int bufOut_sz) = RPR_MIDIEditor_GetSetting_str(midieditor, setting_desc, bufOut, bufOut_sz)

Get settings from a MIDI editor. setting_desc can be:
last_clicked_cc_lane: returns text description ("velocity", "pitch", etc)
scale: returns the scale record, for example "102034050607" for a major scale
list_X: if viewing list view, returns string describing event at row X (0-based). String will have a list of key=value pairs, e.g. 'pos=4.0 len=4.0 offvel=127 msg=90317F'. pos/len times are in QN, len/offvel may not be present if event is not a note. other keys which may be present include pos_pq/len_pq, sel, mute, ccval14, ccshape, ccbeztension.
if setting_desc is unsupported, the function returns false.
See MIDIEditor_GetActive, MIDIEditor_GetSetting_int




C: MediaItem_Take* MIDIEditor_GetTake(HWND midieditor)

EEL2: MediaItem_Take MIDIEditor_GetTake(HWND midieditor)

Lua: MediaItem_Take reaper.MIDIEditor_GetTake(HWND midieditor)

Python: MediaItem_Take RPR_MIDIEditor_GetTake(HWND midieditor)

get the take that is currently being edited in this MIDI editor. see MIDIEditor_EnumTakes



C: bool MIDIEditor_LastFocused_OnCommand(int command_id, bool islistviewcommand)

EEL2: bool MIDIEditor_LastFocused_OnCommand(int command_id, bool islistviewcommand)

Lua: boolean reaper.MIDIEditor_LastFocused_OnCommand(integer command_id, boolean islistviewcommand)

Python: Boolean RPR_MIDIEditor_LastFocused_OnCommand(Int command_id, Boolean islistviewcommand)

Send an action command to the last focused MIDI editor. Returns false if there is no MIDI editor open, or if the view mode (piano roll or event list) does not match the input.
see MIDIEditor_OnCommand



C: bool MIDIEditor_OnCommand(HWND midieditor, int command_id)

EEL2: bool MIDIEditor_OnCommand(HWND midieditor, int command_id)

Lua: boolean reaper.MIDIEditor_OnCommand(HWND midieditor, integer command_id)

Python: Boolean RPR_MIDIEditor_OnCommand(HWND midieditor, Int command_id)

Send an action command to a MIDI editor. Returns false if the supplied MIDI editor pointer is not valid (not an open MIDI editor).
see MIDIEditor_GetActive, MIDIEditor_LastFocused_OnCommand



C: bool MIDIEditor_SetSetting_int(HWND midieditor, const char* setting_desc, int setting)

EEL2: bool MIDIEditor_SetSetting_int(HWND midieditor, "setting_desc", int setting)

Lua: boolean reaper.MIDIEditor_SetSetting_int(HWND midieditor, string setting_desc, integer setting)

Python: Boolean RPR_MIDIEditor_SetSetting_int(HWND midieditor, String setting_desc, Int setting)

Set settings for a MIDI editor. setting_desc can be:
active_note_row: 0-127
See MIDIEditor_GetSetting_int




C: void MIDIEditorFlagsForTrack(MediaTrack* track, int* pitchwheelrangeInOut, int* flagsInOut, bool is_set)

EEL2: MIDIEditorFlagsForTrack(MediaTrack track, int &pitchwheelrange, int &flags, bool is_set)

Lua: integer pitchwheelrange, integer flags = reaper.MIDIEditorFlagsForTrack(MediaTrack track, integer pitchwheelrange, integer flags, boolean is_set)

Python: (MediaTrack track, Int pitchwheelrangeInOut, Int flagsInOut, Boolean is_set) = RPR_MIDIEditorFlagsForTrack(track, pitchwheelrangeInOut, flagsInOut, is_set)

Get or set MIDI editor settings for this track. pitchwheelrange: semitones up or down. flags &1: snap pitch lane edits to semitones if pitchwheel range is defined.



C: void mkpanstr(char* strNeed64, double pan)

EEL2: mkpanstr(#strNeed64, pan)

Lua: string strNeed64 = reaper.mkpanstr(string strNeed64, number pan)

Python: (String strNeed64, Float pan) = RPR_mkpanstr(strNeed64, pan)



C: void mkvolpanstr(char* strNeed64, double vol, double pan)

EEL2: mkvolpanstr(#strNeed64, vol, pan)

Lua: string strNeed64 = reaper.mkvolpanstr(string strNeed64, number vol, number pan)

Python: (String strNeed64, Float vol, Float pan) = RPR_mkvolpanstr(strNeed64, vol, pan)



C: void mkvolstr(char* strNeed64, double vol)

EEL2: mkvolstr(#strNeed64, vol)

Lua: string strNeed64 = reaper.mkvolstr(string strNeed64, number vol)

Python: (String strNeed64, Float vol) = RPR_mkvolstr(strNeed64, vol)



C: void MoveEditCursor(double adjamt, bool dosel)

EEL2: MoveEditCursor(adjamt, bool dosel)

Lua: reaper.MoveEditCursor(number adjamt, boolean dosel)

Python: RPR_MoveEditCursor(Float adjamt, Boolean dosel)



C: bool MoveMediaItemToTrack(MediaItem* item, MediaTrack* desttr)

EEL2: bool MoveMediaItemToTrack(MediaItem item, MediaTrack desttr)

Lua: boolean reaper.MoveMediaItemToTrack(MediaItem item, MediaTrack desttr)

Python: Boolean RPR_MoveMediaItemToTrack(MediaItem item, MediaTrack desttr)

returns TRUE if move succeeded



C: void MuteAllTracks(bool mute)

EEL2: MuteAllTracks(bool mute)

Lua: reaper.MuteAllTracks(boolean mute)

Python: RPR_MuteAllTracks(Boolean mute)



C: void my_getViewport(RECT* r, const RECT* sr, bool wantWorkArea)

EEL2: my_getViewport(int &r.left, int &r.top, int &r.right, int &r.bot, int sr.left, int sr.top, int sr.right, int sr.bot, bool wantWorkArea)

Lua: reaper.my_getViewport(integerr.left, integerr.top, integerr.right, integerr.bot, integer sr.left, integer sr.top, integer sr.right, integer sr.bot, boolean wantWorkArea)

Python: RPR_my_getViewport(RECT r, const RECT sr, Boolean wantWorkArea)



C: int NamedCommandLookup(const char* command_name)

EEL2: int NamedCommandLookup("command_name")

Lua: integer reaper.NamedCommandLookup(string command_name)

Python: Int RPR_NamedCommandLookup(String command_name)

Get the command ID number for named command that was registered by an extension such as "_SWS_ABOUT" or "_113088d11ae641c193a2b7ede3041ad5" for a ReaScript or a custom action.



C: void OnPauseButton()

EEL2: OnPauseButton()

Lua: reaper.OnPauseButton()

Python: RPR_OnPauseButton()

direct way to simulate pause button hit



C: void OnPauseButtonEx(ReaProject* proj)

EEL2: OnPauseButtonEx(ReaProject proj)

Lua: reaper.OnPauseButtonEx(ReaProject proj)

Python: RPR_OnPauseButtonEx(ReaProject proj)

direct way to simulate pause button hit



C: void OnPlayButton()

EEL2: OnPlayButton()

Lua: reaper.OnPlayButton()

Python: RPR_OnPlayButton()

direct way to simulate play button hit



C: void OnPlayButtonEx(ReaProject* proj)

EEL2: OnPlayButtonEx(ReaProject proj)

Lua: reaper.OnPlayButtonEx(ReaProject proj)

Python: RPR_OnPlayButtonEx(ReaProject proj)

direct way to simulate play button hit



C: void OnStopButton()

EEL2: OnStopButton()

Lua: reaper.OnStopButton()

Python: RPR_OnStopButton()

direct way to simulate stop button hit



C: void OnStopButtonEx(ReaProject* proj)

EEL2: OnStopButtonEx(ReaProject proj)

Lua: reaper.OnStopButtonEx(ReaProject proj)

Python: RPR_OnStopButtonEx(ReaProject proj)

direct way to simulate stop button hit



C: bool OpenColorThemeFile(const char* fn)

EEL2: bool OpenColorThemeFile("fn")

Lua: boolean reaper.OpenColorThemeFile(string fn)

Python: Boolean RPR_OpenColorThemeFile(String fn)



C: HWND OpenMediaExplorer(const char* mediafn, bool play)

EEL2: HWND OpenMediaExplorer("mediafn", bool play)

Lua: HWND reaper.OpenMediaExplorer(string mediafn, boolean play)

Python: HWND RPR_OpenMediaExplorer(String mediafn, Boolean play)

Opens mediafn in the Media Explorer, play=true will play the file immediately (or toggle playback if mediafn was already open), =false will just select it.



C: void OscLocalMessageToHost(const char* message, const double* valueInOptional)

EEL2: OscLocalMessageToHost("message", optional valueIn)

Lua: reaper.OscLocalMessageToHost(string message, optional number valueIn)

Python: RPR_OscLocalMessageToHost(String message, const double valueInOptional)

Send an OSC message directly to REAPER. The value argument may be NULL. The message will be matched against the default OSC patterns.



C: double parse_timestr(const char* buf)

EEL2: double parse_timestr("buf")

Lua: number reaper.parse_timestr(string buf)

Python: Float RPR_parse_timestr(String buf)

Parse hh:mm:ss.sss time string, return time in seconds (or 0.0 on error). See parse_timestr_pos, parse_timestr_len.



C: double parse_timestr_len(const char* buf, double offset, int modeoverride)

EEL2: double parse_timestr_len("buf", offset, int modeoverride)

Lua: number reaper.parse_timestr_len(string buf, number offset, integer modeoverride)

Python: Float RPR_parse_timestr_len(String buf, Float offset, Int modeoverride)

time formatting mode overrides: -1=proj default.
0=time
1=measures.beats + time
2=measures.beats
3=seconds
4=samples
5=h:m:s:f




C: double parse_timestr_pos(const char* buf, int modeoverride)

EEL2: double parse_timestr_pos("buf", int modeoverride)

Lua: number reaper.parse_timestr_pos(string buf, integer modeoverride)

Python: Float RPR_parse_timestr_pos(String buf, Int modeoverride)

Parse time string, time formatting mode overrides: -1=proj default.
0=time
1=measures.beats + time
2=measures.beats
3=seconds
4=samples
5=h:m:s:f




C: double parsepanstr(const char* str)

EEL2: double parsepanstr("str")

Lua: number reaper.parsepanstr(string str)

Python: Float RPR_parsepanstr(String str)



C: unsigned int PCM_Sink_Enum(int idx, const char** descstrOut)

EEL2: uint PCM_Sink_Enum(int idx, #descstr)

Lua: integer retval, string descstr = reaper.PCM_Sink_Enum(integer idx)

Python: Unknown RPR_PCM_Sink_Enum(Int idx, String descstrOut)



C: const char* PCM_Sink_GetExtension(const char* data, int data_sz)

EEL2: bool PCM_Sink_GetExtension(#retval, "data")

Lua: string reaper.PCM_Sink_GetExtension(string data)

Python: String RPR_PCM_Sink_GetExtension(String data, Int data_sz)



C: HWND PCM_Sink_ShowConfig(const char* cfg, int cfg_sz, HWND hwndParent)

EEL2: HWND PCM_Sink_ShowConfig("cfg", HWND hwndParent)

Lua: HWND reaper.PCM_Sink_ShowConfig(string cfg, HWND hwndParent)

Python: HWND RPR_PCM_Sink_ShowConfig(String cfg, Int cfg_sz, HWND hwndParent)



C: int PCM_Source_BuildPeaks(PCM_source* src, int mode)

EEL2: int PCM_Source_BuildPeaks(PCM_source src, int mode)

Lua: integer reaper.PCM_Source_BuildPeaks(PCM_source src, integer mode)

Python: Int RPR_PCM_Source_BuildPeaks(PCM_source src, Int mode)

Calls and returns PCM_source::PeaksBuild_Begin() if mode=0, PeaksBuild_Run() if mode=1, and PeaksBuild_Finish() if mode=2. Normal use is to call PCM_Source_BuildPeaks(src,0), and if that returns nonzero, call PCM_Source_BuildPeaks(src,1) periodically until it returns zero (it returns the percentage of the file remaining), then call PCM_Source_BuildPeaks(src,2) to finalize. If PCM_Source_BuildPeaks(src,0) returns zero, then no further action is necessary.



C: PCM_source* PCM_Source_CreateFromFile(const char* filename)

EEL2: PCM_source PCM_Source_CreateFromFile("filename")

Lua: PCM_source reaper.PCM_Source_CreateFromFile(string filename)

Python: PCM_source RPR_PCM_Source_CreateFromFile(String filename)

See PCM_Source_CreateFromFileEx.



C: PCM_source* PCM_Source_CreateFromFileEx(const char* filename, bool forcenoMidiImp)

EEL2: PCM_source PCM_Source_CreateFromFileEx("filename", bool forcenoMidiImp)

Lua: PCM_source reaper.PCM_Source_CreateFromFileEx(string filename, boolean forcenoMidiImp)

Python: PCM_source RPR_PCM_Source_CreateFromFileEx(String filename, Boolean forcenoMidiImp)

Create a PCM_source from filename, and override pref of MIDI files being imported as in-project MIDI events.



C: PCM_source* PCM_Source_CreateFromType(const char* sourcetype)

EEL2: PCM_source PCM_Source_CreateFromType("sourcetype")

Lua: PCM_source reaper.PCM_Source_CreateFromType(string sourcetype)

Python: PCM_source RPR_PCM_Source_CreateFromType(String sourcetype)

Create a PCM_source from a "type" (use this if you're going to load its state via LoadState/ProjectStateContext).
Valid types include "WAVE", "MIDI", or whatever plug-ins define as well.



C: void PCM_Source_Destroy(PCM_source* src)

EEL2: PCM_Source_Destroy(PCM_source src)

Lua: reaper.PCM_Source_Destroy(PCM_source src)

Python: RPR_PCM_Source_Destroy(PCM_source src)

Deletes a PCM_source -- be sure that you remove any project reference before deleting a source



C: int PCM_Source_GetPeaks(PCM_source* src, double peakrate, double starttime, int numchannels, int numsamplesperchannel, int want_extra_type, double* buf)

EEL2: int PCM_Source_GetPeaks(PCM_source src, peakrate, starttime, int numchannels, int numsamplesperchannel, int want_extra_type, buffer_ptr buf)

Lua: integer reaper.PCM_Source_GetPeaks(PCM_source src, number peakrate, number starttime, integer numchannels, integer numsamplesperchannel, integer want_extra_type, reaper.array buf)

Python: (Int retval, PCM_source src, Float peakrate, Float starttime, Int numchannels, Int numsamplesperchannel, Int want_extra_type, Float buf) = RPR_PCM_Source_GetPeaks(src, peakrate, starttime, numchannels, numsamplesperchannel, want_extra_type, buf)

Gets block of peak samples to buf. Note that the peak samples are interleaved, but in two or three blocks (maximums, then minimums, then extra). Return value has 20 bits of returned sample count, then 4 bits of output_mode (0xf00000), then a bit to signify whether extra_type was available (0x1000000). extra_type can be 115 ('s') for spectral information, which will return peak samples as integers with the low 15 bits frequency, next 14 bits tonality.



C: bool PCM_Source_GetSectionInfo(PCM_source* src, double* offsOut, double* lenOut, bool* revOut)

EEL2: bool PCM_Source_GetSectionInfo(PCM_source src, &offs, &len, bool &rev)

Lua: boolean retval, number offs, number len, boolean rev = reaper.PCM_Source_GetSectionInfo(PCM_source src)

Python: (Boolean retval, PCM_source src, Float offsOut, Float lenOut, Boolean revOut) = RPR_PCM_Source_GetSectionInfo(src, offsOut, lenOut, revOut)

If a section/reverse block, retrieves offset/len/reverse. return true if success



C: void PluginWantsAlwaysRunFx(int amt)

EEL2: PluginWantsAlwaysRunFx(int amt)

Lua: reaper.PluginWantsAlwaysRunFx(integer amt)

Python: RPR_PluginWantsAlwaysRunFx(Int amt)



C: void PreventUIRefresh(int prevent_count)

EEL2: PreventUIRefresh(int prevent_count)

Lua: reaper.PreventUIRefresh(integer prevent_count)

Python: RPR_PreventUIRefresh(Int prevent_count)

adds prevent_count to the UI refresh prevention state; always add then remove the same amount, or major disfunction will occur



C: int PromptForAction(int session_mode, int init_id, int section_id)

EEL2: int PromptForAction(int session_mode, int init_id, int section_id)

Lua: integer reaper.PromptForAction(integer session_mode, integer init_id, integer section_id)

Python: Int RPR_PromptForAction(Int session_mode, Int init_id, Int section_id)

Uses the action list to choose an action. Call with session_mode=1 to create a session (init_id will be the initial action to select, or 0), then poll with session_mode=0, checking return value for user-selected action (will return 0 if no action selected yet, or -1 if the action window is no longer available). When finished, call with session_mode=-1.



C: void ReaScriptError(const char* errmsg)

EEL2: ReaScriptError("errmsg")

Lua: reaper.ReaScriptError(string errmsg)

Python: RPR_ReaScriptError(String errmsg)

Causes REAPER to display the error message after the current ReaScript finishes. If called within a Lua context and errmsg has a ! prefix, script execution will be terminated.



C: int RecursiveCreateDirectory(const char* path, size_t ignored)

EEL2: int RecursiveCreateDirectory("path", size_t ignored)

Lua: integer reaper.RecursiveCreateDirectory(string path, integer ignored)

Python: Int RPR_RecursiveCreateDirectory(String path, Unknown ignored)

returns positive value on success, 0 on failure.



C: int reduce_open_files(int flags)

EEL2: int reduce_open_files(int flags)

Lua: integer reaper.reduce_open_files(integer flags)

Python: Int RPR_reduce_open_files(Int flags)

garbage-collects extra open files and closes them. if flags has 1 set, this is done incrementally (call this from a regular timer, if desired). if flags has 2 set, files are aggressively closed (they may need to be re-opened very soon). returns number of files closed by this call.



C: void RefreshToolbar(int command_id)

EEL2: RefreshToolbar(int command_id)

Lua: reaper.RefreshToolbar(integer command_id)

Python: RPR_RefreshToolbar(Int command_id)

See RefreshToolbar2.



C: void RefreshToolbar2(int section_id, int command_id)

EEL2: RefreshToolbar2(int section_id, int command_id)

Lua: reaper.RefreshToolbar2(integer section_id, integer command_id)

Python: RPR_RefreshToolbar2(Int section_id, Int command_id)

Refresh the toolbar button states of a toggle action.



C: void relative_fn(const char* in, char* out, int out_sz)

EEL2: relative_fn("in", #out)

Lua: string out = reaper.relative_fn(string in, string out)

Python: (String in, String out, Int out_sz) = RPR_relative_fn(in, out, out_sz)

Makes a filename "in" relative to the current project, if any.



C: bool RemoveTrackSend(MediaTrack* tr, int category, int sendidx)

EEL2: bool RemoveTrackSend(MediaTrack tr, int category, int sendidx)

Lua: boolean reaper.RemoveTrackSend(MediaTrack tr, integer category, integer sendidx)

Python: Boolean RPR_RemoveTrackSend(MediaTrack tr, Int category, Int sendidx)

Remove a send/receive/hardware output, return true on success. category is <0 for receives, 0=sends, >0 for hardware outputs. See CreateTrackSend, GetSetTrackSendInfo, GetTrackSendInfo_Value, SetTrackSendInfo_Value, GetTrackNumSends.



C: bool RenderFileSection(const char* source_filename, const char* target_filename, double start_percent, double end_percent, double playrate)

EEL2: bool RenderFileSection("source_filename", "target_filename", start_percent, end_percent, playrate)

Lua: boolean reaper.RenderFileSection(string source_filename, string target_filename, number start_percent, number end_percent, number playrate)

Python: Boolean RPR_RenderFileSection(String source_filename, String target_filename, Float start_percent, Float end_percent, Float playrate)

Not available while playing back.



C: bool ReorderSelectedTracks(int beforeTrackIdx, int makePrevFolder)

EEL2: bool ReorderSelectedTracks(int beforeTrackIdx, int makePrevFolder)

Lua: boolean reaper.ReorderSelectedTracks(integer beforeTrackIdx, integer makePrevFolder)

Python: Boolean RPR_ReorderSelectedTracks(Int beforeTrackIdx, Int makePrevFolder)

Moves all selected tracks to immediately above track specified by index beforeTrackIdx, returns false if no tracks were selected. makePrevFolder=0 for normal, 1 = as child of track preceding track specified by beforeTrackIdx, 2 = if track preceding track specified by beforeTrackIdx is last track in folder, extend folder



C: const char* Resample_EnumModes(int mode)

EEL2: bool Resample_EnumModes(#retval, int mode)

Lua: string reaper.Resample_EnumModes(integer mode)

Python: String RPR_Resample_EnumModes(Int mode)



C: void resolve_fn(const char* in, char* out, int out_sz)

EEL2: resolve_fn("in", #out)

Lua: string out = reaper.resolve_fn(string in, string out)

Python: (String in, String out, Int out_sz) = RPR_resolve_fn(in, out, out_sz)

See resolve_fn2.



C: void resolve_fn2(const char* in, char* out, int out_sz, const char* checkSubDirOptional)

EEL2: resolve_fn2("in", #out, optional "checkSubDir")

Lua: string out = reaper.resolve_fn2(string in, string out, optional string checkSubDir)

Python: (String in, String out, Int out_sz, String checkSubDirOptional) = RPR_resolve_fn2(in, out, out_sz, checkSubDirOptional)

Resolves a filename "in" by using project settings etc. If no file found, out will be a copy of in.



C: const char* ReverseNamedCommandLookup(int command_id)

EEL2: bool ReverseNamedCommandLookup(#retval, int command_id)

Lua: string reaper.ReverseNamedCommandLookup(integer command_id)

Python: String RPR_ReverseNamedCommandLookup(Int command_id)

Get the named command for the given command ID. The returned string will not start with '_' (e.g. it will return "SWS_ABOUT"), it will be NULL if command_id is a native action.



C: double ScaleFromEnvelopeMode(int scaling_mode, double val)

EEL2: double ScaleFromEnvelopeMode(int scaling_mode, val)

Lua: number reaper.ScaleFromEnvelopeMode(integer scaling_mode, number val)

Python: Float RPR_ScaleFromEnvelopeMode(Int scaling_mode, Float val)

See GetEnvelopeScalingMode.



C: double ScaleToEnvelopeMode(int scaling_mode, double val)

EEL2: double ScaleToEnvelopeMode(int scaling_mode, val)

Lua: number reaper.ScaleToEnvelopeMode(integer scaling_mode, number val)

Python: Float RPR_ScaleToEnvelopeMode(Int scaling_mode, Float val)

See GetEnvelopeScalingMode.



C: KbdSectionInfo* SectionFromUniqueID(int uniqueID)

EEL2: KbdSectionInfo SectionFromUniqueID(int uniqueID)

Lua: KbdSectionInfo reaper.SectionFromUniqueID(integer uniqueID)

Python: KbdSectionInfo RPR_SectionFromUniqueID(Int uniqueID)



C: void SelectAllMediaItems(ReaProject* proj, bool selected)

EEL2: SelectAllMediaItems(ReaProject proj, bool selected)

Lua: reaper.SelectAllMediaItems(ReaProject proj, boolean selected)

Python: RPR_SelectAllMediaItems(ReaProject proj, Boolean selected)



C: void SelectProjectInstance(ReaProject* proj)

EEL2: SelectProjectInstance(ReaProject proj)

Lua: reaper.SelectProjectInstance(ReaProject proj)

Python: RPR_SelectProjectInstance(ReaProject proj)



C: void SendMIDIMessageToHardware(int output, const char* msg, int msg_sz)

EEL2: SendMIDIMessageToHardware(int output, "msg")

Lua: reaper.SendMIDIMessageToHardware(integer output, string msg)

Python: RPR_SendMIDIMessageToHardware(Int output, String msg, Int msg_sz)

Sends a MIDI message to output device specified by output. Message is sent in immediate mode.



C: void SetActiveTake(MediaItem_Take* take)

EEL2: SetActiveTake(MediaItem_Take take)

Lua: reaper.SetActiveTake(MediaItem_Take take)

Python: RPR_SetActiveTake(MediaItem_Take take)

set this take active in this media item



C: void SetAutomationMode(int mode, bool onlySel)

EEL2: SetAutomationMode(int mode, bool onlySel)

Lua: reaper.SetAutomationMode(integer mode, boolean onlySel)

Python: RPR_SetAutomationMode(Int mode, Boolean onlySel)

sets all or selected tracks to mode.



C: void SetCurrentBPM(ReaProject* __proj, double bpm, bool wantUndo)

EEL2: SetCurrentBPM(ReaProject __proj, bpm, bool wantUndo)

Lua: reaper.SetCurrentBPM(ReaProject __proj, number bpm, boolean wantUndo)

Python: RPR_SetCurrentBPM(ReaProject __proj, Float bpm, Boolean wantUndo)

set current BPM in project, set wantUndo=true to add undo point



C: void SetCursorContext(int mode, TrackEnvelope* envInOptional)

EEL2: SetCursorContext(int mode, TrackEnvelope envIn)

Lua: reaper.SetCursorContext(integer mode, TrackEnvelope envIn)

Python: RPR_SetCursorContext(Int mode, TrackEnvelope envInOptional)

You must use this to change the focus programmatically. mode=0 to focus track panels, 1 to focus the arrange window, 2 to focus the arrange window and select env (or env==NULL to clear the current track/take envelope selection)



C: void SetEditCurPos(double time, bool moveview, bool seekplay)

EEL2: SetEditCurPos(time, bool moveview, bool seekplay)

Lua: reaper.SetEditCurPos(number time, boolean moveview, boolean seekplay)

Python: RPR_SetEditCurPos(Float time, Boolean moveview, Boolean seekplay)



C: void SetEditCurPos2(ReaProject* proj, double time, bool moveview, bool seekplay)

EEL2: SetEditCurPos2(ReaProject proj, time, bool moveview, bool seekplay)

Lua: reaper.SetEditCurPos2(ReaProject proj, number time, boolean moveview, boolean seekplay)

Python: RPR_SetEditCurPos2(ReaProject proj, Float time, Boolean moveview, Boolean seekplay)



C: bool SetEnvelopePoint(TrackEnvelope* envelope, int ptidx, double* timeInOptional, double* valueInOptional, int* shapeInOptional, double* tensionInOptional, bool* selectedInOptional, bool* noSortInOptional)

EEL2: bool SetEnvelopePoint(TrackEnvelope envelope, int ptidx, optional timeIn, optional valueIn, optional int shapeIn, optional tensionIn, optional bool selectedIn, optional bool noSortIn)

Lua: boolean reaper.SetEnvelopePoint(TrackEnvelope envelope, integer ptidx, optional number timeIn, optional number valueIn, optional integer shapeIn, optional number tensionIn, optional boolean selectedIn, optional boolean noSortIn)

Python: (Boolean retval, TrackEnvelope envelope, Int ptidx, Float timeInOptional, Float valueInOptional, Int shapeInOptional, Float tensionInOptional, Boolean selectedInOptional, Boolean noSortInOptional) = RPR_SetEnvelopePoint(envelope, ptidx, timeInOptional, valueInOptional, shapeInOptional, tensionInOptional, selectedInOptional, noSortInOptional)

Set attributes of an envelope point. Values that are not supplied will be ignored. If setting multiple points at once, set noSort=true, and call Envelope_SortPoints when done. See SetEnvelopePointEx.



C: bool SetEnvelopePointEx(TrackEnvelope* envelope, int autoitem_idx, int ptidx, double* timeInOptional, double* valueInOptional, int* shapeInOptional, double* tensionInOptional, bool* selectedInOptional, bool* noSortInOptional)

EEL2: bool SetEnvelopePointEx(TrackEnvelope envelope, int autoitem_idx, int ptidx, optional timeIn, optional valueIn, optional int shapeIn, optional tensionIn, optional bool selectedIn, optional bool noSortIn)

Lua: boolean reaper.SetEnvelopePointEx(TrackEnvelope envelope, integer autoitem_idx, integer ptidx, optional number timeIn, optional number valueIn, optional integer shapeIn, optional number tensionIn, optional boolean selectedIn, optional boolean noSortIn)

Python: (Boolean retval, TrackEnvelope envelope, Int autoitem_idx, Int ptidx, Float timeInOptional, Float valueInOptional, Int shapeInOptional, Float tensionInOptional, Boolean selectedInOptional, Boolean noSortInOptional) = RPR_SetEnvelopePointEx(envelope, autoitem_idx, ptidx, timeInOptional, valueInOptional, shapeInOptional, tensionInOptional, selectedInOptional, noSortInOptional)

Set attributes of an envelope point. Values that are not supplied will be ignored. If setting multiple points at once, set noSort=true, and call Envelope_SortPoints when done.
autoitem_idx=-1 for the underlying envelope, 0 for the first automation item on the envelope, etc.
For automation items, pass autoitem_idx|0x10000000 to base ptidx on the number of points in one full loop iteration,
even if the automation item is trimmed so that not all points are visible.
Otherwise, ptidx will be based on the number of visible points in the automation item, including all loop iterations.
See CountEnvelopePointsEx, GetEnvelopePointEx, InsertEnvelopePointEx, DeleteEnvelopePointEx.



C: bool SetEnvelopeStateChunk(TrackEnvelope* env, const char* str, bool isundoOptional)

EEL2: bool SetEnvelopeStateChunk(TrackEnvelope env, "str", bool isundo)

Lua: boolean reaper.SetEnvelopeStateChunk(TrackEnvelope env, string str, boolean isundo)

Python: Boolean RPR_SetEnvelopeStateChunk(TrackEnvelope env, String str, Boolean isundoOptional)

Sets the RPPXML state of an envelope, returns true if successful. Undo flag is a performance/caching hint.



C: void SetExtState(const char* section, const char* key, const char* value, bool persist)

EEL2: SetExtState("section", "key", "value", bool persist)

Lua: reaper.SetExtState(string section, string key, string value, boolean persist)

Python: RPR_SetExtState(String section, String key, String value, Boolean persist)

Set the extended state value for a specific section and key. persist=true means the value should be stored and reloaded the next time REAPER is opened. See GetExtState, DeleteExtState, HasExtState.



C: void SetGlobalAutomationOverride(int mode)

EEL2: SetGlobalAutomationOverride(int mode)

Lua: reaper.SetGlobalAutomationOverride(integer mode)

Python: RPR_SetGlobalAutomationOverride(Int mode)

mode: see GetGlobalAutomationOverride



C: bool SetItemStateChunk(MediaItem* item, const char* str, bool isundoOptional)

EEL2: bool SetItemStateChunk(MediaItem item, "str", bool isundo)

Lua: boolean reaper.SetItemStateChunk(MediaItem item, string str, boolean isundo)

Python: Boolean RPR_SetItemStateChunk(MediaItem item, String str, Boolean isundoOptional)

Sets the RPPXML state of an item, returns true if successful. Undo flag is a performance/caching hint.



C: int SetMasterTrackVisibility(int flag)

EEL2: int SetMasterTrackVisibility(int flag)

Lua: integer reaper.SetMasterTrackVisibility(integer flag)

Python: Int RPR_SetMasterTrackVisibility(Int flag)

set &1 to show the master track in the TCP, &2 to HIDE in the mixer. Returns the previous visibility state. See GetMasterTrackVisibility.



C: bool SetMediaItemInfo_Value(MediaItem* item, const char* parmname, double newvalue)

EEL2: bool SetMediaItemInfo_Value(MediaItem item, "parmname", newvalue)

Lua: boolean reaper.SetMediaItemInfo_Value(MediaItem item, string parmname, number newvalue)

Python: Boolean RPR_SetMediaItemInfo_Value(MediaItem item, String parmname, Float newvalue)

Set media item numerical-value attributes.
B_MUTE : bool * : muted (item solo overrides). setting this value will clear C_MUTE_SOLO.
B_MUTE_ACTUAL : bool * : muted (ignores solo). setting this value will not affect C_MUTE_SOLO.
C_LANEPLAYS : char * : in fixed lane tracks, 0=this item lane does not play, 1=this item lane plays exclusively, 2=this item lane plays and other lanes also play, -1=this item is on a non-visible, non-playing lane on a non-fixed-lane track (read-only)
C_MUTE_SOLO : char * : solo override (-1=soloed, 0=no override, 1=unsoloed). note that this API does not automatically unsolo other items when soloing (nor clear the unsolos when clearing the last soloed item), it must be done by the caller via action or via this API.
B_LOOPSRC : bool * : loop source
B_ALLTAKESPLAY : bool * : all takes play
B_UISEL : bool * : selected in arrange view
C_BEATATTACHMODE : char * : item timebase, -1=track or project default, 1=beats (position, length, rate), 2=beats (position only). for auto-stretch timebase: C_BEATATTACHMODE=1, C_AUTOSTRETCH=1
C_AUTOSTRETCH: : char * : auto-stretch at project tempo changes, 1=enabled, requires C_BEATATTACHMODE=1
C_LOCK : char * : locked, &1=locked
D_VOL : double * : item volume, 0=-inf, 0.5=-6dB, 1=+0dB, 2=+6dB, etc
D_POSITION : double * : item position in seconds
D_LENGTH : double * : item length in seconds
D_SNAPOFFSET : double * : item snap offset in seconds
D_FADEINLEN : double * : item manual fadein length in seconds
D_FADEOUTLEN : double * : item manual fadeout length in seconds
D_FADEINDIR : double * : item fadein curvature, -1..1
D_FADEOUTDIR : double * : item fadeout curvature, -1..1
D_FADEINLEN_AUTO : double * : item auto-fadein length in seconds, -1=no auto-fadein
D_FADEOUTLEN_AUTO : double * : item auto-fadeout length in seconds, -1=no auto-fadeout
C_FADEINSHAPE : int * : fadein shape, 0..6, 0=linear
C_FADEOUTSHAPE : int * : fadeout shape, 0..6, 0=linear
I_GROUPID : int * : group ID, 0=no group
I_LASTY : int * : Y-position (relative to top of track) in pixels (read-only)
I_LASTH : int * : height in pixels (read-only)
I_CUSTOMCOLOR : int * : custom color, OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). If you do not |0x1000000, then it will not be used, but will store the color
I_CURTAKE : int * : active take number
IP_ITEMNUMBER : int : item number on this track (read-only, returns the item number directly)
F_FREEMODE_Y : float * : free item positioning or fixed lane Y-position. 0=top of track, 1.0=bottom of track
F_FREEMODE_H : float * : free item positioning or fixed lane height. 0.5=half the track height, 1.0=full track height
I_FIXEDLANE : int * : fixed lane of item (fine to call with setNewValue, but returned value is read-only)
B_FIXEDLANE_HIDDEN : bool * : true if displaying only one fixed lane and this item is in a different lane (read-only)




C: bool SetMediaItemLength(MediaItem* item, double length, bool refreshUI)

EEL2: bool SetMediaItemLength(MediaItem item, length, bool refreshUI)

Lua: boolean reaper.SetMediaItemLength(MediaItem item, number length, boolean refreshUI)

Python: Boolean RPR_SetMediaItemLength(MediaItem item, Float length, Boolean refreshUI)

Redraws the screen only if refreshUI == true.
See UpdateArrange().



C: bool SetMediaItemPosition(MediaItem* item, double position, bool refreshUI)

EEL2: bool SetMediaItemPosition(MediaItem item, position, bool refreshUI)

Lua: boolean reaper.SetMediaItemPosition(MediaItem item, number position, boolean refreshUI)

Python: Boolean RPR_SetMediaItemPosition(MediaItem item, Float position, Boolean refreshUI)

Redraws the screen only if refreshUI == true.
See UpdateArrange().



C: void SetMediaItemSelected(MediaItem* item, bool selected)

EEL2: SetMediaItemSelected(MediaItem item, bool selected)

Lua: reaper.SetMediaItemSelected(MediaItem item, boolean selected)

Python: RPR_SetMediaItemSelected(MediaItem item, Boolean selected)



C: bool SetMediaItemTake_Source(MediaItem_Take* take, PCM_source* source)

EEL2: bool SetMediaItemTake_Source(MediaItem_Take take, PCM_source source)

Lua: boolean reaper.SetMediaItemTake_Source(MediaItem_Take take, PCM_source source)

Python: Boolean RPR_SetMediaItemTake_Source(MediaItem_Take take, PCM_source source)

Set media source of media item take. The old source will not be destroyed, it is the caller's responsibility to retrieve it and destroy it after. If source already exists in any project, it will be duplicated before being set. C/C++ code should not use this and instead use GetSetMediaItemTakeInfo() with P_SOURCE to manage ownership directly.



C: bool SetMediaItemTakeInfo_Value(MediaItem_Take* take, const char* parmname, double newvalue)

EEL2: bool SetMediaItemTakeInfo_Value(MediaItem_Take take, "parmname", newvalue)

Lua: boolean reaper.SetMediaItemTakeInfo_Value(MediaItem_Take take, string parmname, number newvalue)

Python: Boolean RPR_SetMediaItemTakeInfo_Value(MediaItem_Take take, String parmname, Float newvalue)

Set media item take numerical-value attributes.
D_STARTOFFS : double * : start offset in source media, in seconds
D_VOL : double * : take volume, 0=-inf, 0.5=-6dB, 1=+0dB, 2=+6dB, etc, negative if take polarity is flipped
D_PAN : double * : take pan, -1..1
D_PANLAW : double * : take pan law, -1=default, 0.5=-6dB, 1.0=+0dB, etc
D_PLAYRATE : double * : take playback rate, 0.5=half speed, 1=normal, 2=double speed, etc
D_PITCH : double * : take pitch adjustment in semitones, -12=one octave down, 0=normal, +12=one octave up, etc
B_PPITCH : bool * : preserve pitch when changing playback rate
I_LASTY : int * : Y-position (relative to top of track) in pixels (read-only)
I_LASTH : int * : height in pixels (read-only)
I_CHANMODE : int * : channel mode, 0=normal, 1=reverse stereo, 2=downmix, 3=left, 4=right
I_PITCHMODE : int * : pitch shifter mode, -1=project default, otherwise high 2 bytes=shifter, low 2 bytes=parameter
I_STRETCHFLAGS : int * : stretch marker flags (&7 mask for mode override: 0=default, 1=balanced, 2/3/6=tonal, 4=transient, 5=no pre-echo)
F_STRETCHFADESIZE : float * : stretch marker fade size in seconds (0.0025 default)
I_RECPASSID : int * : record pass ID
I_TAKEFX_NCH : int * : number of internal audio channels for per-take FX to use (OK to call with setNewValue, but the returned value is read-only)
I_CUSTOMCOLOR : int * : custom color, OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). If you do not |0x1000000, then it will not be used, but will store the color
IP_TAKENUMBER : int : take number (read-only, returns the take number directly)




C: bool SetMediaTrackInfo_Value(MediaTrack* tr, const char* parmname, double newvalue)

EEL2: bool SetMediaTrackInfo_Value(MediaTrack tr, "parmname", newvalue)

Lua: boolean reaper.SetMediaTrackInfo_Value(MediaTrack tr, string parmname, number newvalue)

Python: Boolean RPR_SetMediaTrackInfo_Value(MediaTrack tr, String parmname, Float newvalue)

Set track numerical-value attributes.
B_MUTE : bool * : muted
B_PHASE : bool * : track phase inverted
B_RECMON_IN_EFFECT : bool * : record monitoring in effect (current audio-thread playback state, read-only)
IP_TRACKNUMBER : int : track number 1-based, 0=not found, -1=master track (read-only, returns the int directly)
I_SOLO : int * : soloed, 0=not soloed, 1=soloed, 2=soloed in place, 5=safe soloed, 6=safe soloed in place
B_SOLO_DEFEAT : bool * : when set, if anything else is soloed and this track is not muted, this track acts soloed
I_FXEN : int * : fx enabled, 0=bypassed, !0=fx active
I_RECARM : int * : record armed, 0=not record armed, 1=record armed
I_RECINPUT : int * : record input, <0=no input. if 4096 set, input is MIDI and low 5 bits represent channel (0=all, 1-16=only chan), next 6 bits represent physical input (63=all, 62=VKB). If 4096 is not set, low 10 bits (0..1023) are input start channel (ReaRoute/Loopback start at 512). If 2048 is set, input is multichannel input (using track channel count), or if 1024 is set, input is stereo input, otherwise input is mono.
I_RECMODE : int * : record mode, 0=input, 1=stereo out, 2=none, 3=stereo out w/latency compensation, 4=midi output, 5=mono out, 6=mono out w/ latency compensation, 7=midi overdub, 8=midi replace
I_RECMODE_FLAGS : int * : record mode flags, &3=output recording mode (0=post fader, 1=pre-fx, 2=post-fx/pre-fader)
I_RECMON : int * : record monitoring, 0=off, 1=normal, 2=not when playing (tape style)
I_RECMONITEMS : int * : monitor items while recording, 0=off, 1=on
B_AUTO_RECARM : bool * : automatically set record arm when selected (does not immediately affect recarm state, script should set directly if desired)
I_VUMODE : int * : track vu mode, &1:disabled, &30==0:stereo peaks, &30==2:multichannel peaks, &30==4:stereo RMS, &30==8:combined RMS, &30==12:LUFS-M, &30==16:LUFS-S (readout=max), &30==20:LUFS-S (readout=current), &32:LUFS calculation on channels 1+2 only
I_AUTOMODE : int * : track automation mode, 0=trim/off, 1=read, 2=touch, 3=write, 4=latch
I_NCHAN : int * : number of track channels, 2-128, even numbers only
I_SELECTED : int * : track selected, 0=unselected, 1=selected
I_WNDH : int * : current TCP window height in pixels including envelopes (read-only)
I_TCPH : int * : current TCP window height in pixels not including envelopes (read-only)
I_TCPY : int * : current TCP window Y-position in pixels relative to top of arrange view (read-only)
I_MCPX : int * : current MCP X-position in pixels relative to mixer container (read-only)
I_MCPY : int * : current MCP Y-position in pixels relative to mixer container (read-only)
I_MCPW : int * : current MCP width in pixels (read-only)
I_MCPH : int * : current MCP height in pixels (read-only)
I_FOLDERDEPTH : int * : folder depth change, 0=normal, 1=track is a folder parent, -1=track is the last in the innermost folder, -2=track is the last in the innermost and next-innermost folders, etc
I_FOLDERCOMPACT : int * : folder collapsed state (only valid on folders), 0=normal, 1=collapsed, 2=fully collapsed
I_MIDIHWOUT : int * : track midi hardware output index, <0=disabled, low 5 bits are which channels (0=all, 1-16), next 5 bits are output device index (0-31)
I_PERFFLAGS : int * : track performance flags, &1=no media buffering, &2=no anticipative FX
I_CUSTOMCOLOR : int * : custom color, OS dependent color|0x1000000 (i.e. ColorToNative(r,g,b)|0x1000000). If you do not |0x1000000, then it will not be used, but will store the color
I_HEIGHTOVERRIDE : int * : custom height override for TCP window, 0 for none, otherwise size in pixels
I_SPACER : int * : 1=TCP track spacer above this trackB_HEIGHTLOCK : bool * : track height lock (must set I_HEIGHTOVERRIDE before locking)
D_VOL : double * : trim volume of track, 0=-inf, 0.5=-6dB, 1=+0dB, 2=+6dB, etc
D_PAN : double * : trim pan of track, -1..1
D_WIDTH : double * : width of track, -1..1
D_DUALPANL : double * : dualpan position 1, -1..1, only if I_PANMODE==6
D_DUALPANR : double * : dualpan position 2, -1..1, only if I_PANMODE==6
I_PANMODE : int * : pan mode, 0=classic 3.x, 3=new balance, 5=stereo pan, 6=dual pan
D_PANLAW : double * : pan law of track, <0=project default, 0.5=-6dB, 0.707..=-3dB, 1=+0dB, 1.414..=-3dB with gain compensation, 2=-6dB with gain compensation, etc
I_PANLAW_FLAGS : int * : pan law flags, 0=sine taper, 1=hybrid taper with deprecated behavior when gain compensation enabled, 2=linear taper, 3=hybrid taper
P_ENV:<envchunkname or P_ENV:{GUID... : TrackEnvelope * : (read-only) chunkname can be <VOLENV, <PANENV, etc; GUID is the stringified envelope GUID.
B_SHOWINMIXER : bool * : track control panel visible in mixer (do not use on master track)
B_SHOWINTCP : bool * : track control panel visible in arrange view (do not use on master track)
B_MAINSEND : bool * : track sends audio to parent
C_MAINSEND_OFFS : char * : channel offset of track send to parent
C_MAINSEND_NCH : char * : channel count of track send to parent (0=use all child track channels, 1=use one channel only)
I_FREEMODE : int * : 1=track free item positioning enabled, 2=track fixed lanes enabled (call UpdateTimeline() after changing)
I_NUMFIXEDLANES : int * : number of track fixed lanes (fine to call with setNewValue, but returned value is read-only)
C_LANESCOLLAPSED : char * : fixed lane collapse state (1=lanes collapsed, 2=track displays as non-fixed-lanes but hidden lanes exist)
C_LANEPLAYS:N : char * : on fixed lane tracks, 0=lane N does not play, 1=lane N plays exclusively, 2=lane N plays and other lanes also play (fine to call with setNewValue, but returned value is read-only)
C_ALLLANESPLAY : char * : on fixed lane tracks, 0=no lanes play, 1=all lanes play, 2=some lanes play (fine to call with setNewValue 0 or 1, but returned value is read-only)
C_BEATATTACHMODE : char * : track timebase, -1=project default, 0=time, 1=beats (position, length, rate), 2=beats (position only)
F_MCP_FXSEND_SCALE : float * : scale of fx+send area in MCP (0=minimum allowed, 1=maximum allowed)
F_MCP_FXPARM_SCALE : float * : scale of fx parameter area in MCP (0=minimum allowed, 1=maximum allowed)
F_MCP_SENDRGN_SCALE : float * : scale of send area as proportion of the fx+send total area (0=minimum allowed, 1=maximum allowed)
F_TCP_FXPARM_SCALE : float * : scale of TCP parameter area when TCP FX are embedded (0=min allowed, default, 1=max allowed)
I_PLAY_OFFSET_FLAG : int * : track media playback offset state, &1=bypassed, &2=offset value is measured in samples (otherwise measured in seconds)
D_PLAY_OFFSET : double * : track media playback offset, units depend on I_PLAY_OFFSET_FLAG




C: void SetMIDIEditorGrid(ReaProject* project, double division)

EEL2: SetMIDIEditorGrid(ReaProject project, division)

Lua: reaper.SetMIDIEditorGrid(ReaProject project, number division)

Python: RPR_SetMIDIEditorGrid(ReaProject project, Float division)

Set the MIDI editor grid division. 0.25=quarter note, 1.0/3.0=half note tripet, etc.



C: MediaTrack* SetMixerScroll(MediaTrack* leftmosttrack)

EEL2: MediaTrack SetMixerScroll(MediaTrack leftmosttrack)

Lua: MediaTrack reaper.SetMixerScroll(MediaTrack leftmosttrack)

Python: MediaTrack RPR_SetMixerScroll(MediaTrack leftmosttrack)

Scroll the mixer so that leftmosttrack is the leftmost visible track. Returns the leftmost track after scrolling, which may be different from the passed-in track if there are not enough tracks to its right.



C: void SetMouseModifier(const char* context, int modifier_flag, const char* action)

EEL2: SetMouseModifier("context", int modifier_flag, "action")

Lua: reaper.SetMouseModifier(string context, integer modifier_flag, string action)

Python: RPR_SetMouseModifier(String context, Int modifier_flag, String action)

Set the mouse modifier assignment for a specific modifier key assignment, in a specific context.
Context is a string like "MM_CTX_ITEM" (see reaper-mouse.ini) or "Media item left drag" (unlocalized).
Modifier flag is a number from 0 to 15: add 1 for shift, 2 for control, 4 for alt, 8 for win.
(macOS: add 1 for shift, 2 for command, 4 for opt, 8 for control.)
For left-click and double-click contexts, the action can be any built-in command ID number
or any custom action ID string. Find built-in command IDs in the REAPER actions window
(enable "show command IDs" in the context menu), and find custom action ID strings in reaper-kb.ini.
The action string may be a mouse modifier ID (see reaper-mouse.ini) with " m" appended to it,
or (for click/double-click contexts) a command ID with " c" appended to it,
or the text that appears in the mouse modifiers preferences dialog, like "Move item" (unlocalized).
For example, SetMouseModifier("MM_CTX_ITEM", 0, "1 m") and SetMouseModifier("Media item left drag", 0, "Move item") are equivalent.
SetMouseModifier(context, modifier_flag, -1) will reset that mouse modifier to default.
SetMouseModifier(context, -1, -1) will reset the entire context to default.
SetMouseModifier(-1, -1, -1) will reset all contexts to default.
See GetMouseModifier.




C: void SetOnlyTrackSelected(MediaTrack* track)

EEL2: SetOnlyTrackSelected(MediaTrack track)

Lua: reaper.SetOnlyTrackSelected(MediaTrack track)

Python: RPR_SetOnlyTrackSelected(MediaTrack track)

Set exactly one track selected, deselect all others



C: void SetProjectGrid(ReaProject* project, double division)

EEL2: SetProjectGrid(ReaProject project, division)

Lua: reaper.SetProjectGrid(ReaProject project, number division)

Python: RPR_SetProjectGrid(ReaProject project, Float division)

Set the arrange view grid division. 0.25=quarter note, 1.0/3.0=half note triplet, etc.



C: bool SetProjectMarker(int markrgnindexnumber, bool isrgn, double pos, double rgnend, const char* name)

EEL2: bool SetProjectMarker(int markrgnindexnumber, bool isrgn, pos, rgnend, "name")

Lua: boolean reaper.SetProjectMarker(integer markrgnindexnumber, boolean isrgn, number pos, number rgnend, string name)

Python: Boolean RPR_SetProjectMarker(Int markrgnindexnumber, Boolean isrgn, Float pos, Float rgnend, String name)

Note: this function can't clear a marker's name (an empty string will leave the name unchanged), see SetProjectMarker4.



C: bool SetProjectMarker2(ReaProject* proj, int markrgnindexnumber, bool isrgn, double pos, double rgnend, const char* name)

EEL2: bool SetProjectMarker2(ReaProject proj, int markrgnindexnumber, bool isrgn, pos, rgnend, "name")

Lua: boolean reaper.SetProjectMarker2(ReaProject proj, integer markrgnindexnumber, boolean isrgn, number pos, number rgnend, string name)

Python: Boolean RPR_SetProjectMarker2(ReaProject proj, Int markrgnindexnumber, Boolean isrgn, Float pos, Float rgnend, String name)

Note: this function can't clear a marker's name (an empty string will leave the name unchanged), see SetProjectMarker4.



C: bool SetProjectMarker3(ReaProject* proj, int markrgnindexnumber, bool isrgn, double pos, double rgnend, const char* name, int color)

EEL2: bool SetProjectMarker3(ReaProject proj, int markrgnindexnumber, bool isrgn, pos, rgnend, "name", int color)

Lua: boolean reaper.SetProjectMarker3(ReaProject proj, integer markrgnindexnumber, boolean isrgn, number pos, number rgnend, string name, integer color)

Python: Boolean RPR_SetProjectMarker3(ReaProject proj, Int markrgnindexnumber, Boolean isrgn, Float pos, Float rgnend, String name, Int color)

Note: this function can't clear a marker's name (an empty string will leave the name unchanged), see SetProjectMarker4.



C: bool SetProjectMarker4(ReaProject* proj, int markrgnindexnumber, bool isrgn, double pos, double rgnend, const char* name, int color, int flags)

EEL2: bool SetProjectMarker4(ReaProject proj, int markrgnindexnumber, bool isrgn, pos, rgnend, "name", int color, int flags)

Lua: boolean reaper.SetProjectMarker4(ReaProject proj, integer markrgnindexnumber, boolean isrgn, number pos, number rgnend, string name, integer color, integer flags)

Python: Boolean RPR_SetProjectMarker4(ReaProject proj, Int markrgnindexnumber, Boolean isrgn, Float pos, Float rgnend, String name, Int color, Int flags)

color should be 0 to not change, or ColorToNative(r,g,b)|0x1000000, flags&1 to clear name



C: bool SetProjectMarkerByIndex(ReaProject* proj, int markrgnidx, bool isrgn, double pos, double rgnend, int IDnumber, const char* name, int color)

EEL2: bool SetProjectMarkerByIndex(ReaProject proj, int markrgnidx, bool isrgn, pos, rgnend, int IDnumber, "name", int color)

Lua: boolean reaper.SetProjectMarkerByIndex(ReaProject proj, integer markrgnidx, boolean isrgn, number pos, number rgnend, integer IDnumber, string name, integer color)

Python: Boolean RPR_SetProjectMarkerByIndex(ReaProject proj, Int markrgnidx, Boolean isrgn, Float pos, Float rgnend, Int IDnumber, String name, Int color)

See SetProjectMarkerByIndex2.



C: bool SetProjectMarkerByIndex2(ReaProject* proj, int markrgnidx, bool isrgn, double pos, double rgnend, int IDnumber, const char* name, int color, int flags)

EEL2: bool SetProjectMarkerByIndex2(ReaProject proj, int markrgnidx, bool isrgn, pos, rgnend, int IDnumber, "name", int color, int flags)

Lua: boolean reaper.SetProjectMarkerByIndex2(ReaProject proj, integer markrgnidx, boolean isrgn, number pos, number rgnend, integer IDnumber, string name, integer color, integer flags)

Python: Boolean RPR_SetProjectMarkerByIndex2(ReaProject proj, Int markrgnidx, Boolean isrgn, Float pos, Float rgnend, Int IDnumber, String name, Int color, Int flags)

Differs from SetProjectMarker4 in that markrgnidx is 0 for the first marker/region, 1 for the next, etc (see EnumProjectMarkers3), rather than representing the displayed marker/region ID number (see SetProjectMarker3). Function will fail if attempting to set a duplicate ID number for a region (duplicate ID numbers for markers are OK). , flags&1 to clear name. If flags&2, markers will not be re-sorted, and after making updates, you MUST call SetProjectMarkerByIndex2 with markrgnidx=-1 and flags&2 to force re-sort/UI updates.



C: int SetProjExtState(ReaProject* proj, const char* extname, const char* key, const char* value)

EEL2: int SetProjExtState(ReaProject proj, "extname", "key", "value")

Lua: integer reaper.SetProjExtState(ReaProject proj, string extname, string key, string value)

Python: Int RPR_SetProjExtState(ReaProject proj, String extname, String key, String value)

Save a key/value pair for a specific extension, to be restored the next time this specific project is loaded. Typically extname will be the name of a reascript or extension section. If key is NULL or "", all extended data for that extname will be deleted. If val is NULL or "", the data previously associated with that key will be deleted. Returns the size of the state for this extname. See GetProjExtState, EnumProjExtState.



C: void SetRegionRenderMatrix(ReaProject* proj, int regionindex, MediaTrack* track, int flag)

EEL2: SetRegionRenderMatrix(ReaProject proj, int regionindex, MediaTrack track, int flag)

Lua: reaper.SetRegionRenderMatrix(ReaProject proj, integer regionindex, MediaTrack track, integer flag)

Python: RPR_SetRegionRenderMatrix(ReaProject proj, Int regionindex, MediaTrack track, Int flag)

Add (flag > 0) or remove (flag < 0) a track from this region when using the region render matrix. If adding, flag==2 means force mono, flag==4 means force stereo, flag==N means force N/2 channels.



C: int SetTakeMarker(MediaItem_Take* take, int idx, const char* nameIn, double* srcposInOptional, int* colorInOptional)

EEL2: int SetTakeMarker(MediaItem_Take take, int idx, "nameIn", optional srcposIn, optional int colorIn)

Lua: integer reaper.SetTakeMarker(MediaItem_Take take, integer idx, string nameIn, optional number srcposIn, optional integer colorIn)

Python: (Int retval, MediaItem_Take take, Int idx, String nameIn, Float srcposInOptional, Int colorInOptional) = RPR_SetTakeMarker(take, idx, nameIn, srcposInOptional, colorInOptional)

Inserts or updates a take marker. If idx<0, a take marker will be added, otherwise an existing take marker will be updated. Returns the index of the new or updated take marker (which may change if srcPos is updated). See GetNumTakeMarkers, GetTakeMarker, DeleteTakeMarker



C: int SetTakeStretchMarker(MediaItem_Take* take, int idx, double pos, const double* srcposInOptional)

EEL2: int SetTakeStretchMarker(MediaItem_Take take, int idx, pos, optional srcposIn)

Lua: integer reaper.SetTakeStretchMarker(MediaItem_Take take, integer idx, number pos, optional number srcposIn)

Python: Int RPR_SetTakeStretchMarker(MediaItem_Take take, Int idx, Float pos, const double srcposInOptional)

Adds or updates a stretch marker. If idx<0, stretch marker will be added. If idx>=0, stretch marker will be updated. When adding, if srcposInOptional is omitted, source position will be auto-calculated. When updating a stretch marker, if srcposInOptional is omitted, srcpos will not be modified. Position/srcposition values will be constrained to nearby stretch markers. Returns index of stretch marker, or -1 if did not insert (or marker already existed at time).



C: bool SetTakeStretchMarkerSlope(MediaItem_Take* take, int idx, double slope)

EEL2: bool SetTakeStretchMarkerSlope(MediaItem_Take take, int idx, slope)

Lua: boolean reaper.SetTakeStretchMarkerSlope(MediaItem_Take take, integer idx, number slope)

Python: Boolean RPR_SetTakeStretchMarkerSlope(MediaItem_Take take, Int idx, Float slope)

See GetTakeStretchMarkerSlope



C: bool SetTempoTimeSigMarker(ReaProject* proj, int ptidx, double timepos, int measurepos, double beatpos, double bpm, int timesig_num, int timesig_denom, bool lineartempo)

EEL2: bool SetTempoTimeSigMarker(ReaProject proj, int ptidx, timepos, int measurepos, beatpos, bpm, int timesig_num, int timesig_denom, bool lineartempo)

Lua: boolean reaper.SetTempoTimeSigMarker(ReaProject proj, integer ptidx, number timepos, integer measurepos, number beatpos, number bpm, integer timesig_num, integer timesig_denom, boolean lineartempo)

Python: Boolean RPR_SetTempoTimeSigMarker(ReaProject proj, Int ptidx, Float timepos, Int measurepos, Float beatpos, Float bpm, Int timesig_num, Int timesig_denom, Boolean lineartempo)

Set parameters of a tempo/time signature marker. Provide either timepos (with measurepos=-1, beatpos=-1), or measurepos and beatpos (with timepos=-1). If timesig_num and timesig_denom are zero, the previous time signature will be used. ptidx=-1 will insert a new tempo/time signature marker. See CountTempoTimeSigMarkers, GetTempoTimeSigMarker, AddTempoTimeSigMarker.



C: int SetThemeColor(const char* ini_key, int color, int flagsOptional)

EEL2: int SetThemeColor("ini_key", int color, int flags)

Lua: integer reaper.SetThemeColor(string ini_key, integer color, integer flags)

Python: Int RPR_SetThemeColor(String ini_key, Int color, Int flagsOptional)

Temporarily updates the theme color to the color specified (or the theme default color if -1 is specified). Returns -1 on failure, otherwise returns the color (or transformed-color). Note that the UI is not updated by this, the caller should call UpdateArrange() etc as necessary. If the low bit of flags is set, any color transformations are bypassed. To read a value see GetThemeColor.
Currently valid ini_keys:



C: bool SetToggleCommandState(int section_id, int command_id, int state)

EEL2: bool SetToggleCommandState(int section_id, int command_id, int state)

Lua: boolean reaper.SetToggleCommandState(integer section_id, integer command_id, integer state)

Python: Boolean RPR_SetToggleCommandState(Int section_id, Int command_id, Int state)

Updates the toggle state of an action, returns true if succeeded. Only ReaScripts can have their toggle states changed programmatically. See RefreshToolbar2.



C: void SetTrackAutomationMode(MediaTrack* tr, int mode)

EEL2: SetTrackAutomationMode(MediaTrack tr, int mode)

Lua: reaper.SetTrackAutomationMode(MediaTrack tr, integer mode)

Python: RPR_SetTrackAutomationMode(MediaTrack tr, Int mode)



C: void SetTrackColor(MediaTrack* track, int color)

EEL2: SetTrackColor(MediaTrack track, int color)

Lua: reaper.SetTrackColor(MediaTrack track, integer color)

Python: RPR_SetTrackColor(MediaTrack track, Int color)

Set the custom track color, color is OS dependent (i.e. ColorToNative(r,g,b). To unset the track color, see SetMediaTrackInfo_Value I_CUSTOMCOLOR



C: bool SetTrackMIDILyrics(MediaTrack* track, int flag, const char* str)

EEL2: bool SetTrackMIDILyrics(MediaTrack track, int flag, "str")

Lua: boolean reaper.SetTrackMIDILyrics(MediaTrack track, integer flag, string str)

Python: Boolean RPR_SetTrackMIDILyrics(MediaTrack track, Int flag, String str)

Set all MIDI lyrics on the track. Lyrics will be stuffed into any MIDI items found in range. Flag is unused at present. str is passed in as beat position, tab, text, tab (example with flag=2: "1.1.2\tLyric for measure 1 beat 2\t2.1.1\tLyric for measure 2 beat 1 "). See GetTrackMIDILyrics



C: bool SetTrackMIDINoteName(int track, int pitch, int chan, const char* name)

EEL2: bool SetTrackMIDINoteName(int track, int pitch, int chan, "name")

Lua: boolean reaper.SetTrackMIDINoteName(integer track, integer pitch, integer chan, string name)

Python: Boolean RPR_SetTrackMIDINoteName(Int track, Int pitch, Int chan, String name)

channel < 0 assigns these note names to all channels.



C: bool SetTrackMIDINoteNameEx(ReaProject* proj, MediaTrack* track, int pitch, int chan, const char* name)

EEL2: bool SetTrackMIDINoteNameEx(ReaProject proj, MediaTrack track, int pitch, int chan, "name")

Lua: boolean reaper.SetTrackMIDINoteNameEx(ReaProject proj, MediaTrack track, integer pitch, integer chan, string name)

Python: Boolean RPR_SetTrackMIDINoteNameEx(ReaProject proj, MediaTrack track, Int pitch, Int chan, String name)

channel < 0 assigns note name to all channels. pitch 128 assigns name for CC0, pitch 129 for CC1, etc.



C: void SetTrackSelected(MediaTrack* track, bool selected)

EEL2: SetTrackSelected(MediaTrack track, bool selected)

Lua: reaper.SetTrackSelected(MediaTrack track, boolean selected)

Python: RPR_SetTrackSelected(MediaTrack track, Boolean selected)



C: bool SetTrackSendInfo_Value(MediaTrack* tr, int category, int sendidx, const char* parmname, double newvalue)

EEL2: bool SetTrackSendInfo_Value(MediaTrack tr, int category, int sendidx, "parmname", newvalue)

Lua: boolean reaper.SetTrackSendInfo_Value(MediaTrack tr, integer category, integer sendidx, string parmname, number newvalue)

Python: Boolean RPR_SetTrackSendInfo_Value(MediaTrack tr, Int category, Int sendidx, String parmname, Float newvalue)

Set send/receive/hardware output numerical-value attributes, return true on success.
category is <0 for receives, 0=sends, >0 for hardware outputs
parameter names:
B_MUTE : bool *
B_PHASE : bool * : true to flip phase
B_MONO : bool *
D_VOL : double * : 1.0 = +0dB etc
D_PAN : double * : -1..+1
D_PANLAW : double * : 1.0=+0.0db, 0.5=-6dB, -1.0 = projdef etc
I_SENDMODE : int * : 0=post-fader, 1=pre-fx, 2=post-fx (deprecated), 3=post-fx
I_AUTOMODE : int * : automation mode (-1=use track automode, 0=trim/off, 1=read, 2=touch, 3=write, 4=latch)
I_SRCCHAN : int * : -1 for no audio send. Low 10 bits specify channel offset, and higher bits specify channel count. (srcchan>>10) == 0 for stereo, 1 for mono, 2 for 4 channel, 3 for 6 channel, etc.
I_DSTCHAN : int * : low 10 bits are destination index, &1024 set to mix to mono.
I_MIDIFLAGS : int * : low 5 bits=source channel 0=all, 1-16, next 5 bits=dest channel, 0=orig, 1-16=chan
See CreateTrackSend, RemoveTrackSend, GetTrackNumSends.



C: bool SetTrackSendUIPan(MediaTrack* track, int send_idx, double pan, int isend)

EEL2: bool SetTrackSendUIPan(MediaTrack track, int send_idx, pan, int isend)

Lua: boolean reaper.SetTrackSendUIPan(MediaTrack track, integer send_idx, number pan, integer isend)

Python: Boolean RPR_SetTrackSendUIPan(MediaTrack track, Int send_idx, Float pan, Int isend)

send_idx<0 for receives, >=0 for hw ouputs, >=nb_of_hw_ouputs for sends. isend=1 for end of edit, -1 for an instant edit (such as reset), 0 for normal tweak.



C: bool SetTrackSendUIVol(MediaTrack* track, int send_idx, double vol, int isend)

EEL2: bool SetTrackSendUIVol(MediaTrack track, int send_idx, vol, int isend)

Lua: boolean reaper.SetTrackSendUIVol(MediaTrack track, integer send_idx, number vol, integer isend)

Python: Boolean RPR_SetTrackSendUIVol(MediaTrack track, Int send_idx, Float vol, Int isend)

send_idx<0 for receives, >=0 for hw ouputs, >=nb_of_hw_ouputs for sends. isend=1 for end of edit, -1 for an instant edit (such as reset), 0 for normal tweak.



C: bool SetTrackStateChunk(MediaTrack* track, const char* str, bool isundoOptional)

EEL2: bool SetTrackStateChunk(MediaTrack track, "str", bool isundo)

Lua: boolean reaper.SetTrackStateChunk(MediaTrack track, string str, boolean isundo)

Python: Boolean RPR_SetTrackStateChunk(MediaTrack track, String str, Boolean isundoOptional)

Sets the RPPXML state of a track, returns true if successful. Undo flag is a performance/caching hint.



C: int SetTrackUIInputMonitor(MediaTrack* track, int monitor, int igngroupflags)

EEL2: int SetTrackUIInputMonitor(MediaTrack track, int monitor, int igngroupflags)

Lua: integer reaper.SetTrackUIInputMonitor(MediaTrack track, integer monitor, integer igngroupflags)

Python: Int RPR_SetTrackUIInputMonitor(MediaTrack track, Int monitor, Int igngroupflags)

monitor: 0=no monitoring, 1=monitoring, 2=auto-monitoring. returns new value or -1 if error. igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging



C: int SetTrackUIMute(MediaTrack* track, int mute, int igngroupflags)

EEL2: int SetTrackUIMute(MediaTrack track, int mute, int igngroupflags)

Lua: integer reaper.SetTrackUIMute(MediaTrack track, integer mute, integer igngroupflags)

Python: Int RPR_SetTrackUIMute(MediaTrack track, Int mute, Int igngroupflags)

mute: <0 toggles, >0 sets mute, 0=unsets mute. returns new value or -1 if error. igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging



C: double SetTrackUIPan(MediaTrack* track, double pan, bool relative, bool done, int igngroupflags)

EEL2: double SetTrackUIPan(MediaTrack track, pan, bool relative, bool done, int igngroupflags)

Lua: number reaper.SetTrackUIPan(MediaTrack track, number pan, boolean relative, boolean done, integer igngroupflags)

Python: Float RPR_SetTrackUIPan(MediaTrack track, Float pan, Boolean relative, Boolean done, Int igngroupflags)

igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging



C: int SetTrackUIPolarity(MediaTrack* track, int polarity, int igngroupflags)

EEL2: int SetTrackUIPolarity(MediaTrack track, int polarity, int igngroupflags)

Lua: integer reaper.SetTrackUIPolarity(MediaTrack track, integer polarity, integer igngroupflags)

Python: Int RPR_SetTrackUIPolarity(MediaTrack track, Int polarity, Int igngroupflags)

polarity (AKA phase): <0 toggles, 0=normal, >0=inverted. returns new value or -1 if error.igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging



C: int SetTrackUIRecArm(MediaTrack* track, int recarm, int igngroupflags)

EEL2: int SetTrackUIRecArm(MediaTrack track, int recarm, int igngroupflags)

Lua: integer reaper.SetTrackUIRecArm(MediaTrack track, integer recarm, integer igngroupflags)

Python: Int RPR_SetTrackUIRecArm(MediaTrack track, Int recarm, Int igngroupflags)

recarm: <0 toggles, >0 sets recarm, 0=unsets recarm. returns new value or -1 if error. igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging



C: int SetTrackUISolo(MediaTrack* track, int solo, int igngroupflags)

EEL2: int SetTrackUISolo(MediaTrack track, int solo, int igngroupflags)

Lua: integer reaper.SetTrackUISolo(MediaTrack track, integer solo, integer igngroupflags)

Python: Int RPR_SetTrackUISolo(MediaTrack track, Int solo, Int igngroupflags)

solo: <0 toggles, 1 sets solo (default mode), 0=unsets solo, 2 sets solo (non-SIP), 4 sets solo (SIP). returns new value or -1 if error. igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging



C: double SetTrackUIVolume(MediaTrack* track, double volume, bool relative, bool done, int igngroupflags)

EEL2: double SetTrackUIVolume(MediaTrack track, volume, bool relative, bool done, int igngroupflags)

Lua: number reaper.SetTrackUIVolume(MediaTrack track, number volume, boolean relative, boolean done, integer igngroupflags)

Python: Float RPR_SetTrackUIVolume(MediaTrack track, Float volume, Boolean relative, Boolean done, Int igngroupflags)

igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging



C: double SetTrackUIWidth(MediaTrack* track, double width, bool relative, bool done, int igngroupflags)

EEL2: double SetTrackUIWidth(MediaTrack track, width, bool relative, bool done, int igngroupflags)

Lua: number reaper.SetTrackUIWidth(MediaTrack track, number width, boolean relative, boolean done, integer igngroupflags)

Python: Float RPR_SetTrackUIWidth(MediaTrack track, Float width, Boolean relative, Boolean done, Int igngroupflags)

igngroupflags: &1 to prevent track grouping, &2 to prevent selection ganging



C: void ShowActionList(KbdSectionInfo* section, HWND callerWnd)

EEL2: ShowActionList(KbdSectionInfo section, HWND callerWnd)

Lua: reaper.ShowActionList(KbdSectionInfo section, HWND callerWnd)

Python: RPR_ShowActionList(KbdSectionInfo section, HWND callerWnd)



C: void ShowConsoleMsg(const char* msg)

EEL2: ShowConsoleMsg("msg")

Lua: reaper.ShowConsoleMsg(string msg)

Python: RPR_ShowConsoleMsg(String msg)

Show a message to the user (also useful for debugging). Send "\n" for newline, "" to clear the console. Prefix string with "!SHOW:" and text will be added to console without opening the window. See ClearConsole



C: int ShowMessageBox(const char* msg, const char* title, int type)

EEL2: int ShowMessageBox("msg", "title", int type)

Lua: integer reaper.ShowMessageBox(string msg, string title, integer type)

Python: Int RPR_ShowMessageBox(String msg, String title, Int type)

type 0=OK,1=OKCANCEL,2=ABORTRETRYIGNORE,3=YESNOCANCEL,4=YESNO,5=RETRYCANCEL : ret 1=OK,2=CANCEL,3=ABORT,4=RETRY,5=IGNORE,6=YES,7=NO



C: void ShowPopupMenu(const char* name, int x, int y, HWND hwndParentOptional, void* ctxOptional, int ctx2Optional, int ctx3Optional)

EEL2: ShowPopupMenu("name", int x, int y, HWND hwndParent, void* ctx, int ctx2, int ctx3)

Lua: reaper.ShowPopupMenu(string name, integer x, integer y, HWND hwndParent, identifier ctx, integer ctx2, integer ctx3)

Python: RPR_ShowPopupMenu(String name, Int x, Int y, HWND hwndParentOptional, void ctxOptional, Int ctx2Optional, Int ctx3Optional)

shows a context menu, valid names include: track_input, track_panel, track_area, track_routing, item, ruler, envelope, envelope_point, envelope_item. ctxOptional can be a track pointer for track_*, item pointer for item* (but is optional). for envelope_point, ctx2Optional has point index, ctx3Optional has item index (0=main envelope, 1=first AI). for envelope_item, ctx2Optional has AI index (1=first AI)



C: double SLIDER2DB(double y)

EEL2: double SLIDER2DB(y)

Lua: number reaper.SLIDER2DB(number y)

Python: Float RPR_SLIDER2DB(Float y)



C: double SnapToGrid(ReaProject* project, double time_pos)

EEL2: double SnapToGrid(ReaProject project, time_pos)

Lua: number reaper.SnapToGrid(ReaProject project, number time_pos)

Python: Float RPR_SnapToGrid(ReaProject project, Float time_pos)



C: void SoloAllTracks(int solo)

EEL2: SoloAllTracks(int solo)

Lua: reaper.SoloAllTracks(integer solo)

Python: RPR_SoloAllTracks(Int solo)

solo=2 for SIP



C: HWND Splash_GetWnd()

EEL2: HWND Splash_GetWnd()

Lua: HWND reaper.Splash_GetWnd()

Python: HWND RPR_Splash_GetWnd()

gets the splash window, in case you want to display a message over it. Returns NULL when the splash window is not displayed.



C: MediaItem* SplitMediaItem(MediaItem* item, double position)

EEL2: MediaItem SplitMediaItem(MediaItem item, position)

Lua: MediaItem reaper.SplitMediaItem(MediaItem item, number position)

Python: MediaItem RPR_SplitMediaItem(MediaItem item, Float position)

the original item becomes the left-hand split, the function returns the right-hand split (or NULL if the split failed)



C: void stringToGuid(const char* str, GUID* g)

EEL2: stringToGuid("str", #gGUID)

Lua: string gGUID = reaper.stringToGuid(string str, string gGUID)

Python: RPR_stringToGuid(String str, GUID g)



C: void StuffMIDIMessage(int mode, int msg1, int msg2, int msg3)

EEL2: StuffMIDIMessage(int mode, int msg1, int msg2, int msg3)

Lua: reaper.StuffMIDIMessage(integer mode, integer msg1, integer msg2, integer msg3)

Python: RPR_StuffMIDIMessage(Int mode, Int msg1, Int msg2, Int msg3)

Stuffs a 3 byte MIDI message into either the Virtual MIDI Keyboard queue, or the MIDI-as-control input queue, or sends to a MIDI hardware output. mode=0 for VKB, 1 for control (actions map etc), 2 for VKB-on-current-channel; 16 for external MIDI device 0, 17 for external MIDI device 1, etc; see GetNumMIDIOutputs, GetMIDIOutputName.



C: int TakeFX_AddByName(MediaItem_Take* take, const char* fxname, int instantiate)

EEL2: int TakeFX_AddByName(MediaItem_Take take, "fxname", int instantiate)

Lua: integer reaper.TakeFX_AddByName(MediaItem_Take take, string fxname, integer instantiate)

Python: Int RPR_TakeFX_AddByName(MediaItem_Take take, String fxname, Int instantiate)

Adds or queries the position of a named FX in a take. See TrackFX_AddByName() for information on fxname and instantiate. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TakeFX_CopyToTake(MediaItem_Take* src_take, int src_fx, MediaItem_Take* dest_take, int dest_fx, bool is_move)

EEL2: TakeFX_CopyToTake(MediaItem_Take src_take, int src_fx, MediaItem_Take dest_take, int dest_fx, bool is_move)

Lua: reaper.TakeFX_CopyToTake(MediaItem_Take src_take, integer src_fx, MediaItem_Take dest_take, integer dest_fx, boolean is_move)

Python: RPR_TakeFX_CopyToTake(MediaItem_Take src_take, Int src_fx, MediaItem_Take dest_take, Int dest_fx, Boolean is_move)

Copies (or moves) FX from src_take to dest_take. Can be used with src_take=dest_take to reorder. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TakeFX_CopyToTrack(MediaItem_Take* src_take, int src_fx, MediaTrack* dest_track, int dest_fx, bool is_move)

EEL2: TakeFX_CopyToTrack(MediaItem_Take src_take, int src_fx, MediaTrack dest_track, int dest_fx, bool is_move)

Lua: reaper.TakeFX_CopyToTrack(MediaItem_Take src_take, integer src_fx, MediaTrack dest_track, integer dest_fx, boolean is_move)

Python: RPR_TakeFX_CopyToTrack(MediaItem_Take src_take, Int src_fx, MediaTrack dest_track, Int dest_fx, Boolean is_move)

Copies (or moves) FX from src_take to dest_track. dest_fx can have 0x1000000 set to reference input FX. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_Delete(MediaItem_Take* take, int fx)

EEL2: bool TakeFX_Delete(MediaItem_Take take, int fx)

Lua: boolean reaper.TakeFX_Delete(MediaItem_Take take, integer fx)

Python: Boolean RPR_TakeFX_Delete(MediaItem_Take take, Int fx)

Remove a FX from take chain (returns true on success) FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_EndParamEdit(MediaItem_Take* take, int fx, int param)

EEL2: bool TakeFX_EndParamEdit(MediaItem_Take take, int fx, int param)

Lua: boolean reaper.TakeFX_EndParamEdit(MediaItem_Take take, integer fx, integer param)

Python: Boolean RPR_TakeFX_EndParamEdit(MediaItem_Take take, Int fx, Int param)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_FormatParamValue(MediaItem_Take* take, int fx, int param, double val, char* bufOut, int bufOut_sz)

EEL2: bool TakeFX_FormatParamValue(MediaItem_Take take, int fx, int param, val, #buf)

Lua: boolean retval, string buf = reaper.TakeFX_FormatParamValue(MediaItem_Take take, integer fx, integer param, number val)

Python: (Boolean retval, MediaItem_Take take, Int fx, Int param, Float val, String bufOut, Int bufOut_sz) = RPR_TakeFX_FormatParamValue(take, fx, param, val, bufOut, bufOut_sz)

Note: only works with FX that support Cockos VST extensions. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_FormatParamValueNormalized(MediaItem_Take* take, int fx, int param, double value, char* buf, int buf_sz)

EEL2: bool TakeFX_FormatParamValueNormalized(MediaItem_Take take, int fx, int param, value, #buf)

Lua: boolean retval, string buf = reaper.TakeFX_FormatParamValueNormalized(MediaItem_Take take, integer fx, integer param, number value, string buf)

Python: (Boolean retval, MediaItem_Take take, Int fx, Int param, Float value, String buf, Int buf_sz) = RPR_TakeFX_FormatParamValueNormalized(take, fx, param, value, buf, buf_sz)

Note: only works with FX that support Cockos VST extensions. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TakeFX_GetChainVisible(MediaItem_Take* take)

EEL2: int TakeFX_GetChainVisible(MediaItem_Take take)

Lua: integer reaper.TakeFX_GetChainVisible(MediaItem_Take take)

Python: Int RPR_TakeFX_GetChainVisible(MediaItem_Take take)

returns index of effect visible in chain, or -1 for chain hidden, or -2 for chain visible but no effect selected



C: int TakeFX_GetCount(MediaItem_Take* take)

EEL2: int TakeFX_GetCount(MediaItem_Take take)

Lua: integer reaper.TakeFX_GetCount(MediaItem_Take take)

Python: Int RPR_TakeFX_GetCount(MediaItem_Take take)



C: bool TakeFX_GetEnabled(MediaItem_Take* take, int fx)

EEL2: bool TakeFX_GetEnabled(MediaItem_Take take, int fx)

Lua: boolean reaper.TakeFX_GetEnabled(MediaItem_Take take, integer fx)

Python: Boolean RPR_TakeFX_GetEnabled(MediaItem_Take take, Int fx)

See TakeFX_SetEnabled FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: TrackEnvelope* TakeFX_GetEnvelope(MediaItem_Take* take, int fxindex, int parameterindex, bool create)

EEL2: TrackEnvelope TakeFX_GetEnvelope(MediaItem_Take take, int fxindex, int parameterindex, bool create)

Lua: TrackEnvelope reaper.TakeFX_GetEnvelope(MediaItem_Take take, integer fxindex, integer parameterindex, boolean create)

Python: TrackEnvelope RPR_TakeFX_GetEnvelope(MediaItem_Take take, Int fxindex, Int parameterindex, Boolean create)

Returns the FX parameter envelope. If the envelope does not exist and create=true, the envelope will be created. If the envelope already exists and is bypassed and create=true, then the envelope will be unbypassed. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: HWND TakeFX_GetFloatingWindow(MediaItem_Take* take, int index)

EEL2: HWND TakeFX_GetFloatingWindow(MediaItem_Take take, int index)

Lua: HWND reaper.TakeFX_GetFloatingWindow(MediaItem_Take take, integer index)

Python: HWND RPR_TakeFX_GetFloatingWindow(MediaItem_Take take, Int index)

returns HWND of floating window for effect index, if any FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_GetFormattedParamValue(MediaItem_Take* take, int fx, int param, char* bufOut, int bufOut_sz)

EEL2: bool TakeFX_GetFormattedParamValue(MediaItem_Take take, int fx, int param, #buf)

Lua: boolean retval, string buf = reaper.TakeFX_GetFormattedParamValue(MediaItem_Take take, integer fx, integer param)

Python: (Boolean retval, MediaItem_Take take, Int fx, Int param, String bufOut, Int bufOut_sz) = RPR_TakeFX_GetFormattedParamValue(take, fx, param, bufOut, bufOut_sz)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: GUID* TakeFX_GetFXGUID(MediaItem_Take* take, int fx)

EEL2: bool TakeFX_GetFXGUID(#retguid, MediaItem_Take take, int fx)

Lua: string GUID = reaper.TakeFX_GetFXGUID(MediaItem_Take take, integer fx)

Python: GUID RPR_TakeFX_GetFXGUID(MediaItem_Take take, Int fx)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_GetFXName(MediaItem_Take* take, int fx, char* bufOut, int bufOut_sz)

EEL2: bool TakeFX_GetFXName(MediaItem_Take take, int fx, #buf)

Lua: boolean retval, string buf = reaper.TakeFX_GetFXName(MediaItem_Take take, integer fx)

Python: (Boolean retval, MediaItem_Take take, Int fx, String bufOut, Int bufOut_sz) = RPR_TakeFX_GetFXName(take, fx, bufOut, bufOut_sz)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TakeFX_GetIOSize(MediaItem_Take* take, int fx, int* inputPinsOut, int* outputPinsOut)

EEL2: int TakeFX_GetIOSize(MediaItem_Take take, int fx, int &inputPins, int &outputPins)

Lua: integer retval, integer inputPins, integer outputPins = reaper.TakeFX_GetIOSize(MediaItem_Take take, integer fx)

Python: (Int retval, MediaItem_Take take, Int fx, Int inputPinsOut, Int outputPinsOut) = RPR_TakeFX_GetIOSize(take, fx, inputPinsOut, outputPinsOut)

Gets the number of input/output pins for FX if available, returns plug-in type or -1 on error FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_GetNamedConfigParm(MediaItem_Take* take, int fx, const char* parmname, char* bufOutNeedBig, int bufOutNeedBig_sz)

EEL2: bool TakeFX_GetNamedConfigParm(MediaItem_Take take, int fx, "parmname", #buf)

Lua: boolean retval, string buf = reaper.TakeFX_GetNamedConfigParm(MediaItem_Take take, integer fx, string parmname)

Python: (Boolean retval, MediaItem_Take take, Int fx, String parmname, String bufOutNeedBig, Int bufOutNeedBig_sz) = RPR_TakeFX_GetNamedConfigParm(take, fx, parmname, bufOutNeedBig, bufOutNeedBig_sz)

gets plug-in specific named configuration value (returns true on success). see TrackFX_GetNamedConfigParm FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TakeFX_GetNumParams(MediaItem_Take* take, int fx)

EEL2: int TakeFX_GetNumParams(MediaItem_Take take, int fx)

Lua: integer reaper.TakeFX_GetNumParams(MediaItem_Take take, integer fx)

Python: Int RPR_TakeFX_GetNumParams(MediaItem_Take take, Int fx)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_GetOffline(MediaItem_Take* take, int fx)

EEL2: bool TakeFX_GetOffline(MediaItem_Take take, int fx)

Lua: boolean reaper.TakeFX_GetOffline(MediaItem_Take take, integer fx)

Python: Boolean RPR_TakeFX_GetOffline(MediaItem_Take take, Int fx)

See TakeFX_SetOffline FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_GetOpen(MediaItem_Take* take, int fx)

EEL2: bool TakeFX_GetOpen(MediaItem_Take take, int fx)

Lua: boolean reaper.TakeFX_GetOpen(MediaItem_Take take, integer fx)

Python: Boolean RPR_TakeFX_GetOpen(MediaItem_Take take, Int fx)

Returns true if this FX UI is open in the FX chain window or a floating window. See TakeFX_SetOpen FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: double TakeFX_GetParam(MediaItem_Take* take, int fx, int param, double* minvalOut, double* maxvalOut)

EEL2: double TakeFX_GetParam(MediaItem_Take take, int fx, int param, &minval, &maxval)

Lua: number retval, number minval, number maxval = reaper.TakeFX_GetParam(MediaItem_Take take, integer fx, integer param)

Python: (Float retval, MediaItem_Take take, Int fx, Int param, Float minvalOut, Float maxvalOut) = RPR_TakeFX_GetParam(take, fx, param, minvalOut, maxvalOut)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_GetParameterStepSizes(MediaItem_Take* take, int fx, int param, double* stepOut, double* smallstepOut, double* largestepOut, bool* istoggleOut)

EEL2: bool TakeFX_GetParameterStepSizes(MediaItem_Take take, int fx, int param, &step, &smallstep, &largestep, bool &istoggle)

Lua: boolean retval, number step, number smallstep, number largestep, boolean istoggle = reaper.TakeFX_GetParameterStepSizes(MediaItem_Take take, integer fx, integer param)

Python: (Boolean retval, MediaItem_Take take, Int fx, Int param, Float stepOut, Float smallstepOut, Float largestepOut, Boolean istoggleOut) = RPR_TakeFX_GetParameterStepSizes(take, fx, param, stepOut, smallstepOut, largestepOut, istoggleOut)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: double TakeFX_GetParamEx(MediaItem_Take* take, int fx, int param, double* minvalOut, double* maxvalOut, double* midvalOut)

EEL2: double TakeFX_GetParamEx(MediaItem_Take take, int fx, int param, &minval, &maxval, &midval)

Lua: number retval, number minval, number maxval, number midval = reaper.TakeFX_GetParamEx(MediaItem_Take take, integer fx, integer param)

Python: (Float retval, MediaItem_Take take, Int fx, Int param, Float minvalOut, Float maxvalOut, Float midvalOut) = RPR_TakeFX_GetParamEx(take, fx, param, minvalOut, maxvalOut, midvalOut)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TakeFX_GetParamFromIdent(MediaItem_Take* take, int fx, const char* ident_str)

EEL2: int TakeFX_GetParamFromIdent(MediaItem_Take take, int fx, "ident_str")

Lua: integer reaper.TakeFX_GetParamFromIdent(MediaItem_Take take, integer fx, string ident_str)

Python: Int RPR_TakeFX_GetParamFromIdent(MediaItem_Take take, Int fx, String ident_str)

gets the parameter index from an identifying string (:wet, :bypass, or a string returned from GetParamIdent), or -1 if unknown. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_GetParamIdent(MediaItem_Take* take, int fx, int param, char* bufOut, int bufOut_sz)

EEL2: bool TakeFX_GetParamIdent(MediaItem_Take take, int fx, int param, #buf)

Lua: boolean retval, string buf = reaper.TakeFX_GetParamIdent(MediaItem_Take take, integer fx, integer param)

Python: (Boolean retval, MediaItem_Take take, Int fx, Int param, String bufOut, Int bufOut_sz) = RPR_TakeFX_GetParamIdent(take, fx, param, bufOut, bufOut_sz)

gets an identifying string for the parameter FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_GetParamName(MediaItem_Take* take, int fx, int param, char* bufOut, int bufOut_sz)

EEL2: bool TakeFX_GetParamName(MediaItem_Take take, int fx, int param, #buf)

Lua: boolean retval, string buf = reaper.TakeFX_GetParamName(MediaItem_Take take, integer fx, integer param)

Python: (Boolean retval, MediaItem_Take take, Int fx, Int param, String bufOut, Int bufOut_sz) = RPR_TakeFX_GetParamName(take, fx, param, bufOut, bufOut_sz)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: double TakeFX_GetParamNormalized(MediaItem_Take* take, int fx, int param)

EEL2: double TakeFX_GetParamNormalized(MediaItem_Take take, int fx, int param)

Lua: number reaper.TakeFX_GetParamNormalized(MediaItem_Take take, integer fx, integer param)

Python: Float RPR_TakeFX_GetParamNormalized(MediaItem_Take take, Int fx, Int param)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TakeFX_GetPinMappings(MediaItem_Take* take, int fx, int isoutput, int pin, int* high32Out)

EEL2: int TakeFX_GetPinMappings(MediaItem_Take take, int fx, int isoutput, int pin, int &high32)

Lua: integer retval, integer high32 = reaper.TakeFX_GetPinMappings(MediaItem_Take take, integer fx, integer isoutput, integer pin)

Python: (Int retval, MediaItem_Take take, Int fx, Int isoutput, Int pin, Int high32Out) = RPR_TakeFX_GetPinMappings(take, fx, isoutput, pin, high32Out)

gets the effective channel mapping bitmask for a particular pin. high32Out will be set to the high 32 bits. Add 0x1000000 to pin index in order to access the second 64 bits of mappings independent of the first 64 bits. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_GetPreset(MediaItem_Take* take, int fx, char* presetnameOut, int presetnameOut_sz)

EEL2: bool TakeFX_GetPreset(MediaItem_Take take, int fx, #presetname)

Lua: boolean retval, string presetname = reaper.TakeFX_GetPreset(MediaItem_Take take, integer fx)

Python: (Boolean retval, MediaItem_Take take, Int fx, String presetnameOut, Int presetnameOut_sz) = RPR_TakeFX_GetPreset(take, fx, presetnameOut, presetnameOut_sz)

Get the name of the preset currently showing in the REAPER dropdown, or the full path to a factory preset file for VST3 plug-ins (.vstpreset). See TakeFX_SetPreset. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TakeFX_GetPresetIndex(MediaItem_Take* take, int fx, int* numberOfPresetsOut)

EEL2: int TakeFX_GetPresetIndex(MediaItem_Take take, int fx, int &numberOfPresets)

Lua: integer retval, integer numberOfPresets = reaper.TakeFX_GetPresetIndex(MediaItem_Take take, integer fx)

Python: (Int retval, MediaItem_Take take, Int fx, Int numberOfPresetsOut) = RPR_TakeFX_GetPresetIndex(take, fx, numberOfPresetsOut)

Returns current preset index, or -1 if error. numberOfPresetsOut will be set to total number of presets available. See TakeFX_SetPresetByIndex FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TakeFX_GetUserPresetFilename(MediaItem_Take* take, int fx, char* fnOut, int fnOut_sz)

EEL2: TakeFX_GetUserPresetFilename(MediaItem_Take take, int fx, #fn)

Lua: string fn = reaper.TakeFX_GetUserPresetFilename(MediaItem_Take take, integer fx)

Python: (MediaItem_Take take, Int fx, String fnOut, Int fnOut_sz) = RPR_TakeFX_GetUserPresetFilename(take, fx, fnOut, fnOut_sz)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_NavigatePresets(MediaItem_Take* take, int fx, int presetmove)

EEL2: bool TakeFX_NavigatePresets(MediaItem_Take take, int fx, int presetmove)

Lua: boolean reaper.TakeFX_NavigatePresets(MediaItem_Take take, integer fx, integer presetmove)

Python: Boolean RPR_TakeFX_NavigatePresets(MediaItem_Take take, Int fx, Int presetmove)

presetmove==1 activates the next preset, presetmove==-1 activates the previous preset, etc. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TakeFX_SetEnabled(MediaItem_Take* take, int fx, bool enabled)

EEL2: TakeFX_SetEnabled(MediaItem_Take take, int fx, bool enabled)

Lua: reaper.TakeFX_SetEnabled(MediaItem_Take take, integer fx, boolean enabled)

Python: RPR_TakeFX_SetEnabled(MediaItem_Take take, Int fx, Boolean enabled)

See TakeFX_GetEnabled FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_SetNamedConfigParm(MediaItem_Take* take, int fx, const char* parmname, const char* value)

EEL2: bool TakeFX_SetNamedConfigParm(MediaItem_Take take, int fx, "parmname", "value")

Lua: boolean reaper.TakeFX_SetNamedConfigParm(MediaItem_Take take, integer fx, string parmname, string value)

Python: Boolean RPR_TakeFX_SetNamedConfigParm(MediaItem_Take take, Int fx, String parmname, String value)

gets plug-in specific named configuration value (returns true on success). see TrackFX_SetNamedConfigParm FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TakeFX_SetOffline(MediaItem_Take* take, int fx, bool offline)

EEL2: TakeFX_SetOffline(MediaItem_Take take, int fx, bool offline)

Lua: reaper.TakeFX_SetOffline(MediaItem_Take take, integer fx, boolean offline)

Python: RPR_TakeFX_SetOffline(MediaItem_Take take, Int fx, Boolean offline)

See TakeFX_GetOffline FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TakeFX_SetOpen(MediaItem_Take* take, int fx, bool open)

EEL2: TakeFX_SetOpen(MediaItem_Take take, int fx, bool open)

Lua: reaper.TakeFX_SetOpen(MediaItem_Take take, integer fx, boolean open)

Python: RPR_TakeFX_SetOpen(MediaItem_Take take, Int fx, Boolean open)

Open this FX UI. See TakeFX_GetOpen FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_SetParam(MediaItem_Take* take, int fx, int param, double val)

EEL2: bool TakeFX_SetParam(MediaItem_Take take, int fx, int param, val)

Lua: boolean reaper.TakeFX_SetParam(MediaItem_Take take, integer fx, integer param, number val)

Python: Boolean RPR_TakeFX_SetParam(MediaItem_Take take, Int fx, Int param, Float val)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_SetParamNormalized(MediaItem_Take* take, int fx, int param, double value)

EEL2: bool TakeFX_SetParamNormalized(MediaItem_Take take, int fx, int param, value)

Lua: boolean reaper.TakeFX_SetParamNormalized(MediaItem_Take take, integer fx, integer param, number value)

Python: Boolean RPR_TakeFX_SetParamNormalized(MediaItem_Take take, Int fx, Int param, Float value)

FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_SetPinMappings(MediaItem_Take* take, int fx, int isoutput, int pin, int low32bits, int hi32bits)

EEL2: bool TakeFX_SetPinMappings(MediaItem_Take take, int fx, int isoutput, int pin, int low32bits, int hi32bits)

Lua: boolean reaper.TakeFX_SetPinMappings(MediaItem_Take take, integer fx, integer isoutput, integer pin, integer low32bits, integer hi32bits)

Python: Boolean RPR_TakeFX_SetPinMappings(MediaItem_Take take, Int fx, Int isoutput, Int pin, Int low32bits, Int hi32bits)

sets the channel mapping bitmask for a particular pin. returns false if unsupported (not all types of plug-ins support this capability). Add 0x1000000 to pin index in order to access the second 64 bits of mappings independent of the first 64 bits. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_SetPreset(MediaItem_Take* take, int fx, const char* presetname)

EEL2: bool TakeFX_SetPreset(MediaItem_Take take, int fx, "presetname")

Lua: boolean reaper.TakeFX_SetPreset(MediaItem_Take take, integer fx, string presetname)

Python: Boolean RPR_TakeFX_SetPreset(MediaItem_Take take, Int fx, String presetname)

Activate a preset with the name shown in the REAPER dropdown. Full paths to .vstpreset files are also supported for VST3 plug-ins. See TakeFX_GetPreset. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeFX_SetPresetByIndex(MediaItem_Take* take, int fx, int idx)

EEL2: bool TakeFX_SetPresetByIndex(MediaItem_Take take, int fx, int idx)

Lua: boolean reaper.TakeFX_SetPresetByIndex(MediaItem_Take take, integer fx, integer idx)

Python: Boolean RPR_TakeFX_SetPresetByIndex(MediaItem_Take take, Int fx, Int idx)

Sets the preset idx, or the factory preset (idx==-2), or the default user preset (idx==-1). Returns true on success. See TakeFX_GetPresetIndex. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TakeFX_Show(MediaItem_Take* take, int index, int showFlag)

EEL2: TakeFX_Show(MediaItem_Take take, int index, int showFlag)

Lua: reaper.TakeFX_Show(MediaItem_Take take, integer index, integer showFlag)

Python: RPR_TakeFX_Show(MediaItem_Take take, Int index, Int showFlag)

showflag=0 for hidechain, =1 for show chain(index valid), =2 for hide floating window(index valid), =3 for show floating window (index valid) FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TakeIsMIDI(MediaItem_Take* take)

EEL2: bool TakeIsMIDI(MediaItem_Take take)

Lua: boolean reaper.TakeIsMIDI(MediaItem_Take take)

Python: Boolean RPR_TakeIsMIDI(MediaItem_Take take)

Returns true if the active take contains MIDI.



C: bool ThemeLayout_GetLayout(const char* section, int idx, char* nameOut, int nameOut_sz)

EEL2: bool ThemeLayout_GetLayout("section", int idx, #name)

Lua: boolean retval, string name = reaper.ThemeLayout_GetLayout(string section, integer idx)

Python: (Boolean retval, String section, Int idx, String nameOut, Int nameOut_sz) = RPR_ThemeLayout_GetLayout(section, idx, nameOut, nameOut_sz)

Gets theme layout information. section can be 'global' for global layout override, 'seclist' to enumerate a list of layout sections, otherwise a layout section such as 'mcp', 'tcp', 'trans', etc. idx can be -1 to query the current value, -2 to get the description of the section (if not global), -3 will return the current context DPI-scaling (256=normal, 512=retina, etc), or 0..x. returns false if failed.



C: const char* ThemeLayout_GetParameter(int wp, const char** descOutOptional, int* valueOutOptional, int* defValueOutOptional, int* minValueOutOptional, int* maxValueOutOptional)

EEL2: bool ThemeLayout_GetParameter(#retval, int wp, optional #desc, optional int &value, optional int &defValue, optional int &minValue, optional int &maxValue)

Lua: string retval, optional string desc, optional integer value, optional integer defValue, optional integer minValue, optional integer maxValue = reaper.ThemeLayout_GetParameter(integer wp)

Python: (String retval, Int wp, String descOutOptional, Int valueOutOptional, Int defValueOutOptional, Int minValueOutOptional, Int maxValueOutOptional) = RPR_ThemeLayout_GetParameter(wp, descOutOptional, valueOutOptional, defValueOutOptional, minValueOutOptional, maxValueOutOptional)

returns theme layout parameter. return value is cfg-name, or nil/empty if out of range.



C: void ThemeLayout_RefreshAll()

EEL2: ThemeLayout_RefreshAll()

Lua: reaper.ThemeLayout_RefreshAll()

Python: RPR_ThemeLayout_RefreshAll()

Refreshes all layouts



C: bool ThemeLayout_SetLayout(const char* section, const char* layout)

EEL2: bool ThemeLayout_SetLayout("section", " layout")

Lua: boolean reaper.ThemeLayout_SetLayout(string section, string layout)

Python: Boolean RPR_ThemeLayout_SetLayout(String section, String layout)

Sets theme layout override for a particular section -- section can be 'global' or 'mcp' etc. If setting global layout, prefix a ! to the layout string to clear any per-layout overrides. Returns false if failed.



C: bool ThemeLayout_SetParameter(int wp, int value, bool persist)

EEL2: bool ThemeLayout_SetParameter(int wp, int value, bool persist)

Lua: boolean reaper.ThemeLayout_SetParameter(integer wp, integer value, boolean persist)

Python: Boolean RPR_ThemeLayout_SetParameter(Int wp, Int value, Boolean persist)

sets theme layout parameter to value. persist=true in order to have change loaded on next theme load. note that the caller should update layouts via ??? to make changes visible.



C: double time_precise()

Lua: number reaper.time_precise()

Python: Float RPR_time_precise()

Gets a precise system timestamp in seconds



C: double TimeMap2_beatsToTime(ReaProject* proj, double tpos, const int* measuresInOptional)

EEL2: double TimeMap2_beatsToTime(ReaProject proj, tpos, optional int measuresIn)

Lua: number reaper.TimeMap2_beatsToTime(ReaProject proj, number tpos, optional integer measuresIn)

Python: Float RPR_TimeMap2_beatsToTime(ReaProject proj, Float tpos, const int measuresInOptional)

convert a beat position (or optionally a beats+measures if measures is non-NULL) to time.



C: double TimeMap2_GetDividedBpmAtTime(ReaProject* proj, double time)

EEL2: double TimeMap2_GetDividedBpmAtTime(ReaProject proj, time)

Lua: number reaper.TimeMap2_GetDividedBpmAtTime(ReaProject proj, number time)

Python: Float RPR_TimeMap2_GetDividedBpmAtTime(ReaProject proj, Float time)

get the effective BPM at the time (seconds) position (i.e. 2x in /8 signatures)



C: double TimeMap2_GetNextChangeTime(ReaProject* proj, double time)

EEL2: double TimeMap2_GetNextChangeTime(ReaProject proj, time)

Lua: number reaper.TimeMap2_GetNextChangeTime(ReaProject proj, number time)

Python: Float RPR_TimeMap2_GetNextChangeTime(ReaProject proj, Float time)

when does the next time map (tempo or time sig) change occur



C: double TimeMap2_QNToTime(ReaProject* proj, double qn)

EEL2: double TimeMap2_QNToTime(ReaProject proj, qn)

Lua: number reaper.TimeMap2_QNToTime(ReaProject proj, number qn)

Python: Float RPR_TimeMap2_QNToTime(ReaProject proj, Float qn)

converts project QN position to time.



C: double TimeMap2_timeToBeats(ReaProject* proj, double tpos, int* measuresOutOptional, int* cmlOutOptional, double* fullbeatsOutOptional, int* cdenomOutOptional)

EEL2: double TimeMap2_timeToBeats(ReaProject proj, tpos, optional int &measures, optional int &cml, optional &fullbeats, optional int &cdenom)

Lua: number retval, optional integer measures, optional integer cml, optional number fullbeats, optional integer cdenom = reaper.TimeMap2_timeToBeats(ReaProject proj, number tpos)

Python: (Float retval, ReaProject proj, Float tpos, Int measuresOutOptional, Int cmlOutOptional, Float fullbeatsOutOptional, Int cdenomOutOptional) = RPR_TimeMap2_timeToBeats(proj, tpos, measuresOutOptional, cmlOutOptional, fullbeatsOutOptional, cdenomOutOptional)

convert a time into beats.
if measures is non-NULL, measures will be set to the measure count, return value will be beats since measure.
if cml is non-NULL, will be set to current measure length in beats (i.e. time signature numerator)
if fullbeats is non-NULL, and measures is non-NULL, fullbeats will get the full beat count (same value returned if measures is NULL).
if cdenom is non-NULL, will be set to the current time signature denominator.



C: double TimeMap2_timeToQN(ReaProject* proj, double tpos)

EEL2: double TimeMap2_timeToQN(ReaProject proj, tpos)

Lua: number reaper.TimeMap2_timeToQN(ReaProject proj, number tpos)

Python: Float RPR_TimeMap2_timeToQN(ReaProject proj, Float tpos)

converts project time position to QN position.



C: double TimeMap_curFrameRate(ReaProject* proj, bool* dropFrameOut)

EEL2: double TimeMap_curFrameRate(ReaProject proj, bool &dropFrame)

Lua: number retval, boolean dropFrame = reaper.TimeMap_curFrameRate(ReaProject proj)

Python: (Float retval, ReaProject proj, Boolean dropFrameOut) = RPR_TimeMap_curFrameRate(proj, dropFrameOut)

Gets project framerate, and optionally whether it is drop-frame timecode



C: double TimeMap_GetDividedBpmAtTime(double time)

EEL2: double TimeMap_GetDividedBpmAtTime(time)

Lua: number reaper.TimeMap_GetDividedBpmAtTime(number time)

Python: Float RPR_TimeMap_GetDividedBpmAtTime(Float time)

get the effective BPM at the time (seconds) position (i.e. 2x in /8 signatures)



C: double TimeMap_GetMeasureInfo(ReaProject* proj, int measure, double* qn_startOut, double* qn_endOut, int* timesig_numOut, int* timesig_denomOut, double* tempoOut)

EEL2: double TimeMap_GetMeasureInfo(ReaProject proj, int measure, &qn_start, &qn_end, int &timesig_num, int &timesig_denom, &tempo)

Lua: number retval, number qn_start, number qn_end, integer timesig_num, integer timesig_denom, number tempo = reaper.TimeMap_GetMeasureInfo(ReaProject proj, integer measure)

Python: (Float retval, ReaProject proj, Int measure, Float qn_startOut, Float qn_endOut, Int timesig_numOut, Int timesig_denomOut, Float tempoOut) = RPR_TimeMap_GetMeasureInfo(proj, measure, qn_startOut, qn_endOut, timesig_numOut, timesig_denomOut, tempoOut)

Get the QN position and time signature information for the start of a measure. Return the time in seconds of the measure start.



C: int TimeMap_GetMetronomePattern(ReaProject* proj, double time, char* pattern, int pattern_sz)

EEL2: int TimeMap_GetMetronomePattern(ReaProject proj, time, #pattern)

Lua: integer retval, string pattern = reaper.TimeMap_GetMetronomePattern(ReaProject proj, number time, string pattern)

Python: (Int retval, ReaProject proj, Float time, String pattern, Int pattern_sz) = RPR_TimeMap_GetMetronomePattern(proj, time, pattern, pattern_sz)

Fills in a string representing the active metronome pattern. For example, in a 7/8 measure divided 3+4, the pattern might be "1221222". The length of the string is the time signature numerator, and the function returns the time signature denominator.



C: void TimeMap_GetTimeSigAtTime(ReaProject* proj, double time, int* timesig_numOut, int* timesig_denomOut, double* tempoOut)

EEL2: TimeMap_GetTimeSigAtTime(ReaProject proj, time, int &timesig_num, int &timesig_denom, &tempo)

Lua: integer timesig_num, integer timesig_denom, number tempo = reaper.TimeMap_GetTimeSigAtTime(ReaProject proj, number time)

Python: (ReaProject proj, Float time, Int timesig_numOut, Int timesig_denomOut, Float tempoOut) = RPR_TimeMap_GetTimeSigAtTime(proj, time, timesig_numOut, timesig_denomOut, tempoOut)

get the effective time signature and tempo



C: int TimeMap_QNToMeasures(ReaProject* proj, double qn, double* qnMeasureStartOutOptional, double* qnMeasureEndOutOptional)

EEL2: int TimeMap_QNToMeasures(ReaProject proj, qn, optional &qnMeasureStart, optional &qnMeasureEnd)

Lua: integer retval, optional number qnMeasureStart, optional number qnMeasureEnd = reaper.TimeMap_QNToMeasures(ReaProject proj, number qn)

Python: (Int retval, ReaProject proj, Float qn, Float qnMeasureStartOutOptional, Float qnMeasureEndOutOptional) = RPR_TimeMap_QNToMeasures(proj, qn, qnMeasureStartOutOptional, qnMeasureEndOutOptional)

Find which measure the given QN position falls in.



C: double TimeMap_QNToTime(double qn)

EEL2: double TimeMap_QNToTime(qn)

Lua: number reaper.TimeMap_QNToTime(number qn)

Python: Float RPR_TimeMap_QNToTime(Float qn)

converts project QN position to time.



C: double TimeMap_QNToTime_abs(ReaProject* proj, double qn)

EEL2: double TimeMap_QNToTime_abs(ReaProject proj, qn)

Lua: number reaper.TimeMap_QNToTime_abs(ReaProject proj, number qn)

Python: Float RPR_TimeMap_QNToTime_abs(ReaProject proj, Float qn)

Converts project quarter note count (QN) to time. QN is counted from the start of the project, regardless of any partial measures. See TimeMap2_QNToTime



C: double TimeMap_timeToQN(double tpos)

EEL2: double TimeMap_timeToQN(tpos)

Lua: number reaper.TimeMap_timeToQN(number tpos)

Python: Float RPR_TimeMap_timeToQN(Float tpos)

converts project QN position to time.



C: double TimeMap_timeToQN_abs(ReaProject* proj, double tpos)

EEL2: double TimeMap_timeToQN_abs(ReaProject proj, tpos)

Lua: number reaper.TimeMap_timeToQN_abs(ReaProject proj, number tpos)

Python: Float RPR_TimeMap_timeToQN_abs(ReaProject proj, Float tpos)

Converts project time position to quarter note count (QN). QN is counted from the start of the project, regardless of any partial measures. See TimeMap2_timeToQN



C: bool ToggleTrackSendUIMute(MediaTrack* track, int send_idx)

EEL2: bool ToggleTrackSendUIMute(MediaTrack track, int send_idx)

Lua: boolean reaper.ToggleTrackSendUIMute(MediaTrack track, integer send_idx)

Python: Boolean RPR_ToggleTrackSendUIMute(MediaTrack track, Int send_idx)

send_idx<0 for receives, >=0 for hw ouputs, >=nb_of_hw_ouputs for sends.



C: double Track_GetPeakHoldDB(MediaTrack* track, int channel, bool clear)

EEL2: double Track_GetPeakHoldDB(MediaTrack track, int channel, bool clear)

Lua: number reaper.Track_GetPeakHoldDB(MediaTrack track, integer channel, boolean clear)

Python: Float RPR_Track_GetPeakHoldDB(MediaTrack track, Int channel, Boolean clear)

Returns meter hold state, in dB*0.01 (0 = +0dB, -0.01 = -1dB, 0.02 = +2dB, etc). If clear is set, clears the meter hold. If channel==1024 or channel==1025, returns loudness values if this is the master track or this track's VU meters are set to display loudness.



C: double Track_GetPeakInfo(MediaTrack* track, int channel)

EEL2: double Track_GetPeakInfo(MediaTrack track, int channel)

Lua: number reaper.Track_GetPeakInfo(MediaTrack track, integer channel)

Python: Float RPR_Track_GetPeakInfo(MediaTrack track, Int channel)

Returns peak meter value (1.0=+0dB, 0.0=-inf) for channel. If channel==1024 or channel==1025, returns loudness values if this is the master track or this track's VU meters are set to display loudness.



C: void TrackCtl_SetToolTip(const char* fmt, int xpos, int ypos, bool topmost)

EEL2: TrackCtl_SetToolTip("fmt", int xpos, int ypos, bool topmost)

Lua: reaper.TrackCtl_SetToolTip(string fmt, integer xpos, integer ypos, boolean topmost)

Python: RPR_TrackCtl_SetToolTip(String fmt, Int xpos, Int ypos, Boolean topmost)

displays tooltip at location, or removes if empty string



C: int TrackFX_AddByName(MediaTrack* track, const char* fxname, bool recFX, int instantiate)

EEL2: int TrackFX_AddByName(MediaTrack track, "fxname", bool recFX, int instantiate)

Lua: integer reaper.TrackFX_AddByName(MediaTrack track, string fxname, boolean recFX, integer instantiate)

Python: Int RPR_TrackFX_AddByName(MediaTrack track, String fxname, Boolean recFX, Int instantiate)

Adds or queries the position of a named FX from the track FX chain (recFX=false) or record input FX/monitoring FX (recFX=true, monitoring FX are on master track). Specify a negative value for instantiate to always create a new effect, 0 to only query the first instance of an effect, or a positive value to add an instance if one is not found. If instantiate is <= -1000, it is used for the insertion position (-1000 is first item in chain, -1001 is second, etc). fxname can have prefix to specify type: VST3:,VST2:,VST:,AU:,JS:, or DX:, or FXADD: which adds selected items from the currently-open FX browser, FXADD:2 to limit to 2 FX added, or FXADD:2e to only succeed if exactly 2 FX are selected. Returns -1 on failure or the new position in chain on success. FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TrackFX_CopyToTake(MediaTrack* src_track, int src_fx, MediaItem_Take* dest_take, int dest_fx, bool is_move)

EEL2: TrackFX_CopyToTake(MediaTrack src_track, int src_fx, MediaItem_Take dest_take, int dest_fx, bool is_move)

Lua: reaper.TrackFX_CopyToTake(MediaTrack src_track, integer src_fx, MediaItem_Take dest_take, integer dest_fx, boolean is_move)

Python: RPR_TrackFX_CopyToTake(MediaTrack src_track, Int src_fx, MediaItem_Take dest_take, Int dest_fx, Boolean is_move)

Copies (or moves) FX from src_track to dest_take. src_fx can have 0x1000000 set to reference input FX. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TrackFX_CopyToTrack(MediaTrack* src_track, int src_fx, MediaTrack* dest_track, int dest_fx, bool is_move)

EEL2: TrackFX_CopyToTrack(MediaTrack src_track, int src_fx, MediaTrack dest_track, int dest_fx, bool is_move)

Lua: reaper.TrackFX_CopyToTrack(MediaTrack src_track, integer src_fx, MediaTrack dest_track, integer dest_fx, boolean is_move)

Python: RPR_TrackFX_CopyToTrack(MediaTrack src_track, Int src_fx, MediaTrack dest_track, Int dest_fx, Boolean is_move)

Copies (or moves) FX from src_track to dest_track. Can be used with src_track=dest_track to reorder, FX indices have 0x1000000 set to reference input FX. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_Delete(MediaTrack* track, int fx)

EEL2: bool TrackFX_Delete(MediaTrack track, int fx)

Lua: boolean reaper.TrackFX_Delete(MediaTrack track, integer fx)

Python: Boolean RPR_TrackFX_Delete(MediaTrack track, Int fx)

Remove a FX from track chain (returns true on success) FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_EndParamEdit(MediaTrack* track, int fx, int param)

EEL2: bool TrackFX_EndParamEdit(MediaTrack track, int fx, int param)

Lua: boolean reaper.TrackFX_EndParamEdit(MediaTrack track, integer fx, integer param)

Python: Boolean RPR_TrackFX_EndParamEdit(MediaTrack track, Int fx, Int param)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_FormatParamValue(MediaTrack* track, int fx, int param, double val, char* bufOut, int bufOut_sz)

EEL2: bool TrackFX_FormatParamValue(MediaTrack track, int fx, int param, val, #buf)

Lua: boolean retval, string buf = reaper.TrackFX_FormatParamValue(MediaTrack track, integer fx, integer param, number val)

Python: (Boolean retval, MediaTrack track, Int fx, Int param, Float val, String bufOut, Int bufOut_sz) = RPR_TrackFX_FormatParamValue(track, fx, param, val, bufOut, bufOut_sz)

Note: only works with FX that support Cockos VST extensions. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_FormatParamValueNormalized(MediaTrack* track, int fx, int param, double value, char* buf, int buf_sz)

EEL2: bool TrackFX_FormatParamValueNormalized(MediaTrack track, int fx, int param, value, #buf)

Lua: boolean retval, string buf = reaper.TrackFX_FormatParamValueNormalized(MediaTrack track, integer fx, integer param, number value, string buf)

Python: (Boolean retval, MediaTrack track, Int fx, Int param, Float value, String buf, Int buf_sz) = RPR_TrackFX_FormatParamValueNormalized(track, fx, param, value, buf, buf_sz)

Note: only works with FX that support Cockos VST extensions. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TrackFX_GetByName(MediaTrack* track, const char* fxname, bool instantiate)

EEL2: int TrackFX_GetByName(MediaTrack track, "fxname", bool instantiate)

Lua: integer reaper.TrackFX_GetByName(MediaTrack track, string fxname, boolean instantiate)

Python: Int RPR_TrackFX_GetByName(MediaTrack track, String fxname, Boolean instantiate)

Get the index of the first track FX insert that matches fxname. If the FX is not in the chain and instantiate is true, it will be inserted. See TrackFX_GetInstrument, TrackFX_GetEQ. Deprecated in favor of TrackFX_AddByName.



C: int TrackFX_GetChainVisible(MediaTrack* track)

EEL2: int TrackFX_GetChainVisible(MediaTrack track)

Lua: integer reaper.TrackFX_GetChainVisible(MediaTrack track)

Python: Int RPR_TrackFX_GetChainVisible(MediaTrack track)

returns index of effect visible in chain, or -1 for chain hidden, or -2 for chain visible but no effect selected



C: int TrackFX_GetCount(MediaTrack* track)

EEL2: int TrackFX_GetCount(MediaTrack track)

Lua: integer reaper.TrackFX_GetCount(MediaTrack track)

Python: Int RPR_TrackFX_GetCount(MediaTrack track)



C: bool TrackFX_GetEnabled(MediaTrack* track, int fx)

EEL2: bool TrackFX_GetEnabled(MediaTrack track, int fx)

Lua: boolean reaper.TrackFX_GetEnabled(MediaTrack track, integer fx)

Python: Boolean RPR_TrackFX_GetEnabled(MediaTrack track, Int fx)

See TrackFX_SetEnabled FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TrackFX_GetEQ(MediaTrack* track, bool instantiate)

EEL2: int TrackFX_GetEQ(MediaTrack track, bool instantiate)

Lua: integer reaper.TrackFX_GetEQ(MediaTrack track, boolean instantiate)

Python: Int RPR_TrackFX_GetEQ(MediaTrack track, Boolean instantiate)

Get the index of ReaEQ in the track FX chain. If ReaEQ is not in the chain and instantiate is true, it will be inserted. See TrackFX_GetInstrument, TrackFX_GetByName.



C: bool TrackFX_GetEQBandEnabled(MediaTrack* track, int fxidx, int bandtype, int bandidx)

EEL2: bool TrackFX_GetEQBandEnabled(MediaTrack track, int fxidx, int bandtype, int bandidx)

Lua: boolean reaper.TrackFX_GetEQBandEnabled(MediaTrack track, integer fxidx, integer bandtype, integer bandidx)

Python: Boolean RPR_TrackFX_GetEQBandEnabled(MediaTrack track, Int fxidx, Int bandtype, Int bandidx)

Returns true if the EQ band is enabled.
Returns false if the band is disabled, or if track/fxidx is not ReaEQ.
Bandtype: -1=master gain, 0=hipass, 1=loshelf, 2=band, 3=notch, 4=hishelf, 5=lopass, 6=bandpass, 7=parallel bandpass.
Bandidx (ignored for master gain): 0=target first band matching bandtype, 1=target 2nd band matching bandtype, etc.

See TrackFX_GetEQ, TrackFX_GetEQParam, TrackFX_SetEQParam, TrackFX_SetEQBandEnabled. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_GetEQParam(MediaTrack* track, int fxidx, int paramidx, int* bandtypeOut, int* bandidxOut, int* paramtypeOut, double* normvalOut)

EEL2: bool TrackFX_GetEQParam(MediaTrack track, int fxidx, int paramidx, int &bandtype, int &bandidx, int &paramtype, &normval)

Lua: boolean retval, integer bandtype, integer bandidx, integer paramtype, number normval = reaper.TrackFX_GetEQParam(MediaTrack track, integer fxidx, integer paramidx)

Python: (Boolean retval, MediaTrack track, Int fxidx, Int paramidx, Int bandtypeOut, Int bandidxOut, Int paramtypeOut, Float normvalOut) = RPR_TrackFX_GetEQParam(track, fxidx, paramidx, bandtypeOut, bandidxOut, paramtypeOut, normvalOut)

Returns false if track/fxidx is not ReaEQ.
Bandtype: -1=master gain, 0=hipass, 1=loshelf, 2=band, 3=notch, 4=hishelf, 5=lopass, 6=bandpass, 7=parallel bandpass.
Bandidx (ignored for master gain): 0=target first band matching bandtype, 1=target 2nd band matching bandtype, etc.
Paramtype (ignored for master gain): 0=freq, 1=gain, 2=Q.
See TrackFX_GetEQ, TrackFX_SetEQParam, TrackFX_GetEQBandEnabled, TrackFX_SetEQBandEnabled. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: HWND TrackFX_GetFloatingWindow(MediaTrack* track, int index)

EEL2: HWND TrackFX_GetFloatingWindow(MediaTrack track, int index)

Lua: HWND reaper.TrackFX_GetFloatingWindow(MediaTrack track, integer index)

Python: HWND RPR_TrackFX_GetFloatingWindow(MediaTrack track, Int index)

returns HWND of floating window for effect index, if any FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_GetFormattedParamValue(MediaTrack* track, int fx, int param, char* bufOut, int bufOut_sz)

EEL2: bool TrackFX_GetFormattedParamValue(MediaTrack track, int fx, int param, #buf)

Lua: boolean retval, string buf = reaper.TrackFX_GetFormattedParamValue(MediaTrack track, integer fx, integer param)

Python: (Boolean retval, MediaTrack track, Int fx, Int param, String bufOut, Int bufOut_sz) = RPR_TrackFX_GetFormattedParamValue(track, fx, param, bufOut, bufOut_sz)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: GUID* TrackFX_GetFXGUID(MediaTrack* track, int fx)

EEL2: bool TrackFX_GetFXGUID(#retguid, MediaTrack track, int fx)

Lua: string GUID = reaper.TrackFX_GetFXGUID(MediaTrack track, integer fx)

Python: GUID RPR_TrackFX_GetFXGUID(MediaTrack track, Int fx)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_GetFXName(MediaTrack* track, int fx, char* bufOut, int bufOut_sz)

EEL2: bool TrackFX_GetFXName(MediaTrack track, int fx, #buf)

Lua: boolean retval, string buf = reaper.TrackFX_GetFXName(MediaTrack track, integer fx)

Python: (Boolean retval, MediaTrack track, Int fx, String bufOut, Int bufOut_sz) = RPR_TrackFX_GetFXName(track, fx, bufOut, bufOut_sz)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TrackFX_GetInstrument(MediaTrack* track)

EEL2: int TrackFX_GetInstrument(MediaTrack track)

Lua: integer reaper.TrackFX_GetInstrument(MediaTrack track)

Python: Int RPR_TrackFX_GetInstrument(MediaTrack track)

Get the index of the first track FX insert that is a virtual instrument, or -1 if none. See TrackFX_GetEQ, TrackFX_GetByName.



C: int TrackFX_GetIOSize(MediaTrack* track, int fx, int* inputPinsOut, int* outputPinsOut)

EEL2: int TrackFX_GetIOSize(MediaTrack track, int fx, int &inputPins, int &outputPins)

Lua: integer retval, integer inputPins, integer outputPins = reaper.TrackFX_GetIOSize(MediaTrack track, integer fx)

Python: (Int retval, MediaTrack track, Int fx, Int inputPinsOut, Int outputPinsOut) = RPR_TrackFX_GetIOSize(track, fx, inputPinsOut, outputPinsOut)

Gets the number of input/output pins for FX if available, returns plug-in type or -1 on error FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_GetNamedConfigParm(MediaTrack* track, int fx, const char* parmname, char* bufOutNeedBig, int bufOutNeedBig_sz)

EEL2: bool TrackFX_GetNamedConfigParm(MediaTrack track, int fx, "parmname", #buf)

Lua: boolean retval, string buf = reaper.TrackFX_GetNamedConfigParm(MediaTrack track, integer fx, string parmname)

Python: (Boolean retval, MediaTrack track, Int fx, String parmname, String bufOutNeedBig, Int bufOutNeedBig_sz) = RPR_TrackFX_GetNamedConfigParm(track, fx, parmname, bufOutNeedBig, bufOutNeedBig_sz)

gets plug-in specific named configuration value (returns true on success).

Supported values for read:
pdc : PDC latency
in_pin_X : name of input pin X
out_pin_X : name of output pin X
fx_type : type string
fx_ident : type-specific identifier
fx_name : name of FX (also supported as original_name)
GainReduction_dB : [ReaComp + other supported compressors]
parent_container : FX ID of parent container, if any (v7.06+)
container_count : [Container] number of FX in container
container_item.X : FX ID of item in container (first item is container_item.0) (v7.06+)
param.X.container_map.hint_id : unique ID of mapping (preserved if mapping order changes)
param.X.container_map.delete : read this value in order to remove the mapping for this parameter
container_map.add : read from this value to add a new container parameter mapping -- will return new parameter index (accessed via param.X.container_map.*)
container_map.add.FXID.PARMIDX : read from this value to add/get container parameter mapping for FXID/PARMIDX -- will return the parameter index (accessed via param.X.container_map.*). FXID can be a full address (must be a child of the container) or a 0-based sub-index (v7.06+).
container_map.get.FXID.PARMIDX : read from this value to get container parameter mapping for FXID/PARMIDX -- will return the parameter index (accessed via param.X.container_map.*). FXID can be a full address (must be a child of the container) or a 0-based sub-index (v7.06+).


Supported values for read/write:
vst_chunk[_program] : base64-encoded VST-specific chunk.
clap_chunk : base64-encoded CLAP-specific chunk.
param.X.lfo.[active,dir,phase,speed,strength,temposync,free,shape] : parameter moduation LFO state
param.X.acs.[active,dir,strength,attack,release,dblo,dbhi,chan,stereo,x2,y2] : parameter modulation ACS state
param.X.plink.[active,scale,offset,effect,param,midi_bus,midi_chan,midi_msg,midi_msg2] : parameter link/MIDI link: set effect=-100 to support midi_*
param.X.mod.[active,baseline,visible] : parameter module global settings
param.X.learn.[midi1,midi2,osc] : first two bytes of MIDI message, or OSC string if set
param.X.learn.mode : absolution/relative mode flag (0: Absolute, 1: 127=-1,1=+1, 2: 63=-1, 65=+1, 3: 65=-1, 1=+1, 4: toggle if nonzero)
param.X.learn.flags : &1=selected track only, &2=soft takeover, &4=focused FX only, &8=LFO retrigger, &16=visible FX only
param.X.container_map.fx_index : index of FX contained in container
param.X.container_map.fx_parm : parameter index of parameter of FX contained in container
param.X.container_map.aliased_name : name of parameter (if user-renamed, otherwise fails)
BANDTYPEx, BANDENABLEDx : band configuration [ReaEQ]
THRESHOLD, CEILING, TRUEPEAK : [ReaLimit]
NUMCHANNELS, NUMSPEAKERS, RESETCHANNELS : [ReaSurroundPan]
ITEMx : [ReaVerb] state configuration line, when writing should be followed by a write of DONE
FILE, FILEx, -FILEx, +FILEx, -FILE* : [RS5k] file list, -/+ prefixes are write-only, when writing any, should be followed by a write of DONE
MODE, RSMODE : [RS5k] general mode, resample mode
VIDEO_CODE : [video processor] code
force_auto_bypass : 0 or 1 - force auto-bypass plug-in on silence
parallel : 0, 1 or 2 - 1=process plug-in in parallel with previous, 2=process plug-in parallel and merge MIDI
instance_oversample_shift : instance oversampling shift amount, 0=none, 1=~96k, 2=~192k, etc. When setting requires playback stop/start to take effect
chain_oversample_shift : chain oversampling shift amount, 0=none, 1=~96k, 2=~192k, etc. When setting requires playback stop/start to take effect
chain_pdc_mode : chain PDC mode (0=classic, 1=new-default, 2=ignore PDC, 3=hwcomp-master)
chain_sel : selected/visible FX in chain
renamed_name : renamed FX instance name (empty string = not renamed)
container_nch : number of internal channels for container
container_nch_in : number of input pins for container
container_nch_out : number of output pints for container
container_nch_feedback : number of internal feedback channels enabled in container
focused : reading returns 1 if focused. Writing a positive value to this sets the FX UI as "last focused."
last_touched : reading returns two integers, one indicates whether FX is the last-touched FX, the second indicates which parameter was last touched. Writing a negative value ensures this plug-in is not set as last touched, otherwise the FX is set "last touched," and last touched parameter index is set to the value in the string (if valid).
FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TrackFX_GetNumParams(MediaTrack* track, int fx)

EEL2: int TrackFX_GetNumParams(MediaTrack track, int fx)

Lua: integer reaper.TrackFX_GetNumParams(MediaTrack track, integer fx)

Python: Int RPR_TrackFX_GetNumParams(MediaTrack track, Int fx)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_GetOffline(MediaTrack* track, int fx)

EEL2: bool TrackFX_GetOffline(MediaTrack track, int fx)

Lua: boolean reaper.TrackFX_GetOffline(MediaTrack track, integer fx)

Python: Boolean RPR_TrackFX_GetOffline(MediaTrack track, Int fx)

See TrackFX_SetOffline FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_GetOpen(MediaTrack* track, int fx)

EEL2: bool TrackFX_GetOpen(MediaTrack track, int fx)

Lua: boolean reaper.TrackFX_GetOpen(MediaTrack track, integer fx)

Python: Boolean RPR_TrackFX_GetOpen(MediaTrack track, Int fx)

Returns true if this FX UI is open in the FX chain window or a floating window. See TrackFX_SetOpen FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: double TrackFX_GetParam(MediaTrack* track, int fx, int param, double* minvalOut, double* maxvalOut)

EEL2: double TrackFX_GetParam(MediaTrack track, int fx, int param, &minval, &maxval)

Lua: number retval, number minval, number maxval = reaper.TrackFX_GetParam(MediaTrack track, integer fx, integer param)

Python: (Float retval, MediaTrack track, Int fx, Int param, Float minvalOut, Float maxvalOut) = RPR_TrackFX_GetParam(track, fx, param, minvalOut, maxvalOut)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_GetParameterStepSizes(MediaTrack* track, int fx, int param, double* stepOut, double* smallstepOut, double* largestepOut, bool* istoggleOut)

EEL2: bool TrackFX_GetParameterStepSizes(MediaTrack track, int fx, int param, &step, &smallstep, &largestep, bool &istoggle)

Lua: boolean retval, number step, number smallstep, number largestep, boolean istoggle = reaper.TrackFX_GetParameterStepSizes(MediaTrack track, integer fx, integer param)

Python: (Boolean retval, MediaTrack track, Int fx, Int param, Float stepOut, Float smallstepOut, Float largestepOut, Boolean istoggleOut) = RPR_TrackFX_GetParameterStepSizes(track, fx, param, stepOut, smallstepOut, largestepOut, istoggleOut)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: double TrackFX_GetParamEx(MediaTrack* track, int fx, int param, double* minvalOut, double* maxvalOut, double* midvalOut)

EEL2: double TrackFX_GetParamEx(MediaTrack track, int fx, int param, &minval, &maxval, &midval)

Lua: number retval, number minval, number maxval, number midval = reaper.TrackFX_GetParamEx(MediaTrack track, integer fx, integer param)

Python: (Float retval, MediaTrack track, Int fx, Int param, Float minvalOut, Float maxvalOut, Float midvalOut) = RPR_TrackFX_GetParamEx(track, fx, param, minvalOut, maxvalOut, midvalOut)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TrackFX_GetParamFromIdent(MediaTrack* track, int fx, const char* ident_str)

EEL2: int TrackFX_GetParamFromIdent(MediaTrack track, int fx, "ident_str")

Lua: integer reaper.TrackFX_GetParamFromIdent(MediaTrack track, integer fx, string ident_str)

Python: Int RPR_TrackFX_GetParamFromIdent(MediaTrack track, Int fx, String ident_str)

gets the parameter index from an identifying string (:wet, :bypass, :delta, or a string returned from GetParamIdent), or -1 if unknown. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_GetParamIdent(MediaTrack* track, int fx, int param, char* bufOut, int bufOut_sz)

EEL2: bool TrackFX_GetParamIdent(MediaTrack track, int fx, int param, #buf)

Lua: boolean retval, string buf = reaper.TrackFX_GetParamIdent(MediaTrack track, integer fx, integer param)

Python: (Boolean retval, MediaTrack track, Int fx, Int param, String bufOut, Int bufOut_sz) = RPR_TrackFX_GetParamIdent(track, fx, param, bufOut, bufOut_sz)

gets an identifying string for the parameter FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_GetParamName(MediaTrack* track, int fx, int param, char* bufOut, int bufOut_sz)

EEL2: bool TrackFX_GetParamName(MediaTrack track, int fx, int param, #buf)

Lua: boolean retval, string buf = reaper.TrackFX_GetParamName(MediaTrack track, integer fx, integer param)

Python: (Boolean retval, MediaTrack track, Int fx, Int param, String bufOut, Int bufOut_sz) = RPR_TrackFX_GetParamName(track, fx, param, bufOut, bufOut_sz)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: double TrackFX_GetParamNormalized(MediaTrack* track, int fx, int param)

EEL2: double TrackFX_GetParamNormalized(MediaTrack track, int fx, int param)

Lua: number reaper.TrackFX_GetParamNormalized(MediaTrack track, integer fx, integer param)

Python: Float RPR_TrackFX_GetParamNormalized(MediaTrack track, Int fx, Int param)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TrackFX_GetPinMappings(MediaTrack* tr, int fx, int isoutput, int pin, int* high32Out)

EEL2: int TrackFX_GetPinMappings(MediaTrack tr, int fx, int isoutput, int pin, int &high32)

Lua: integer retval, integer high32 = reaper.TrackFX_GetPinMappings(MediaTrack tr, integer fx, integer isoutput, integer pin)

Python: (Int retval, MediaTrack tr, Int fx, Int isoutput, Int pin, Int high32Out) = RPR_TrackFX_GetPinMappings(tr, fx, isoutput, pin, high32Out)

gets the effective channel mapping bitmask for a particular pin. high32Out will be set to the high 32 bits. Add 0x1000000 to pin index in order to access the second 64 bits of mappings independent of the first 64 bits. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_GetPreset(MediaTrack* track, int fx, char* presetnameOut, int presetnameOut_sz)

EEL2: bool TrackFX_GetPreset(MediaTrack track, int fx, #presetname)

Lua: boolean retval, string presetname = reaper.TrackFX_GetPreset(MediaTrack track, integer fx)

Python: (Boolean retval, MediaTrack track, Int fx, String presetnameOut, Int presetnameOut_sz) = RPR_TrackFX_GetPreset(track, fx, presetnameOut, presetnameOut_sz)

Get the name of the preset currently showing in the REAPER dropdown, or the full path to a factory preset file for VST3 plug-ins (.vstpreset). See TrackFX_SetPreset. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TrackFX_GetPresetIndex(MediaTrack* track, int fx, int* numberOfPresetsOut)

EEL2: int TrackFX_GetPresetIndex(MediaTrack track, int fx, int &numberOfPresets)

Lua: integer retval, integer numberOfPresets = reaper.TrackFX_GetPresetIndex(MediaTrack track, integer fx)

Python: (Int retval, MediaTrack track, Int fx, Int numberOfPresetsOut) = RPR_TrackFX_GetPresetIndex(track, fx, numberOfPresetsOut)

Returns current preset index, or -1 if error. numberOfPresetsOut will be set to total number of presets available. See TrackFX_SetPresetByIndex FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: int TrackFX_GetRecChainVisible(MediaTrack* track)

EEL2: int TrackFX_GetRecChainVisible(MediaTrack track)

Lua: integer reaper.TrackFX_GetRecChainVisible(MediaTrack track)

Python: Int RPR_TrackFX_GetRecChainVisible(MediaTrack track)

returns index of effect visible in record input chain, or -1 for chain hidden, or -2 for chain visible but no effect selected



C: int TrackFX_GetRecCount(MediaTrack* track)

EEL2: int TrackFX_GetRecCount(MediaTrack track)

Lua: integer reaper.TrackFX_GetRecCount(MediaTrack track)

Python: Int RPR_TrackFX_GetRecCount(MediaTrack track)

returns count of record input FX. To access record input FX, use a FX indices [0x1000000..0x1000000+n). On the master track, this accesses monitoring FX rather than record input FX.



C: void TrackFX_GetUserPresetFilename(MediaTrack* track, int fx, char* fnOut, int fnOut_sz)

EEL2: TrackFX_GetUserPresetFilename(MediaTrack track, int fx, #fn)

Lua: string fn = reaper.TrackFX_GetUserPresetFilename(MediaTrack track, integer fx)

Python: (MediaTrack track, Int fx, String fnOut, Int fnOut_sz) = RPR_TrackFX_GetUserPresetFilename(track, fx, fnOut, fnOut_sz)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_NavigatePresets(MediaTrack* track, int fx, int presetmove)

EEL2: bool TrackFX_NavigatePresets(MediaTrack track, int fx, int presetmove)

Lua: boolean reaper.TrackFX_NavigatePresets(MediaTrack track, integer fx, integer presetmove)

Python: Boolean RPR_TrackFX_NavigatePresets(MediaTrack track, Int fx, Int presetmove)

presetmove==1 activates the next preset, presetmove==-1 activates the previous preset, etc. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TrackFX_SetEnabled(MediaTrack* track, int fx, bool enabled)

EEL2: TrackFX_SetEnabled(MediaTrack track, int fx, bool enabled)

Lua: reaper.TrackFX_SetEnabled(MediaTrack track, integer fx, boolean enabled)

Python: RPR_TrackFX_SetEnabled(MediaTrack track, Int fx, Boolean enabled)

See TrackFX_GetEnabled FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_SetEQBandEnabled(MediaTrack* track, int fxidx, int bandtype, int bandidx, bool enable)

EEL2: bool TrackFX_SetEQBandEnabled(MediaTrack track, int fxidx, int bandtype, int bandidx, bool enable)

Lua: boolean reaper.TrackFX_SetEQBandEnabled(MediaTrack track, integer fxidx, integer bandtype, integer bandidx, boolean enable)

Python: Boolean RPR_TrackFX_SetEQBandEnabled(MediaTrack track, Int fxidx, Int bandtype, Int bandidx, Boolean enable)

Enable or disable a ReaEQ band.
Returns false if track/fxidx is not ReaEQ.
Bandtype: -1=master gain, 0=hipass, 1=loshelf, 2=band, 3=notch, 4=hishelf, 5=lopass, 6=bandpass, 7=parallel bandpass.
Bandidx (ignored for master gain): 0=target first band matching bandtype, 1=target 2nd band matching bandtype, etc.

See TrackFX_GetEQ, TrackFX_GetEQParam, TrackFX_SetEQParam, TrackFX_GetEQBandEnabled. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_SetEQParam(MediaTrack* track, int fxidx, int bandtype, int bandidx, int paramtype, double val, bool isnorm)

EEL2: bool TrackFX_SetEQParam(MediaTrack track, int fxidx, int bandtype, int bandidx, int paramtype, val, bool isnorm)

Lua: boolean reaper.TrackFX_SetEQParam(MediaTrack track, integer fxidx, integer bandtype, integer bandidx, integer paramtype, number val, boolean isnorm)

Python: Boolean RPR_TrackFX_SetEQParam(MediaTrack track, Int fxidx, Int bandtype, Int bandidx, Int paramtype, Float val, Boolean isnorm)

Returns false if track/fxidx is not ReaEQ. Targets a band matching bandtype.
Bandtype: -1=master gain, 0=hipass, 1=loshelf, 2=band, 3=notch, 4=hishelf, 5=lopass, 6=bandpass, 7=parallel bandpass.
Bandidx (ignored for master gain): 0=target first band matching bandtype, 1=target 2nd band matching bandtype, etc.
Paramtype (ignored for master gain): 0=freq, 1=gain, 2=Q.
See TrackFX_GetEQ, TrackFX_GetEQParam, TrackFX_GetEQBandEnabled, TrackFX_SetEQBandEnabled. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_SetNamedConfigParm(MediaTrack* track, int fx, const char* parmname, const char* value)

EEL2: bool TrackFX_SetNamedConfigParm(MediaTrack track, int fx, "parmname", "value")

Lua: boolean reaper.TrackFX_SetNamedConfigParm(MediaTrack track, integer fx, string parmname, string value)

Python: Boolean RPR_TrackFX_SetNamedConfigParm(MediaTrack track, Int fx, String parmname, String value)

sets plug-in specific named configuration value (returns true on success).

Support values for write:
vst_chunk[_program] : base64-encoded VST-specific chunk.
clap_chunk : base64-encoded CLAP-specific chunk.
param.X.lfo.[active,dir,phase,speed,strength,temposync,free,shape] : parameter moduation LFO state
param.X.acs.[active,dir,strength,attack,release,dblo,dbhi,chan,stereo,x2,y2] : parameter modulation ACS state
param.X.plink.[active,scale,offset,effect,param,midi_bus,midi_chan,midi_msg,midi_msg2] : parameter link/MIDI link: set effect=-100 to support midi_*
param.X.mod.[active,baseline,visible] : parameter module global settings
param.X.learn.[midi1,midi2,osc] : first two bytes of MIDI message, or OSC string if set
param.X.learn.mode : absolution/relative mode flag (0: Absolute, 1: 127=-1,1=+1, 2: 63=-1, 65=+1, 3: 65=-1, 1=+1, 4: toggle if nonzero)
param.X.learn.flags : &1=selected track only, &2=soft takeover, &4=focused FX only, &8=LFO retrigger, &16=visible FX only
param.X.container_map.fx_index : index of FX contained in container
param.X.container_map.fx_parm : parameter index of parameter of FX contained in container
param.X.container_map.aliased_name : name of parameter (if user-renamed, otherwise fails)
BANDTYPEx, BANDENABLEDx : band configuration [ReaEQ]
THRESHOLD, CEILING, TRUEPEAK : [ReaLimit]
NUMCHANNELS, NUMSPEAKERS, RESETCHANNELS : [ReaSurroundPan]
ITEMx : [ReaVerb] state configuration line, when writing should be followed by a write of DONE
FILE, FILEx, -FILEx, +FILEx, -FILE* : [RS5k] file list, -/+ prefixes are write-only, when writing any, should be followed by a write of DONE
MODE, RSMODE : [RS5k] general mode, resample mode
VIDEO_CODE : [video processor] code
force_auto_bypass : 0 or 1 - force auto-bypass plug-in on silence
parallel : 0, 1 or 2 - 1=process plug-in in parallel with previous, 2=process plug-in parallel and merge MIDI
instance_oversample_shift : instance oversampling shift amount, 0=none, 1=~96k, 2=~192k, etc. When setting requires playback stop/start to take effect
chain_oversample_shift : chain oversampling shift amount, 0=none, 1=~96k, 2=~192k, etc. When setting requires playback stop/start to take effect
chain_pdc_mode : chain PDC mode (0=classic, 1=new-default, 2=ignore PDC, 3=hwcomp-master)
chain_sel : selected/visible FX in chain
renamed_name : renamed FX instance name (empty string = not renamed)
container_nch : number of internal channels for container
container_nch_in : number of input pins for container
container_nch_out : number of output pints for container
container_nch_feedback : number of internal feedback channels enabled in container
focused : reading returns 1 if focused. Writing a positive value to this sets the FX UI as "last focused."
last_touched : reading returns two integers, one indicates whether FX is the last-touched FX, the second indicates which parameter was last touched. Writing a negative value ensures this plug-in is not set as last touched, otherwise the FX is set "last touched," and last touched parameter index is set to the value in the string (if valid).
FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TrackFX_SetOffline(MediaTrack* track, int fx, bool offline)

EEL2: TrackFX_SetOffline(MediaTrack track, int fx, bool offline)

Lua: reaper.TrackFX_SetOffline(MediaTrack track, integer fx, boolean offline)

Python: RPR_TrackFX_SetOffline(MediaTrack track, Int fx, Boolean offline)

See TrackFX_GetOffline FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TrackFX_SetOpen(MediaTrack* track, int fx, bool open)

EEL2: TrackFX_SetOpen(MediaTrack track, int fx, bool open)

Lua: reaper.TrackFX_SetOpen(MediaTrack track, integer fx, boolean open)

Python: RPR_TrackFX_SetOpen(MediaTrack track, Int fx, Boolean open)

Open this FX UI. See TrackFX_GetOpen FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_SetParam(MediaTrack* track, int fx, int param, double val)

EEL2: bool TrackFX_SetParam(MediaTrack track, int fx, int param, val)

Lua: boolean reaper.TrackFX_SetParam(MediaTrack track, integer fx, integer param, number val)

Python: Boolean RPR_TrackFX_SetParam(MediaTrack track, Int fx, Int param, Float val)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_SetParamNormalized(MediaTrack* track, int fx, int param, double value)

EEL2: bool TrackFX_SetParamNormalized(MediaTrack track, int fx, int param, value)

Lua: boolean reaper.TrackFX_SetParamNormalized(MediaTrack track, integer fx, integer param, number value)

Python: Boolean RPR_TrackFX_SetParamNormalized(MediaTrack track, Int fx, Int param, Float value)

FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_SetPinMappings(MediaTrack* tr, int fx, int isoutput, int pin, int low32bits, int hi32bits)

EEL2: bool TrackFX_SetPinMappings(MediaTrack tr, int fx, int isoutput, int pin, int low32bits, int hi32bits)

Lua: boolean reaper.TrackFX_SetPinMappings(MediaTrack tr, integer fx, integer isoutput, integer pin, integer low32bits, integer hi32bits)

Python: Boolean RPR_TrackFX_SetPinMappings(MediaTrack tr, Int fx, Int isoutput, Int pin, Int low32bits, Int hi32bits)

sets the channel mapping bitmask for a particular pin. returns false if unsupported (not all types of plug-ins support this capability). Add 0x1000000 to pin index in order to access the second 64 bits of mappings independent of the first 64 bits. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_SetPreset(MediaTrack* track, int fx, const char* presetname)

EEL2: bool TrackFX_SetPreset(MediaTrack track, int fx, "presetname")

Lua: boolean reaper.TrackFX_SetPreset(MediaTrack track, integer fx, string presetname)

Python: Boolean RPR_TrackFX_SetPreset(MediaTrack track, Int fx, String presetname)

Activate a preset with the name shown in the REAPER dropdown. Full paths to .vstpreset files are also supported for VST3 plug-ins. See TrackFX_GetPreset. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: bool TrackFX_SetPresetByIndex(MediaTrack* track, int fx, int idx)

EEL2: bool TrackFX_SetPresetByIndex(MediaTrack track, int fx, int idx)

Lua: boolean reaper.TrackFX_SetPresetByIndex(MediaTrack track, integer fx, integer idx)

Python: Boolean RPR_TrackFX_SetPresetByIndex(MediaTrack track, Int fx, Int idx)

Sets the preset idx, or the factory preset (idx==-2), or the default user preset (idx==-1). Returns true on success. See TrackFX_GetPresetIndex. FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TrackFX_Show(MediaTrack* track, int index, int showFlag)

EEL2: TrackFX_Show(MediaTrack track, int index, int showFlag)

Lua: reaper.TrackFX_Show(MediaTrack track, integer index, integer showFlag)

Python: RPR_TrackFX_Show(MediaTrack track, Int index, Int showFlag)

showflag=0 for hidechain, =1 for show chain(index valid), =2 for hide floating window(index valid), =3 for show floating window (index valid) FX indices for tracks can have 0x1000000 added to them in order to reference record input FX (normal tracks) or hardware output FX (master track). FX indices can have 0x2000000 added to them, in which case they will be used to address FX in containers. To address a container, the 1-based subitem is multiplied by one plus the count of the FX chain and added to the 1-based container item index. e.g. to address the third item in the container at the second position of the track FX chain for tr, the index would be 0x2000000 + 3*(TrackFX_GetCount(tr)+1) + 2. This can be extended to sub-containers using TrackFX_GetNamedConfigParm with container_count and similar logic. In REAPER v7.06+, you can use the much more convenient method to navigate hierarchies, see TrackFX_GetNamedConfigParm with parent_container and container_item.X.



C: void TrackList_AdjustWindows(bool isMinor)

EEL2: TrackList_AdjustWindows(bool isMinor)

Lua: reaper.TrackList_AdjustWindows(boolean isMinor)

Python: RPR_TrackList_AdjustWindows(Boolean isMinor)



C: void TrackList_UpdateAllExternalSurfaces()

EEL2: TrackList_UpdateAllExternalSurfaces()

Lua: reaper.TrackList_UpdateAllExternalSurfaces()

Python: RPR_TrackList_UpdateAllExternalSurfaces()



C: void Undo_BeginBlock()

EEL2: Undo_BeginBlock()

Lua: reaper.Undo_BeginBlock()

Python: RPR_Undo_BeginBlock()

call to start a new block



C: void Undo_BeginBlock2(ReaProject* proj)

EEL2: Undo_BeginBlock2(ReaProject proj)

Lua: reaper.Undo_BeginBlock2(ReaProject proj)

Python: RPR_Undo_BeginBlock2(ReaProject proj)

call to start a new block



C: const char* Undo_CanRedo2(ReaProject* proj)

EEL2: bool Undo_CanRedo2(#retval, ReaProject proj)

Lua: string reaper.Undo_CanRedo2(ReaProject proj)

Python: String RPR_Undo_CanRedo2(ReaProject proj)

returns string of next action,if able,NULL if not



C: const char* Undo_CanUndo2(ReaProject* proj)

EEL2: bool Undo_CanUndo2(#retval, ReaProject proj)

Lua: string reaper.Undo_CanUndo2(ReaProject proj)

Python: String RPR_Undo_CanUndo2(ReaProject proj)

returns string of last action,if able,NULL if not



C: int Undo_DoRedo2(ReaProject* proj)

EEL2: int Undo_DoRedo2(ReaProject proj)

Lua: integer reaper.Undo_DoRedo2(ReaProject proj)

Python: Int RPR_Undo_DoRedo2(ReaProject proj)

nonzero if success



C: int Undo_DoUndo2(ReaProject* proj)

EEL2: int Undo_DoUndo2(ReaProject proj)

Lua: integer reaper.Undo_DoUndo2(ReaProject proj)

Python: Int RPR_Undo_DoUndo2(ReaProject proj)

nonzero if success



C: void Undo_EndBlock(const char* descchange, int extraflags)

EEL2: Undo_EndBlock("descchange", int extraflags)

Lua: reaper.Undo_EndBlock(string descchange, integer extraflags)

Python: RPR_Undo_EndBlock(String descchange, Int extraflags)

call to end the block,with extra flags if any,and a description



C: void Undo_EndBlock2(ReaProject* proj, const char* descchange, int extraflags)

EEL2: Undo_EndBlock2(ReaProject proj, "descchange", int extraflags)

Lua: reaper.Undo_EndBlock2(ReaProject proj, string descchange, integer extraflags)

Python: RPR_Undo_EndBlock2(ReaProject proj, String descchange, Int extraflags)

call to end the block,with extra flags if any,and a description



C: void Undo_OnStateChange(const char* descchange)

EEL2: Undo_OnStateChange("descchange")

Lua: reaper.Undo_OnStateChange(string descchange)

Python: RPR_Undo_OnStateChange(String descchange)

limited state change to items



C: void Undo_OnStateChange2(ReaProject* proj, const char* descchange)

EEL2: Undo_OnStateChange2(ReaProject proj, "descchange")

Lua: reaper.Undo_OnStateChange2(ReaProject proj, string descchange)

Python: RPR_Undo_OnStateChange2(ReaProject proj, String descchange)

limited state change to items



C: void Undo_OnStateChange_Item(ReaProject* proj, const char* name, MediaItem* item)

EEL2: Undo_OnStateChange_Item(ReaProject proj, "name", MediaItem item)

Lua: reaper.Undo_OnStateChange_Item(ReaProject proj, string name, MediaItem item)

Python: RPR_Undo_OnStateChange_Item(ReaProject proj, String name, MediaItem item)



C: void Undo_OnStateChangeEx(const char* descchange, int whichStates, int trackparm)

EEL2: Undo_OnStateChangeEx("descchange", int whichStates, int trackparm)

Lua: reaper.Undo_OnStateChangeEx(string descchange, integer whichStates, integer trackparm)

Python: RPR_Undo_OnStateChangeEx(String descchange, Int whichStates, Int trackparm)

trackparm=-1 by default,or if updating one fx chain,you can specify track index



C: void Undo_OnStateChangeEx2(ReaProject* proj, const char* descchange, int whichStates, int trackparm)

EEL2: Undo_OnStateChangeEx2(ReaProject proj, "descchange", int whichStates, int trackparm)

Lua: reaper.Undo_OnStateChangeEx2(ReaProject proj, string descchange, integer whichStates, integer trackparm)

Python: RPR_Undo_OnStateChangeEx2(ReaProject proj, String descchange, Int whichStates, Int trackparm)

trackparm=-1 by default,or if updating one fx chain,you can specify track index



C: void UpdateArrange()

EEL2: UpdateArrange()

Lua: reaper.UpdateArrange()

Python: RPR_UpdateArrange()

Redraw the arrange view



C: void UpdateItemInProject(MediaItem* item)

EEL2: UpdateItemInProject(MediaItem item)

Lua: reaper.UpdateItemInProject(MediaItem item)

Python: RPR_UpdateItemInProject(MediaItem item)



C: bool UpdateItemLanes(ReaProject* proj)

EEL2: bool UpdateItemLanes(ReaProject proj)

Lua: boolean reaper.UpdateItemLanes(ReaProject proj)

Python: Boolean RPR_UpdateItemLanes(ReaProject proj)

Recalculate lane arrangement for fixed lane tracks, including auto-removing empty lanes at the bottom of the track



C: void UpdateTimeline()

EEL2: UpdateTimeline()

Lua: reaper.UpdateTimeline()

Python: RPR_UpdateTimeline()

Redraw the arrange view and ruler



C: bool ValidatePtr(void* pointer, const char* ctypename)

EEL2: bool ValidatePtr(void* pointer, "ctypename")

Lua: boolean reaper.ValidatePtr(identifier pointer, string ctypename)

Python: Boolean RPR_ValidatePtr(void pointer, String ctypename)

see ValidatePtr2



C: bool ValidatePtr2(ReaProject* proj, void* pointer, const char* ctypename)

EEL2: bool ValidatePtr2(ReaProject proj, void* pointer, "ctypename")

Lua: boolean reaper.ValidatePtr2(ReaProject proj, identifier pointer, string ctypename)

Python: Boolean RPR_ValidatePtr2(ReaProject proj, void pointer, String ctypename)

Return true if the pointer is a valid object of the right type in proj (proj is ignored if pointer is itself a project). Supported types are: ReaProject*, MediaTrack*, MediaItem*, MediaItem_Take*, TrackEnvelope* and PCM_source*.



C: void ViewPrefs(int page, const char* pageByName)

EEL2: ViewPrefs(int page, "pageByName")

Lua: reaper.ViewPrefs(integer page, string pageByName)

Python: RPR_ViewPrefs(Int page, String pageByName)

Opens the prefs to a page, use pageByName if page is 0.





ReaScript/EEL2 Built-in Function List



EEL2: abs(value)

Returns the absolute value of the parameter.



EEL2: acos(value)

Returns the arc cosine of the value specified (return value is in radians). If the parameter is not between -1.0 and 1.0 inclusive, the return value is undefined.



EEL2: asin(value)

Returns the arc sine of the value specified (return value is in radians). If the parameter is not between -1.0 and 1.0 inclusive, the return value is undefined.



EEL2: atan(value)

Returns the arc tangent of the value specified (return value is in radians). If the parameter is not between -1.0 and 1.0 inclusive, the return value is undefined.



EEL2: atan2(numerator,denominator)

Returns the arc tangent of the numerator divided by the denominator, allowing the denominator to be 0, and using their signs to produce a more meaningful result.



EEL2: atexit("code")

Adds code to be executed when the script finishes or is ended by the user. Typically used to clean up after the user terminates defer() or runloop() code.



EEL2: ceil(value)

Returns the value rounded to the next highest integer (ceil(3.1)==4, ceil(-3.9)==-3).



EEL2: convolve_c(dest,src,size)

Multiplies each of size complex pairs in dest by the complex pairs in src. Often used for convolution.



EEL2: cos(angle)

Returns the cosine of the angle specified (specified in radians).



EEL2: defer("code")

Adds code to be called back by REAPER. Used to create persistent ReaScripts that continue to run and respond to input, while the user does other tasks. Identical to runloop().
Note that no undo point will be automatically created when the script finishes, unless you create it explicitly.



EEL2: eval("code")

Executes code passed in. Code can use functions, but functions created in code can't be used elsewhere.



EEL2: exp(exponent)

Returns the number e ($e, approximately 2.718) raised to the parameter-th power. This function is significantly faster than pow() or the ^ operator.



EEL2: extension_api("function_name"[,...])

Used to call functions exported by extension plugins. The first parameter must be the exported function name, then its own parameters (as if the function was called directly).



EEL2: fclose(fp)

Closes a file previously opened with fopen().



EEL2: feof(fp)

Returns nonzero if the file fp is at the end of file.



EEL2: fflush(fp)

If file fp is open for writing, flushes out any buffered data to disk.



EEL2: fft(buffer,size)

Performs a FFT on the data in the local memory buffer at the offset specified by the first parameter. The size of the FFT is specified by the second parameter, which must be 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, or 32768. The outputs are permuted, so if you plan to use them in-order, call fft_permute(buffer, size) before and fft_ipermute(buffer,size) after your in-order use. Your inputs or outputs will need to be scaled down by 1/size, if used.
Note that fft()/ifft() require real / imaginary input pairs, so a 256 point FFT actually works with 512 items.
Note that fft()/ifft() must NOT cross a 65,536 item boundary, so be sure to specify the offset accordingly.



EEL2: fft_ipermute(buffer,size)

Permute the input for ifft(), taking bands from in-order to the order ifft() requires. See fft() for more information.



EEL2: fft_permute(buffer,size)

Permute the output of fft() to have bands in-order. See fft() for more information.



EEL2: fft_real(buffer,size)

Performs an FFT, but takes size input samples and produces size/2 complex output pairs. Usually used along with fft_permute(size/2). Inputs/outputs will need to be scaled by 0.5/size.



EEL2: fgetc(fp)

Reads a character from file fp, returns -1 if EOF.



EEL2: fgets(fp,#str)

Reads a line from file fp into #str. Returns length of #str read.



EEL2: floor(value)

Returns the value rounded to the next lowest integer (floor(3.9)==3, floor(-3.1)==-4).



EEL2: fopen("fn","mode")

Opens a file "fn" with mode "mode". For read, use "r" or "rb", write "w" or "wb". Returns a positive integer on success.



EEL2: fprintf(fp,"format"[,...])

Formats a string and writes it to file fp. For more information on format specifiers, see sprintf(). Returns bytes written to file.



EEL2: fread(fp,#str,length)

Reads from file fp into #str, up to length bytes. Returns actual length read, or negative if error.



EEL2: freembuf(address)

Hints the runtime that memory above the address specified may no longer be used. The runtime may, at its leisure, choose to lose the contents of memory above the address specified.



EEL2: fseek(fp,offset,whence)

Seeks file fp, offset bytes from whence reference. Whence negative specifies start of file, positive whence specifies end of file, and zero whence specifies current file position.



EEL2: ftell(fp)

Retunrs the current file position.



EEL2: fwrite(fp,#str,len)

Writes up to len characters of #str to file fp. If len is less than 1, the full contents of #str will be written. Returns the number of bytes written to file.



EEL2: get_action_context(#filename,sectionID,cmdID,mode,resolution,val,contextstr)

Queries contextual information about the script, typically MIDI/OSC input values.
Returns true if a new value has been updated.
val will be set to a relative or absolute value depending on mode (=0: absolute mode, >0: relative modes).
resolution=127 for 7-bit resolution, =16383 for 14-bit resolution.
sectionID, and cmdID will be set to -1 if the script is not part of the action list.
mode, resolution and val will be set to -1 if the script was not triggered via MIDI/OSC.
contextstr may be empty or one of:(flags may include V=virtkey, S=shift, A=alt/option, C=control/command, W=win/control)




EEL2: gfx VARIABLES

The following global variables are special and will be used by the graphics system:





EEL2: gfx_arc(x,y,r,ang1,ang2[,antialias])

Draws an arc of the circle centered at x,y, with ang1/ang2 being specified in radians.



EEL2: gfx_blit(source[, scale, rotation, srcx, srcy, srcw, srch, destx, desty, destw, desth, rotxoffs, rotyoffs])

Copies from source (-1 = main framebuffer, or an image from gfx_loadimg() etc), using current opacity and copy mode (set with gfx_a, gfx_mode).
If destx/desty are not specified, gfx_x/gfx_y will be used as the destination position.
scale (1.0 is unscaled) will be used only if destw/desth are not specified.
rotation is an angle in radians
srcx/srcy/srcw/srch specify the source rectangle (if omitted srcw/srch default to image size)
destx/desty/destw/desth specify destination rectangle (if not specified destw/desth default to srcw/srch * scale).



EEL2: gfx_blitext(source,coordinatelist,rotation)

Deprecated, use gfx_blit instead.



EEL2: gfx_blurto(x,y)

Blurs the region of the screen between gfx_x,gfx_y and x,y, and updates gfx_x,gfx_y to x,y.



EEL2: gfx_circle(x,y,r[,fill,antialias])

Draws a circle, optionally filling/antialiasing.



EEL2: gfx_clienttoscreen(x,y)

Converts client coordinates x,y to screen coordinates.



EEL2: gfx_deltablit(srcimg,srcs,srct,srcw,srch,destx,desty,destw,desth,dsdx,dtdx,dsdy,dtdy,dsdxdy,dtdxdy[,usecliprect=1])

Blits from srcimg(srcx,srcy,srcw,srch) to destination (destx,desty,destw,desth). Source texture coordinates are s/t, dsdx represents the change in s coordinate for each x pixel, dtdy represents the change in t coordinate for each y pixel, etc. dsdxdy represents the change in dsdx for each line. If usecliprect is specified and 0, then srcw/srch are ignored.



EEL2: gfx_dock(v[,wx,wy,ww,wh])

Call with v=-1 to query docked state, otherwise v>=0 to set docked state. State is &1 if docked, second byte is docker index (or last docker index if undocked). If wx-wh are specified, they will be filled with the undocked window position/size



EEL2: gfx_drawchar(char)

Draws the character (can be a numeric ASCII code as well), to gfx_x, gfx_y, and moves gfx_x over by the size of the character.



EEL2: gfx_drawnumber(n,ndigits)

Draws the number n with ndigits of precision to gfx_x, gfx_y, and updates gfx_x to the right side of the drawing. The text height is gfx_texth.



EEL2: gfx_drawstr("str"[,flags,right,bottom])

Draws a string at gfx_x, gfx_y, and updates gfx_x/gfx_y so that subsequent draws will occur in a similar place.

If flags, right ,bottom passed in:
  • flags&1: center horizontally
  • flags&2: right justify
  • flags&4: center vertically
  • flags&8: bottom justify
  • flags&256: ignore right/bottom, otherwise text is clipped to (gfx_x, gfx_y, right, bottom)



    EEL2: gfx_getchar([char, unichar])

    If char is 0 or omitted, returns a character from the keyboard queue, or 0 if no character is available, or -1 if the graphics window is not open. If char is specified and nonzero, that character's status will be checked, and the function will return greater than 0 if it is pressed. Note that calling gfx_getchar() at least once causes mouse_cap to reflect keyboard modifiers even when the mouse is not captured.

    Common values are standard ASCII, such as 'a', 'A', '=' and '1', but for many keys multi-byte values are used, including 'home', 'up', 'down', 'left', 'rght', 'f1'.. 'f12', 'pgup', 'pgdn', 'ins', and 'del'.

    Modified and special keys can also be returned, including:



    EEL2: gfx_getdropfile(idx[,#str])

    Enumerates any drag/dropped files. call gfx_dropfile(-1) to clear the list when finished. Returns 1 if idx is valid, 0 if idx is out of range.



    EEL2: gfx_getfont([#str])

    Returns current font index. If a string is passed, it will receive the actual font face used by this font, if available.



    EEL2: gfx_getimgdim(image,w,h)

    Retreives the dimensions of image (representing a filename: index number) into w and h. Sets these values to 0 if an image failed loading (or if the filename index is invalid).



    EEL2: gfx_getpixel(r,g,b)

    Gets the value of the pixel at gfx_x,gfx_y into r,g,b.



    EEL2: gfx_gradrect(x,y,w,h, r,g,b,a[, drdx, dgdx, dbdx, dadx, drdy, dgdy, dbdy, dady])

    Fills a gradient rectangle with the color and alpha specified. drdx-dadx reflect the adjustment (per-pixel) applied for each pixel moved to the right, drdy-dady are the adjustment applied for each pixel moved toward the bottom. Normally drdx=adjustamount/w, drdy=adjustamount/h, etc.



    EEL2: gfx_init("name"[,width,height,dockstate,xpos,ypos])

    Initializes the graphics window with title name. Suggested width and height can be specified. If window is already open, a non-empty name will re-title window, or an empty title will resize window.

    Once the graphics window is open, gfx_update() should be called periodically.



    EEL2: gfx_line(x,y,x2,y2[,aa])

    Draws a line from x,y to x2,y2, and if aa is not specified or 0.5 or greater, it will be antialiased.



    EEL2: gfx_lineto(x,y[,aa])

    Draws a line from gfx_x,gfx_y to x,y. If aa is 0.5 or greater, then antialiasing is used. Updates gfx_x and gfx_y to x,y.



    EEL2: gfx_loadimg(image,"filename")

    Load image from filename into slot 0..1024-1 specified by image. Returns the image index if success, otherwise -1 if failure. The image will be resized to the dimensions of the image file.



    EEL2: gfx_measurechar(character,&w,&h)

    Measures the drawing dimensions of a character with the current font (as set by gfx_setfont).



    EEL2: gfx_measurestr("str",&w,&h)

    Measures the drawing dimensions of a string with the current font (as set by gfx_setfont).



    EEL2: gfx_muladdrect(x,y,w,h,mul_r,mul_g,mul_b[,mul_a,add_r,add_g,add_b,add_a])

    Multiplies each pixel by mul_* and adds add_*, and updates in-place. Useful for changing brightness/contrast, or other effects.



    EEL2: gfx_printf("format"[, ...])

    Formats and draws a string at gfx_x, gfx_y, and updates gfx_x/gfx_y accordingly (the latter only if the formatted string contains newline). For more information on format strings, see sprintf()



    EEL2: gfx_quit()

    Closes the graphics window.



    EEL2: gfx_rect(x,y,w,h[,filled])

    Fills a rectangle at x,y, w,h pixels in dimension, filled by default.



    EEL2: gfx_rectto(x,y)

    Fills a rectangle from gfx_x,gfx_y to x,y. Updates gfx_x,gfx_y to x,y.



    EEL2: gfx_roundrect(x,y,w,h,radius[,antialias])

    Draws a rectangle with rounded corners.



    EEL2: gfx_screentoclient(x,y)

    Converts screen coordinates x,y to client coordinates.



    EEL2: gfx_set(r[,g,b,a,mode,dest,a2])

    Sets gfx_r/gfx_g/gfx_b/gfx_a/gfx_mode/gfx_a2, sets gfx_dest if final parameter specified



    EEL2: gfx_setcursor(resource_id,custom_cursor_name)

    Specify 0 resource_id and custom_cursor_name from https://www.reaper.fm/sdk/cursors/cursors.php (e.g. 'arrow') to set the cursor. Alternatively can specify resource_id for a Windows cursor or built-in REAPER cursor.



    EEL2: gfx_setfont(idx[,"fontface", sz, flags])

    Can select a font and optionally configure it. idx=0 for default bitmapped font, no configuration is possible for this font. idx=1..16 for a configurable font, specify fontface such as "Arial", sz of 8-100, and optionally specify flags, which is a multibyte character, which can include 'i' for italics, 'u' for underline, or 'b' for bold. These flags may or may not be supported depending on the font and OS. After calling gfx_setfont(), gfx_texth may be updated to reflect the new average line height.



    EEL2: gfx_setimgdim(image,w,h)

    Resize image referenced by index 0..1024-1, width and height must be 0-8192. The contents of the image will be undefined after the resize.



    EEL2: gfx_setpixel(r,g,b)

    Writes a pixel of r,g,b to gfx_x,gfx_y.



    EEL2: gfx_showmenu("str")

    Shows a popup menu at gfx_x,gfx_y. str is a list of fields separated by | characters. Each field represents a menu item.
    Fields can start with special characters:

    # : grayed out
    ! : checked
    > : this menu item shows a submenu
    < : last item in the current submenu

    An empty field will appear as a separator in the menu. gfx_showmenu returns 0 if the user selected nothing from the menu, 1 if the first field is selected, etc.
    Example:

    gfx_showmenu("first item, followed by separator||!second item, checked|>third item which spawns a submenu|#first item in submenu, grayed out|<second and last item in submenu|fourth item in top menu")



    EEL2: gfx_transformblit(srcimg,destx,desty,destw,desth,div_w,div_h,table)

    Blits to destination at (destx,desty), size (destw,desth). div_w and div_h should be 2..64, and table should point to a table of 2*div_w*div_h values (this table must not cross a 65536 item boundary). Each pair in the table represents a S,T coordinate in the source image, and the table is treated as a left-right, top-bottom list of texture coordinates, which will then be rendered to the destination.



    EEL2: gfx_triangle(x1,y1,x2,y2,x3,y3[x4,y4...])

    Draws a filled triangle, or any convex polygon.



    EEL2: gfx_update()

    Updates the graphics display, if opened



    EEL2: ifft(buffer,size)

    Perform an inverse FFT. For more information see fft().



    EEL2: ifft_real(buffer,size)

    Performs an inverse FFT, but takes size/2 complex input pairs and produces size real output values. Usually used along with fft_ipermute(size/2).



    EEL2: invsqrt(value)

    Returns a fast inverse square root (1/sqrt(x)) approximation of the parameter.



    EEL2: log(value)

    Returns the natural logarithm (base e) of the parameter. If the value is not greater than 0, the return value is undefined.



    EEL2: log10(value)

    Returns the base-10 logarithm of the parameter. If the value is not greater than 0, the return value is undefined.



    EEL2: loop(count,expression)

    Evaluates count once, and then executes expression count, but not more than 1048576, times.



    EEL2: match("needle","haystack"[, ...])

    Searches for the first parameter in the second parameter, using a simplified regular expression syntax.
    You can also use format specifiers to match certain types of data, and optionally put that into a variable:
    See also sprintf() for other notes, including specifying direct variable references via {}.



    EEL2: matchi("needle","haystack"[, ...])

    Case-insensitive version of match().



    EEL2: max(&value,&value)

    Returns (by reference) the maximum value of the two parameters. Since max() returns by reference, expressions such as max(x,y) = 5 are possible.



    EEL2: mem_get_values(offset, ...)

    Reads values from memory starting at offset into variables specified. Slower than regular memory reads for less than a few variables, faster for more than a few. Undefined behavior if used with more than 32767 variables.



    EEL2: mem_insert_shuffle(buf,len,value)

    Shuffles contents of buf right by 1, inserts value at buf[0], returns previous buf[len-1].



    EEL2: mem_multiply_sum(src1,src2,length)

    Calculates the sum of the products of values pointed to by src1 and src2. If src2 is -1, then calculates the sum of squares of src1, if -2, the sum of the absolute values of src, if -3, calculates the sum of the values of src1. Other negative values are undefined.



    EEL2: mem_set_values(offset, ...)

    Writes values to memory starting at offset from variables specified. Slower than regular memory writes for less than a few variables, faster for more than a few. Undefined behavior if used with more than 32767 variables.



    EEL2: memcpy(dest,src,length)

    Copies length items of memory from src to dest. Regions are permitted to overlap.



    EEL2: memset(offset,value,length)

    Sets length items of memory at offset to value.



    EEL2: min(&value,&value)

    Returns (by reference) the minimum value of the two parameters. Since min() returns by reference, expressions such as min(x,y) = 5 are possible.



    EEL2: printf("format"[, ...])

    Output formatted string to system-specific destination, see sprintf() for more information



    EEL2: rand([max])

    Returns a pseudorandom real number between 0 and the parameter, inclusive. If the parameter is omitted or less than 1.0, 1.0 is used as a maximum instead.



    EEL2: runloop("code")

    Adds code to be called back by REAPER. Used to create persistent ReaScripts that continue to run and respond to input, while the user does other tasks. Identical to defer().
    Note that no undo point will be automatically created when the script finishes, unless you create it explicitly.



    EEL2: set_action_options(flags)

    Sets action options for the script.
    flag&1: script will auto-terminate if re-launched while already running
    flag&2: if (flag&1) is set, script will re-launch after auto-terminating
    flag&4: set script toggle state on
    flag&8: set script toggle state off




    EEL2: sign(value)

    Returns 1.0 if the parameter is greater than 0, -1.0 if the parameter is less than 0, or 0 if the parameter is 0.



    EEL2: sin(angle)

    Returns the sine of the angle specified (specified in radians -- to convert from degrees to radians, multiply by $pi/180, or 0.017453).



    EEL2: sleep(ms)

    Yields the CPU for the millisecond count specified, calling Sleep() on Windows or usleep() on other platforms.



    EEL2: sprintf(#dest,"format"[, ...])

    Formats a string and stores it in #dest. Format specifiers begin with %, and may include:
    Many standard C printf() modifiers can be used, including:
    Values for format specifiers can be specified as additional parameters to sprintf, or within {} in the format specifier (such as %{varname}d, in that case a global variable is always used).



    EEL2: sqr(value)

    Returns the square of the parameter (similar to value*value, but only evaluating value once).



    EEL2: sqrt(value)

    Returns the square root of the parameter. If the parameter is negative, the return value is undefined.



    EEL2: stack_exch(&value)

    Exchanges a value with the top of the stack, and returns a reference to the parameter (with the new value).



    EEL2: stack_peek(index)

    Returns a reference to the item on the top of the stack (if index is 0), or to the Nth item on the stack if index is greater than 0.



    EEL2: stack_pop(&value)

    Pops a value from the user stack into value, or into a temporary buffer if value is not specified, and returns a reference to where the stack was popped. Note that no checking is done to determine if the stack is empty, and as such stack_pop() will never fail.



    EEL2: stack_push(&value)

    Pushes value onto the user stack, returns a reference to the parameter.



    EEL2: str_delsub(#str,pos,len)

    Deletes len characters at offset pos from #str, and returns #str.



    EEL2: str_getchar("str",offset[,type])

    Returns the data at byte-offset offset of str. If offset is negative, position is relative to end of string.type defaults to signed char, but can be specified to read raw binary data in other formats (note the single quotes, these are single/multi-byte characters):



    EEL2: str_insert(#str,"srcstr",pos)

    Inserts srcstr into #str at offset pos. Returns #str



    EEL2: str_setchar(#str,offset,val[,type]))

    Sets value at offset offset, type optional. offset may be negative to refer to offset relative to end of string, or between 0 and length, inclusive, and if set to length it will lengthen string. See str_getchar() for more information on types.



    EEL2: str_setlen(#str,len)

    Sets length of #str (if increasing, will be space-padded), and returns #str.



    EEL2: strcat(#str,"srcstr")

    Appends srcstr to #str, and returns #str



    EEL2: strcmp("str","str2")

    Compares strings, returning 0 if equal



    EEL2: strcpy(#str,"srcstr")

    Copies the contents of srcstr to #str, and returns #str



    EEL2: strcpy_from(#str,"srcstr",offset)

    Copies srcstr to #str, but starts reading srcstr at offset offset



    EEL2: strcpy_substr(#str,"srcstr",offs,ml))

    PHP-style (start at offs, offs<0 means from end, ml for maxlen, ml<0 = reduce length by this amt)



    EEL2: stricmp("str","str2")

    Compares strings ignoring case, returning 0 if equal



    EEL2: strlen("str")

    Returns the length of the string passed as a parameter



    EEL2: strncat(#str,"srcstr",maxlen)

    Appends srcstr to #str, stopping after maxlen characters of srcstr. Returns #str.



    EEL2: strncmp("str","str2",maxlen)

    Compares strings giving up after maxlen characters, returning 0 if equal



    EEL2: strncpy(#str,"srcstr",maxlen)

    Copies srcstr to #str, stopping after maxlen characters. Returns #str.



    EEL2: strnicmp("str","str2",maxlen)

    Compares strings giving up after maxlen characters, ignoring case, returning 0 if equal



    EEL2: tan(angle)

    Returns the tangent of the angle specified (specified in radians).



    EEL2: tcp_close(connection)

    Closes a TCP connection created by tcp_listen() or tcp_connect().



    EEL2: tcp_connect("address",port[,block])

    Create a new TCP connection to address:port. If block is specified and 0, connection will be made nonblocking. Returns TCP connection ID greater than 0 on success.



    EEL2: tcp_listen(port[,"interface",#ip_out])

    Listens on port specified. Returns less than 0 if could not listen, 0 if no new connection available, or greater than 0 (as a TCP connection ID) if a new connection was made. If a connection made and #ip_out specified, it will be set to the remote IP. interface can be empty for all interfaces, otherwise an interface IP as a string.



    EEL2: tcp_listen_end(port)

    Ends listening on port specified.



    EEL2: tcp_recv(connection,#str[,maxlen])

    Receives data from a connection to #str. If maxlen is specified, no more than maxlen bytes will be received. If non-blocking, 0 will be returned if would block. Returns less than 0 if error.



    EEL2: tcp_send(connection,"str"[,len])

    Sends a string to connection. Returns -1 on error, 0 if connection is non-blocking and would block, otherwise returns length sent. If len is specified and not less than 1, only the first len bytes of the string parameter will be sent.



    EEL2: tcp_set_block(connection,block)

    Sets whether a connection blocks.



    EEL2: time([&val])

    Sets the parameter (or a temporary buffer if omitted) to the number of seconds since January 1, 1970, and returns a reference to that value. The granularity of the value returned is 1 second.



    EEL2: time_precise([&val])

    Sets the parameter (or a temporary buffer if omitted) to a system-local timestamp in seconds, and returns a reference to that value. The granularity of the value returned is system defined (but generally significantly smaller than one second).



    EEL2: while(expression)

    Executes expression until expression evaluates to zero, or until 1048576iterations occur. An alternate and more useful syntax is while (expression) ( statements ), which evaluates statements after every non-zero evaluation of expression.





  • ReaScript/Lua Built-In Function list



    Lua: reaper.atexit(function)

    Adds code to be executed when the script finishes or is ended by the user. Typically used to clean up after the user terminates defer() or runloop() code.



    Lua: reaper.defer(function)

    Adds code to be called back by REAPER. Used to create persistent ReaScripts that continue to run and respond to input, while the user does other tasks. Identical to runloop().
    Note that no undo point will be automatically created when the script finishes, unless you create it explicitly.



    Lua: reaper.get_action_context()

    is_new_value,filename,sectionID,cmdID,mode,resolution,val,contextstr = reaper.get_action_context()
    Returns contextual information about the script, typically MIDI/OSC input values.
    val will be set to a relative or absolute value depending on mode (=0: absolute mode, >0: relative modes).
    resolution=127 for 7-bit resolution, =16383 for 14-bit resolution.
    sectionID, and cmdID will be set to -1 if the script is not part of the action list.
    mode, resolution and val will be set to -1 if the script was not triggered via MIDI/OSC.
    contextstr may be empty or one of:(flags may include V=virtkey, S=shift, A=alt/option, C=control/command, W=win/control)




    Lua: gfx VARIABLES

    The following global variables are special and will be used by the graphics system:





    Lua: gfx.arc(x,y,r,ang1,ang2[,antialias])

    Draws an arc of the circle centered at x,y, with ang1/ang2 being specified in radians.



    Lua: gfx.blit(source[, scale, rotation, srcx, srcy, srcw, srch, destx, desty, destw, desth, rotxoffs, rotyoffs])

    Copies from source (-1 = main framebuffer, or an image from gfx.loadimg() etc), using current opacity and copy mode (set with gfx.a, gfx.mode).
    If destx/desty are not specified, gfx.x/gfx.y will be used as the destination position.
    scale (1.0 is unscaled) will be used only if destw/desth are not specified.
    rotation is an angle in radians
    srcx/srcy/srcw/srch specify the source rectangle (if omitted srcw/srch default to image size)
    destx/desty/destw/desth specify destination rectangle (if not specified destw/desth default to srcw/srch * scale).



    Lua: gfx.blitext(source,coordinatelist,rotation)

    Deprecated, use gfx.blit instead.



    Lua: gfx.blurto(x,y)

    Blurs the region of the screen between gfx.x,gfx.y and x,y, and updates gfx.x,gfx.y to x,y.



    Lua: gfx.circle(x,y,r[,fill,antialias])

    Draws a circle, optionally filling/antialiasing.



    Lua: gfx.clienttoscreen(x,y)

    Converts the coordinates x,y to screen coordinates, returns those values.



    Lua: gfx.deltablit(srcimg,srcs,srct,srcw,srch,destx,desty,destw,desth,dsdx,dtdx,dsdy,dtdy,dsdxdy,dtdxdy[,usecliprect=1])

    Blits from srcimg(srcx,srcy,srcw,srch) to destination (destx,desty,destw,desth). Source texture coordinates are s/t, dsdx represents the change in s coordinate for each x pixel, dtdy represents the change in t coordinate for each y pixel, etc. dsdxdy represents the change in dsdx for each line. If usecliprect is specified and 0, then srcw/srch are ignored.



    Lua: gfx.dock(v[,wx,wy,ww,wh])

    Call with v=-1 to query docked state, otherwise v>=0 to set docked state. State is &1 if docked, second byte is docker index (or last docker index if undocked). If wx-wh specified, additional values will be returned with the undocked window position/size



    Lua: gfx.drawchar(char)

    Draws the character (can be a numeric ASCII code as well), to gfx.x, gfx.y, and moves gfx.x over by the size of the character.



    Lua: gfx.drawnumber(n,ndigits)

    Draws the number n with ndigits of precision to gfx.x, gfx.y, and updates gfx.x to the right side of the drawing. The text height is gfx.texth.



    Lua: gfx.drawstr("str"[,flags,right,bottom])

    Draws a string at gfx.x, gfx.y, and updates gfx.x/gfx.y so that subsequent draws will occur in a similar place.

    If flags, right ,bottom passed in:
  • flags&1: center horizontally
  • flags&2: right justify
  • flags&4: center vertically
  • flags&8: bottom justify
  • flags&256: ignore right/bottom, otherwise text is clipped to (gfx.x, gfx.y, right, bottom)



    Lua: gfx.getchar([char, unichar])

    If char is 0 or omitted, returns a character from the keyboard queue, or 0 if no character is available, or -1 if the graphics window is not open. If char is specified and nonzero, that character's status will be checked, and the function will return greater than 0 if it is pressed. Note that calling gfx.getchar() at least once causes gfx.mouse_cap to reflect keyboard modifiers even when the mouse is not captured.

    Common values are standard ASCII, such as 'a', 'A', '=' and '1', but for many keys multi-byte values are used, including 'home', 'up', 'down', 'left', 'rght', 'f1'.. 'f12', 'pgup', 'pgdn', 'ins', and 'del'.

    Modified and special keys can also be returned, including:



    Lua: gfx.getdropfile(idx)

    Returns success,string for dropped file index idx. call gfx.dropfile(-1) to clear the list when finished.



    Lua: gfx.getfont()

    Returns current font index, and the actual font face used by this font (if available).



    Lua: gfx.getimgdim(handle)

    Retreives the dimensions of an image specified by handle, returns w, h pair.



    Lua: gfx.getpixel()

    Returns r,g,b values [0..1] of the pixel at (gfx.x,gfx.y)



    Lua: gfx.gradrect(x,y,w,h, r,g,b,a[, drdx, dgdx, dbdx, dadx, drdy, dgdy, dbdy, dady])

    Fills a gradient rectangle with the color and alpha specified. drdx-dadx reflect the adjustment (per-pixel) applied for each pixel moved to the right, drdy-dady are the adjustment applied for each pixel moved toward the bottom. Normally drdx=adjustamount/w, drdy=adjustamount/h, etc.



    Lua: gfx.init("name"[,width,height,dockstate,xpos,ypos])

    Initializes the graphics window with title name. Suggested width and height can be specified. If window is already open, a non-empty name will re-title window, or an empty title will resize window.

    Once the graphics window is open, gfx.update() should be called periodically.



    Lua: gfx.line(x,y,x2,y2[,aa])

    Draws a line from x,y to x2,y2, and if aa is not specified or 0.5 or greater, it will be antialiased.



    Lua: gfx.lineto(x,y[,aa])

    Draws a line from gfx.x,gfx.y to x,y. If aa is 0.5 or greater, then antialiasing is used. Updates gfx.x and gfx.y to x,y.



    Lua: gfx.loadimg(image,"filename")

    Load image from filename into slot 0..1024-1 specified by image. Returns the image index if success, otherwise -1 if failure. The image will be resized to the dimensions of the image file.



    Lua: gfx.measurechar(char)

    Measures the drawing dimensions of a character with the current font (as set by gfx.setfont). Returns width and height of character.



    Lua: gfx.measurestr("str")

    Measures the drawing dimensions of a string with the current font (as set by gfx.setfont). Returns width and height of string.



    Lua: gfx.muladdrect(x,y,w,h,mul_r,mul_g,mul_b[,mul_a,add_r,add_g,add_b,add_a])

    Multiplies each pixel by mul_* and adds add_*, and updates in-place. Useful for changing brightness/contrast, or other effects.



    Lua: gfx.printf("format"[, ...])

    Formats and draws a string at gfx.x, gfx.y, and updates gfx.x/gfx.y accordingly (the latter only if the formatted string contains newline). For more information on format strings, see sprintf()



    Lua: gfx.quit()

    Closes the graphics window.



    Lua: gfx.rect(x,y,w,h[,filled])

    Fills a rectangle at x,y, w,h pixels in dimension, filled by default.



    Lua: gfx.rectto(x,y)

    Fills a rectangle from gfx.x,gfx.y to x,y. Updates gfx.x,gfx.y to x,y.



    Lua: gfx.roundrect(x,y,w,h,radius[,antialias])

    Draws a rectangle with rounded corners.



    Lua: gfx.screentoclient(x,y)

    Converts the screen coordinates x,y to client coordinates, returns those values.



    Lua: gfx.set(r[,g,b,a,mode,dest,a2])

    Sets gfx.r/gfx.g/gfx.b/gfx.a/gfx.mode/gfx.a2, sets gfx.dest if final parameter specified



    Lua: gfx.setcursor(resource_id,custom_cursor_name)

    Sets the mouse cursor to resource_id and/or custom_cursor_name.



    Lua: gfx.setfont(idx[,"fontface", sz, flags])

    Can select a font and optionally configure it. idx=0 for default bitmapped font, no configuration is possible for this font. idx=1..16 for a configurable font, specify fontface such as "Arial", sz of 8-100, and optionally specify flags, which is a multibyte character, which can include 'i' for italics, 'u' for underline, or 'b' for bold. These flags may or may not be supported depending on the font and OS. After calling gfx.setfont(), gfx.texth may be updated to reflect the new average line height.



    Lua: gfx.setimgdim(image,w,h)

    Resize image referenced by index 0..1024-1, width and height must be 0-8192. The contents of the image will be undefined after the resize.



    Lua: gfx.setpixel(r,g,b)

    Writes a pixel of r,g,b to gfx.x,gfx.y.



    Lua: gfx.showmenu("str")

    Shows a popup menu at gfx.x,gfx.y. str is a list of fields separated by | characters. Each field represents a menu item.
    Fields can start with special characters:

    # : grayed out
    ! : checked
    > : this menu item shows a submenu
    < : last item in the current submenu

    An empty field will appear as a separator in the menu. gfx.showmenu returns 0 if the user selected nothing from the menu, 1 if the first field is selected, etc.
    Example:

    gfx.showmenu("first item, followed by separator||!second item, checked|>third item which spawns a submenu|#first item in submenu, grayed out|<second and last item in submenu|fourth item in top menu")



    Lua: gfx.transformblit(srcimg,destx,desty,destw,desth,div_w,div_h,table)

    Blits to destination at (destx,desty), size (destw,desth). div_w and div_h should be 2..64, and table should point to a table of 2*div_w*div_h values (table can be a regular table or (for less overhead) a reaper.array). Each pair in the table represents a S,T coordinate in the source image, and the table is treated as a left-right, top-bottom list of texture coordinates, which will then be rendered to the destination.



    Lua: gfx.triangle(x1,y1,x2,y2,x3,y3[x4,y4...])

    Draws a filled triangle, or any convex polygon.



    Lua: gfx.update()

    Updates the graphics display, if opened



    Lua: reaper.gmem_attach(sharedMemoryName)

    Causes gmem_read()/gmem_write() to read EEL2/JSFX/Video shared memory segment named by parameter. Set to empty string to detach. 6.20+: returns previous shared memory segment name.



    Lua: reaper.gmem_read(index)

    Read (number) value from shared memory attached-to by gmem_attach(). index can be [0..1<<25).



    Lua: reaper.gmem_write(index,value)

    Write (number) value to shared memory attached-to by gmem_attach(). index can be [0..1<<25).



    Lua: reaper.new_array([table|array][size])

    Creates a new reaper.array object of maximum and initial size size, if specified, or from the size/values of a table/array. Both size and table/array can be specified, the size parameter will override the table/array size.



    Lua: reaper.runloop(function)

    Adds code to be called back by REAPER. Used to create persistent ReaScripts that continue to run and respond to input, while the user does other tasks. Identical to defer().
    Note that no undo point will be automatically created when the script finishes, unless you create it explicitly.



    Lua: reaper.set_action_options(flag)

    reaper.set_action_options(flag)
    Sets action options for the script.
    flag&1: script will auto-terminate if re-launched while already running
    flag&2: if (flag&1) is set, script will re-launch after auto-terminating
    flag&4: set script toggle state on
    flag&8: set script toggle state off




    Lua: {reaper.array}.clear([value, offset, size])

    Sets the value of zero or more items in the array. If value not specified, 0.0 is used. offset is 1-based, if size omitted then the maximum amount available will be set.



    Lua: {reaper.array}.convolve([src, srcoffs, size, destoffs])

    Convolves complex value pairs from reaper.array, starting at 1-based srcoffs, reading/writing to 1-based destoffs. size is in normal items (so it must be even)



    Lua: {reaper.array}.copy([src, srcoffs, size, destoffs])

    Copies values from reaper.array or table, starting at 1-based srcoffs, writing to 1-based destoffs.



    Lua: {reaper.array}.fft(size[, permute, offset])

    Performs a forward FFT of size. size must be a power of two between 4 and 32768 inclusive. If permute is specified and true, the values will be shuffled following the FFT to be in normal order.



    Lua: {reaper.array}.fft_real(size[, permute, offset])

    Performs a forward real->complex FFT of size. size must be a power of two between 4 and 32768 inclusive. If permute is specified and true, the values will be shuffled following the FFT to be in normal order.



    Lua: {reaper.array}.get_alloc()

    Returns the maximum (allocated) size of the array.



    Lua: {reaper.array}.ifft(size[, permute, offset])

    Performs a backwards FFT of size. size must be a power of two between 4 and 32768 inclusive. If permute is specified and true, the values will be shuffled before the IFFT to be in fft-order.



    Lua: {reaper.array}.ifft_real(size[, permute, offset])

    Performs a backwards complex->real FFT of size. size must be a power of two between 4 and 32768 inclusive. If permute is specified and true, the values will be shuffled before the IFFT to be in fft-order.



    Lua: {reaper.array}.multiply([src, srcoffs, size, destoffs])

    Multiplies values from reaper.array, starting at 1-based srcoffs, reading/writing to 1-based destoffs.



    Lua: {reaper.array}.resize(size)

    Resizes an array object to size. size must be [0..max_size].



    Lua: {reaper.array}.table([offset, size])

    Returns a new table with values from items in the array. Offset is 1-based and if size is omitted all available values are used.





  • ReaScript/Python Built-In Function list



    Python: RPR_atexit(String)

    Adds code to be executed when the script finishes or is ended by the user. Typically used to clean up after the user terminates defer() or runloop() code.



    Python: RPR_defer(String code)

    Adds code to be called back by REAPER. Used to create persistent ReaScripts that continue to run and respond to input, while the user does other tasks. Identical to runloop().
    Note that no undo point will be automatically created when the script finishes, unless you create it explicitly.



    Python: RPR_runloop(String code)

    Adds code to be called back by REAPER. Used to create persistent ReaScripts that continue to run and respond to input, while the user does other tasks. Identical to defer().
    Note that no undo point will be automatically created when the script finishes, unless you create it explicitly.

    View: [all] [C/C++] [EEL2] [Lua] [Python]