linuxsampler 2.3.1
LinuxSampler::MidiInputPort Class Reference

#include <MidiInputPort.h>

Classes

class  ParameterName
 MIDI Port Parameter 'NAME'. More...
 

Public Member Functions

void Connect (EngineChannel *pEngineChannel, midi_chan_t MidiChannel)
 Connect given sampler engine channel with this MIDI input device.
 
void Disconnect (EngineChannel *pEngineChannel)
 Disconnect given sampler engine channel from this MIDI input device.
 
MidiInputDeviceGetDevice ()
 Return MIDI device where this MIDI port belongs to.
 
uint GetPortNumber ()
 Return port number with which this MIDI port is registered to the MIDI device.
 
std::map< String, DeviceRuntimeParameter * > PortParameters ()
 Return all parameter settings of this MIDI port.
 
void Connect (VirtualMidiDevice *pDevice)
 Connects the given virtual MIDI device to this MIDI input device.
 
void Disconnect (VirtualMidiDevice *pDevice)
 Disconnect the previously connected virtual MIDI device.
 
void SetNoteOnVelocityFilter (const std::vector< uint8_t > &filter)
 Registers the given filter to be applied against all note on events, adjusting their MIDI velocity data.
 
void DispatchNoteOn (uint8_t Key, uint8_t Velocity, uint MidiChannel)
 Should be called by the implementing MIDI input device whenever a note on event arrived, this will cause the note on event to be forwarded to all connected engines on the corresponding MIDI channel.
 
void DispatchNoteOn (uint8_t Key, uint8_t Velocity, uint MidiChannel, int32_t FragmentPos)
 Should be called by the implementing MIDI input device whenever a note on event arrived, this will cause the note on event to be forwarded to all connected engines on the corresponding MIDI channel.
 
void DispatchNoteOff (uint8_t Key, uint8_t Velocity, uint MidiChannel)
 Should be called by the implementing MIDI input device whenever a note off event arrived, this will cause the note off event to be forwarded to all connected engines on the corresponding MIDI channel.
 
void DispatchNoteOff (uint8_t Key, uint8_t Velocity, uint MidiChannel, int32_t FragmentPos)
 Should be called by the implementing MIDI input device whenever a note off event arrived, this will cause the note off event to be forwarded to all connected engines on the corresponding MIDI channel.
 
void DispatchPitchbend (int Pitch, uint MidiChannel)
 Should be called by the implementing MIDI input device whenever a pitchbend event arrived, this will cause the pitchbend event to be forwarded to all connected engines.
 
void DispatchPitchbend (int Pitch, uint MidiChannel, int32_t FragmentPos)
 Should be called by the implementing MIDI input device whenever a pitchbend event arrived, this will cause the pitchbend event to be forwarded to all connected engines.
 
void DispatchControlChange (uint8_t Controller, uint8_t Value, uint MidiChannel)
 Should be called by the implementing MIDI input device whenever a control change event arrived, this will cause the control change event to be forwarded to all engines on the corresponding MIDI channel.
 
void DispatchControlChange (uint8_t Controller, uint8_t Value, uint MidiChannel, int32_t FragmentPos)
 Should be called by the implementing MIDI input device whenever a control change event arrived, this will cause the control change event to be forwarded to all engines on the corresponding MIDI channel.
 
void DispatchChannelPressure (uint8_t Value, uint MidiChannel)
 Should be called by the implementing MIDI input device whenever a channel pressure event arrived (a.k.a.
 
void DispatchChannelPressure (uint8_t Value, uint MidiChannel, int32_t FragmentPos)
 Should be called by the implementing MIDI input device whenever a channel pressure event arrived (a.k.a.
 
void DispatchPolyphonicKeyPressure (uint8_t Key, uint8_t Value, uint MidiChannel)
 Should be called by the implementing MIDI input device whenever a polyphonic key pressure event arrived (a.k.a.
 
void DispatchPolyphonicKeyPressure (uint8_t Key, uint8_t Value, uint MidiChannel, int32_t FragmentPos)
 Should be called by the implementing MIDI input device whenever a polyphonic key pressure event arrived (a.k.a.
 
void DispatchProgramChange (uint8_t Program, uint MidiChannel)
 Should be called by the implementing MIDI input device whenever a program change event arrived.
 
void DispatchBankSelectMsb (uint8_t BankMsb, uint MidiChannel)
 Should be called by the implementing MIDI input device whenever a MIDI bank select MSB (Most Significant Byte) event arrived.
 
void DispatchBankSelectLsb (uint8_t BankLsb, uint MidiChannel)
 Should be called by the implementing MIDI input device whenever a MIDI bank select LSB (Least Significant Byte) event arrived.
 
void DispatchSysex (void *pData, uint Size)
 Should be called by the implementing MIDI input device whenever a system exclusive message arrived, this will cause the message to be forwarded to all connected engines.
 
void DispatchRaw (uint8_t *pData)
 Helper function for MIDI input devices that have the MIDI data as raw bytes.
 
void DispatchRaw (uint8_t *pData, int32_t FragmentPos)
 Helper function for MIDI input devices that have the MIDI data as raw bytes.
 

Static Public Member Functions

static void AddSysexListener (Engine *engine)
 Registers that an engine wants to have sysex messages.
 
static bool RemoveSysexListener (Engine *engine)
 Removes engine from list of engines getting sysex messages.
 

Protected Types

typedef std::set< EngineChannel * > MidiChannelMap_t[17]
 

Protected Member Functions

 MidiInputPort (MidiInputDevice *pDevice, int portNumber)
 Constructor.
 
virtual ~MidiInputPort ()
 Destructor.
 
int expectedEventSize (unsigned char byte)
 Takes a MIDI status byte (the first byte of each MIDI event) as argument and returns the expected size of the associated MIDI event according to the MIDI protocol.
 

Protected Attributes

MidiInputDevicepDevice
 
int portNumber
 
std::map< String, DeviceRuntimeParameter * > Parameters
 All port parameters.
 
SynchronizedConfig< MidiChannelMap_tMidiChannelMap
 Contains the list of connected engines for each MIDI channel, where index 0 points to the list of engines which are connected to all MIDI channels. Usually it's not necessary for the descendant to use this map, instead it should just use the Dispatch* methods.
 
SynchronizedConfig< MidiChannelMap_t >::Reader MidiChannelMapReader
 MIDI thread access to MidiChannelMap.
 
Mutex MidiChannelMapMutex
 Used to protect the MidiChannelMap from being used at the same time by different threads.
 
SynchronizedConfig< std::set< Engine * > >::Reader SysexListenersReader
 MIDI thread access to SysexListeners.
 
SynchronizedConfig< std::vector< VirtualMidiDevice * > > virtualMidiDevices
 
SynchronizedConfig< std::vector< VirtualMidiDevice * > >::Reader virtualMidiDevicesReader
 
Mutex virtualMidiDevicesMutex
 
SynchronizedConfig< std::vector< uint8_t > > noteOnVelocityFilter
 
SynchronizedConfig< std::vector< uint8_t > >::Reader noteOnVelocityFilterReader
 
Mutex noteOnVelocityFilterMutex
 
uint8_t runningStatusBuf [3]
 

Friends

class MidiInputDevice
 

Detailed Description

Definition at line 43 of file MidiInputPort.h.

Member Typedef Documentation

◆ MidiChannelMap_t

typedef std::set<EngineChannel*> LinuxSampler::MidiInputPort::MidiChannelMap_t[17]
protected

Definition at line 471 of file MidiInputPort.h.

Constructor & Destructor Documentation

◆ MidiInputPort()

LinuxSampler::MidiInputPort::MidiInputPort ( MidiInputDevice pDevice,
int  portNumber 
)
protected

Constructor.

◆ ~MidiInputPort()

virtual LinuxSampler::MidiInputPort::~MidiInputPort ( )
protectedvirtual

Destructor.

Member Function Documentation

◆ AddSysexListener()

static void LinuxSampler::MidiInputPort::AddSysexListener ( Engine engine)
static

Registers that an engine wants to have sysex messages.

◆ Connect() [1/2]

void LinuxSampler::MidiInputPort::Connect ( EngineChannel pEngineChannel,
midi_chan_t  MidiChannel 
)

Connect given sampler engine channel with this MIDI input device.

The engine channel can either be connected to one specific MIDI channel or all MIDI channels. If an engine channel gets connected twice to this MIDI input device, then the engine's old connection will be detached (no matter on which MIDI channel).

Parameters
pEngineChannel- sampler engine
MidiChannel- MIDI channel to connect to
Exceptions
MidiInputExceptionif MidiChannel argument invalid

◆ Connect() [2/2]

void LinuxSampler::MidiInputPort::Connect ( VirtualMidiDevice pDevice)

Connects the given virtual MIDI device to this MIDI input device.

This can be used to listen to MIDI data arriving on the MIDI input device's MIDI ports, e.g. to show an MIDI activity indicator somewhere.

◆ Disconnect() [1/2]

void LinuxSampler::MidiInputPort::Disconnect ( EngineChannel pEngineChannel)

Disconnect given sampler engine channel from this MIDI input device.

If the given engine channel was not connected with this device, nothing happens.

Parameters
pEngineChannel- sampler engine

◆ Disconnect() [2/2]

void LinuxSampler::MidiInputPort::Disconnect ( VirtualMidiDevice pDevice)

Disconnect the previously connected virtual MIDI device.

◆ DispatchBankSelectLsb()

void LinuxSampler::MidiInputPort::DispatchBankSelectLsb ( uint8_t  BankLsb,
uint  MidiChannel 
)

Should be called by the implementing MIDI input device whenever a MIDI bank select LSB (Least Significant Byte) event arrived.

In case the respective sampler channel(s) are enabled for "MIDI instrument mapping", a subsequent MIDI program change event can be used to let the respective sampler engine load another instrument according to the respective entry in the MIDI instrument map.

MIDI sources can either a) just send bank select MSB events, or b) just send bank select LSB events or c) they can send both bank select MSB and LSB events. The sampler will automatically detect which style the MIDI source is using and appropriately interpret it for selecting the appropriate bank.

Parameters
BankMsb- Most Significant Byte of the bank number
MidiChannel- MIDI channel on which this bank select occurred

◆ DispatchBankSelectMsb()

void LinuxSampler::MidiInputPort::DispatchBankSelectMsb ( uint8_t  BankMsb,
uint  MidiChannel 
)

Should be called by the implementing MIDI input device whenever a MIDI bank select MSB (Most Significant Byte) event arrived.

In case the respective sampler channel(s) are enabled for "MIDI instrument mapping", a subsequent MIDI program change event can be used to let the respective sampler engine load another instrument according to the respective entry in the MIDI instrument map.

MIDI sources can either a) just send bank select MSB events, or b) just send bank select LSB events or c) they can send both bank select MSB and LSB events. The sampler will automatically detect which style the MIDI source is using and appropriately interpret it for selecting the appropriate bank.

Parameters
BankMsb- Most Significant Byte of the bank number
MidiChannel- MIDI channel on which this bank select occurred

◆ DispatchChannelPressure() [1/2]

void LinuxSampler::MidiInputPort::DispatchChannelPressure ( uint8_t  Value,
uint  MidiChannel 
)

Should be called by the implementing MIDI input device whenever a channel pressure event arrived (a.k.a.

aftertouch), this will cause the channel pressure event to be forwarded to all engines on the corresponding MIDI channel.

This method is meant for realtime rendering, this way an event is immediately created with the current system time as time stamp.

Parameters
Value- MIDI channel pressure value (0..127)
MidiChannel- MIDI channel on which event occured on (low level indexing, means 0..15)
See also
DispatchPolyphonicKeyPressure()

◆ DispatchChannelPressure() [2/2]

void LinuxSampler::MidiInputPort::DispatchChannelPressure ( uint8_t  Value,
uint  MidiChannel,
int32_t  FragmentPos 
)

Should be called by the implementing MIDI input device whenever a channel pressure event arrived (a.k.a.

aftertouch), this will cause the channel pressure event to be forwarded to all engines on the corresponding MIDI channel.

This method is meant for offline rendering and / or in case the exact fragment position of the event is already known.

Parameters
Value- MIDI channel pressure value (0..127)
MidiChannel- MIDI channel on which event occured on (low level indexing, means 0..15)
FragmentPos- event's sample point position in the current audio fragment
See also
DispatchPolyphonicKeyPressure()

◆ DispatchControlChange() [1/2]

void LinuxSampler::MidiInputPort::DispatchControlChange ( uint8_t  Controller,
uint8_t  Value,
uint  MidiChannel 
)

Should be called by the implementing MIDI input device whenever a control change event arrived, this will cause the control change event to be forwarded to all engines on the corresponding MIDI channel.

This method is meant for realtime rendering, this way an event is immediately created with the current system time as time stamp.

Parameters
Controller- MIDI controller number
Value- MIDI control change value
MidiChannel- MIDI channel on which event occured on (low level indexing, means 0..15)

◆ DispatchControlChange() [2/2]

void LinuxSampler::MidiInputPort::DispatchControlChange ( uint8_t  Controller,
uint8_t  Value,
uint  MidiChannel,
int32_t  FragmentPos 
)

Should be called by the implementing MIDI input device whenever a control change event arrived, this will cause the control change event to be forwarded to all engines on the corresponding MIDI channel.

This method is meant for offline rendering and / or in case the exact fragment position of the event is already known.

Parameters
Controller- MIDI controller number
Value- MIDI control change value
MidiChannel- MIDI channel on which event occured on (low level indexing, means 0..15)
FragmentPos- event's sample point position in the current audio fragment

◆ DispatchNoteOff() [1/2]

void LinuxSampler::MidiInputPort::DispatchNoteOff ( uint8_t  Key,
uint8_t  Velocity,
uint  MidiChannel 
)

Should be called by the implementing MIDI input device whenever a note off event arrived, this will cause the note off event to be forwarded to all connected engines on the corresponding MIDI channel.

This method is meant for realtime rendering, this way an event is immediately created with the current system time as time stamp.

Parameters
Key- MIDI key number of the released key
Velocity- MIDI velocity of the released key
MidiChannel- MIDI channel on which event occured on (low level indexing, means 0..15)

◆ DispatchNoteOff() [2/2]

void LinuxSampler::MidiInputPort::DispatchNoteOff ( uint8_t  Key,
uint8_t  Velocity,
uint  MidiChannel,
int32_t  FragmentPos 
)

Should be called by the implementing MIDI input device whenever a note off event arrived, this will cause the note off event to be forwarded to all connected engines on the corresponding MIDI channel.

This method is meant for offline rendering and / or in case the exact fragment position of the event is already known.

Parameters
Key- MIDI key number of the released key
Velocity- MIDI velocity of the released key
MidiChannel- MIDI channel on which event occured on (low level indexing, means 0..15)
FragmentPos- event's sample point position in the current audio fragment

◆ DispatchNoteOn() [1/2]

void LinuxSampler::MidiInputPort::DispatchNoteOn ( uint8_t  Key,
uint8_t  Velocity,
uint  MidiChannel 
)

Should be called by the implementing MIDI input device whenever a note on event arrived, this will cause the note on event to be forwarded to all connected engines on the corresponding MIDI channel.

This method is meant for realtime rendering, this way an event is immediately created with the current system time as time stamp.

Parameters
Key- MIDI key number of the triggered key
Velocity- MIDI velocity of the triggered key
MidiChannel- MIDI channel on which event occured on (low level indexing, means 0..15)

◆ DispatchNoteOn() [2/2]

void LinuxSampler::MidiInputPort::DispatchNoteOn ( uint8_t  Key,
uint8_t  Velocity,
uint  MidiChannel,
int32_t  FragmentPos 
)

Should be called by the implementing MIDI input device whenever a note on event arrived, this will cause the note on event to be forwarded to all connected engines on the corresponding MIDI channel.

This method is meant for offline rendering and / or in case the exact fragment position of the event is already known.

Parameters
Key- MIDI key number of the triggered key
Velocity- MIDI velocity of the triggered key
MidiChannel- MIDI channel on which event occured on (low level indexing, means 0..15)
FragmentPos- event's sample point position in the current audio fragment

◆ DispatchPitchbend() [1/2]

void LinuxSampler::MidiInputPort::DispatchPitchbend ( int  Pitch,
uint  MidiChannel 
)

Should be called by the implementing MIDI input device whenever a pitchbend event arrived, this will cause the pitchbend event to be forwarded to all connected engines.

This method is meant for realtime rendering, this way an event is immediately created with the current system time as time stamp.

Parameters
Pitch- MIDI pitch value
MidiChannel- MIDI channel on which event occured on (low level indexing, means 0..15)

◆ DispatchPitchbend() [2/2]

void LinuxSampler::MidiInputPort::DispatchPitchbend ( int  Pitch,
uint  MidiChannel,
int32_t  FragmentPos 
)

Should be called by the implementing MIDI input device whenever a pitchbend event arrived, this will cause the pitchbend event to be forwarded to all connected engines.

This method is meant for offline rendering and / or in case the exact fragment position of the event is already known.

Parameters
Pitch- MIDI pitch value
MidiChannel- MIDI channel on which event occured on (low level indexing, means 0..15)
FragmentPos- event's sample point position in the current audio fragment

◆ DispatchPolyphonicKeyPressure() [1/2]

void LinuxSampler::MidiInputPort::DispatchPolyphonicKeyPressure ( uint8_t  Key,
uint8_t  Value,
uint  MidiChannel 
)

Should be called by the implementing MIDI input device whenever a polyphonic key pressure event arrived (a.k.a.

polyphonic aftertouch), this will cause the polyphonic key pressure event to be forwarded to all engines on the corresponding MIDI channel.

This method is meant for realtime rendering, this way an event is immediately created with the current system time as time stamp.

Parameters
Key- MIDI key number of the key where pressure changed
Value- MIDI key pressure value (0..127)
MidiChannel- MIDI channel on which event occured on (low level indexing, means 0..15)
See also
DispatchChannelPressure()

◆ DispatchPolyphonicKeyPressure() [2/2]

void LinuxSampler::MidiInputPort::DispatchPolyphonicKeyPressure ( uint8_t  Key,
uint8_t  Value,
uint  MidiChannel,
int32_t  FragmentPos 
)

Should be called by the implementing MIDI input device whenever a polyphonic key pressure event arrived (a.k.a.

polyphonic aftertouch), this will cause the polyphonic key pressure event to be forwarded to all engines on the corresponding MIDI channel.

This method is meant for offline rendering and / or in case the exact fragment position of the event is already known.

Parameters
Key- MIDI key number of the key where pressure changed
Value- MIDI key pressure value (0..127)
MidiChannel- MIDI channel on which event occured on (low level indexing, means 0..15)
FragmentPos- event's sample point position in the current audio fragment
See also
DispatchChannelPressure()

◆ DispatchProgramChange()

void LinuxSampler::MidiInputPort::DispatchProgramChange ( uint8_t  Program,
uint  MidiChannel 
)

Should be called by the implementing MIDI input device whenever a program change event arrived.

In case the respective sampler channel(s) are enabled for MIDI instrument mapping, the respective sampler engine and instrument will be loaded on the connected sampler channel(s) as defined by the respective entry in the MIDI instrument map.

Note: the MIDI instrument map is empty by default on sampler startup. It has to be explicitly filled with entries and the sampler channel(s) have to be enabled for a certain MIDI instrument table, otherwise program change messages are ignored!

Parameters
Program- MIDI program change number
MidiChannel- MIDI channel on which this program change occured
See also
MidiInstrumentMapper

◆ DispatchRaw() [1/2]

void LinuxSampler::MidiInputPort::DispatchRaw ( uint8_t pData)

Helper function for MIDI input devices that have the MIDI data as raw bytes.

Parameters
pData- pointer to the raw MIDI data

◆ DispatchRaw() [2/2]

void LinuxSampler::MidiInputPort::DispatchRaw ( uint8_t pData,
int32_t  FragmentPos 
)

Helper function for MIDI input devices that have the MIDI data as raw bytes.

Parameters
pData- pointer to the raw MIDI data
FragmentPos- event's sample point position in the current audio fragment

◆ DispatchSysex()

void LinuxSampler::MidiInputPort::DispatchSysex ( void pData,
uint  Size 
)

Should be called by the implementing MIDI input device whenever a system exclusive message arrived, this will cause the message to be forwarded to all connected engines.

Parameters
pData- pointer to the sysex data
Size- length of the sysex data (in bytes)

◆ expectedEventSize()

int LinuxSampler::MidiInputPort::expectedEventSize ( unsigned char  byte)
protected

Takes a MIDI status byte (the first byte of each MIDI event) as argument and returns the expected size of the associated MIDI event according to the MIDI protocol.

Returns -1 on invalid status bytes AND on variable size events (SysEx events).

This method can be used for drivers which have to deal with raw MIDI data, like the CoreMIDI driver, which can receive MIDI packets with more than one event per packet.

This method handles "MIDI running status" as well. That is, in case the supplied byte is not a status byte but a data byte, it expects the event to be in "running status" and accordingly uses the status byte of the previous event (processed by the Dispatch*() methods).

◆ GetDevice()

MidiInputDevice * LinuxSampler::MidiInputPort::GetDevice ( )

Return MIDI device where this MIDI port belongs to.

◆ GetPortNumber()

uint LinuxSampler::MidiInputPort::GetPortNumber ( )

Return port number with which this MIDI port is registered to the MIDI device.

◆ PortParameters()

std::map< String, DeviceRuntimeParameter * > LinuxSampler::MidiInputPort::PortParameters ( )

Return all parameter settings of this MIDI port.

◆ RemoveSysexListener()

static bool LinuxSampler::MidiInputPort::RemoveSysexListener ( Engine engine)
static

Removes engine from list of engines getting sysex messages.

Returns
true if engine was removed, false if it wasn't present in the list.

◆ SetNoteOnVelocityFilter()

void LinuxSampler::MidiInputPort::SetNoteOnVelocityFilter ( const std::vector< uint8_t > &  filter)

Registers the given filter to be applied against all note on events, adjusting their MIDI velocity data.

The vector supplied here must exactly be either of size 128 or 0. In case the given vector is of size 128, it will be used as lookup table by this MIDI inpurt port to remap any incoming MIDI note on velocity data to the respective value in that vector, or exactly:

Wraps as a kind of pointer class some data object shared with other threads, to protect / synchronize...

Accordingly the values in the vector have to be in the range 0..127, however note that a value 0 should actually never be used, since by MIDI specification, a note on with velocity 0 is interpreted as note off event instead!

If a vector of size 0 is supplied, this note on velocity filter mechanism will be disabled.

Parameters
filter- lookup table in the format described above
Exceptions
MidiInputException- if filter is in invalid format

Friends And Related Symbol Documentation

◆ MidiInputDevice

Definition at line 512 of file MidiInputPort.h.

Member Data Documentation

◆ MidiChannelMap

SynchronizedConfig<MidiChannelMap_t> LinuxSampler::MidiInputPort::MidiChannelMap
protected

Contains the list of connected engines for each MIDI channel, where index 0 points to the list of engines which are connected to all MIDI channels. Usually it's not necessary for the descendant to use this map, instead it should just use the Dispatch* methods.

Definition at line 472 of file MidiInputPort.h.

◆ MidiChannelMapMutex

Mutex LinuxSampler::MidiInputPort::MidiChannelMapMutex
protected

Used to protect the MidiChannelMap from being used at the same time by different threads.

Definition at line 474 of file MidiInputPort.h.

◆ MidiChannelMapReader

SynchronizedConfig<MidiChannelMap_t>::Reader LinuxSampler::MidiInputPort::MidiChannelMapReader
protected

MIDI thread access to MidiChannelMap.

Definition at line 473 of file MidiInputPort.h.

◆ noteOnVelocityFilter

SynchronizedConfig<std::vector<uint8_t> > LinuxSampler::MidiInputPort::noteOnVelocityFilter
protected

Definition at line 479 of file MidiInputPort.h.

◆ noteOnVelocityFilterMutex

Mutex LinuxSampler::MidiInputPort::noteOnVelocityFilterMutex
protected

Definition at line 481 of file MidiInputPort.h.

◆ noteOnVelocityFilterReader

SynchronizedConfig<std::vector<uint8_t>>::Reader LinuxSampler::MidiInputPort::noteOnVelocityFilterReader
protected

Definition at line 480 of file MidiInputPort.h.

◆ Parameters

std::map<String,DeviceRuntimeParameter*> LinuxSampler::MidiInputPort::Parameters
protected

All port parameters.

Definition at line 470 of file MidiInputPort.h.

◆ pDevice

MidiInputDevice* LinuxSampler::MidiInputPort::pDevice
protected

Definition at line 468 of file MidiInputPort.h.

◆ portNumber

int LinuxSampler::MidiInputPort::portNumber
protected

Definition at line 469 of file MidiInputPort.h.

◆ runningStatusBuf

uint8_t LinuxSampler::MidiInputPort::runningStatusBuf[3]
protected

Definition at line 482 of file MidiInputPort.h.

◆ SysexListenersReader

SynchronizedConfig<std::set<Engine*>>::Reader LinuxSampler::MidiInputPort::SysexListenersReader
protected

MIDI thread access to SysexListeners.

Definition at line 475 of file MidiInputPort.h.

◆ virtualMidiDevices

SynchronizedConfig<std::vector<VirtualMidiDevice*> > LinuxSampler::MidiInputPort::virtualMidiDevices
protected

Definition at line 476 of file MidiInputPort.h.

◆ virtualMidiDevicesMutex

Mutex LinuxSampler::MidiInputPort::virtualMidiDevicesMutex
protected

Definition at line 478 of file MidiInputPort.h.

◆ virtualMidiDevicesReader

SynchronizedConfig<std::vector<VirtualMidiDevice*>>::Reader LinuxSampler::MidiInputPort::virtualMidiDevicesReader
protected

Definition at line 477 of file MidiInputPort.h.


The documentation for this class was generated from the following file: