MidiReceiver Class Reference

#include <MIDIReceiver.h>

Inheritance diagram for MidiReceiver:

Public Member Functions
	MidiReceiver (const MidiReceiver &other)=delete
	MidiReceiver (Devices &devices)
	MidiReceiver (MidiReceiver &&other)=delete
	~MidiReceiver ()=default
template<class T >
void	AddCallback (_In_ T *const object, _In_ void(T::*const mf)(rsj::MidiMessage))
MidiReceiver &	operator= (const MidiReceiver &other)=delete
MidiReceiver &	operator= (MidiReceiver &&other)=delete
void	RescanDevices ()
void	Start ()
void	Stop ()

Private Member Functions
void	DispatchCcMessage (const std::pair< rsj::MidiMessage, juce::MidiInput * > &popped)
void	DispatchMessages ()
void	DispatchNoteOnPwMessage (const std::pair< rsj::MidiMessage, juce::MidiInput * > &popped) const
void	handleIncomingMidiMessage (juce::MidiInput *device, const juce::MidiMessage &message) override
void	InitDevices ()
void	TryToOpen ()

Private Attributes
std::vector< std::function< void(rsj::MidiMessage)> >	callbacks_
Devices &	devices_
std::future< void >	dispatch_messages_future_
std::map< juce::MidiInput *, NrpnFilter >	filters_ {}
std::vector< std::unique_ptr< juce::MidiInput > >	input_devices_
rsj::ConcurrentQueue< std::pair< rsj::MidiMessage, juce::MidiInput * > >	messages_

Constructor & Destructor Documentation

MidiReceiver() [1/3]

MidiReceiver::MidiReceiver ( Devices &  devices )

inlineexplicit

: devices_(devices) {}

~MidiReceiver()

MidiReceiver::~MidiReceiver ( )

default

MidiReceiver() [2/3]

MidiReceiver::MidiReceiver ( const MidiReceiver &  other )

delete

MidiReceiver() [3/3]

MidiReceiver::MidiReceiver ( MidiReceiver &&  other )

delete

Member Function Documentation

AddCallback()

template<class T >

void MidiReceiver::AddCallback ( _In_ T *const  object, _In_ void(T::*)(rsj::MidiMessage)  mf  )

inline

   {
      if (object && mf) { callbacks_.emplace_back(std::bind_front(mf, object)); }
   }

DispatchCcMessage()

void MidiReceiver::DispatchCcMessage ( const std::pair< rsj::MidiMessage, juce::MidiInput * > &  popped )

private

{
   try {
      if (const auto result {filters_[popped.second](popped.first)}; result.is_nrpn) {
         if (result.is_ready) {
            const rsj::MidiMessage nrpn_message {
                rsj::MessageType::kCc, popped.first.channel, result.control, result.value};
            for (const auto& cb : callbacks_) { cb(nrpn_message); }
         }
      }
      else {
         for (const auto& cb : callbacks_) { cb(popped.first); }
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

DispatchMessages()

void MidiReceiver::DispatchMessages ( )

private

{
   try {
      for (auto popped {messages_.pop()}; popped.first != kTerminate; popped = messages_.pop()) {
#ifdef _WIN32
         SetThreadExecutionState(0x00000002UL | 0x00000001UL);
#endif
         switch (popped.first.message_type_byte) {
         case rsj::MessageType::kCc:
            DispatchCcMessage(popped);
            break;
         case rsj::MessageType::kNoteOn:
         case rsj::MessageType::kPw:
            DispatchNoteOnPwMessage(popped);
            break;
         case rsj::MessageType::kChanPressure:
         case rsj::MessageType::kKeyPressure:
         case rsj::MessageType::kNoteOff:
         case rsj::MessageType::kPgmChange:
         case rsj::MessageType::kSystem:
            break; /* no action if other type of MIDI message */
         }
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

DispatchNoteOnPwMessage()

void MidiReceiver::DispatchNoteOnPwMessage ( const std::pair< rsj::MidiMessage, juce::MidiInput * > &  popped ) const

private

{
   try {
      for (const auto& cb : callbacks_) { cb(popped.first); }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

handleIncomingMidiMessage()

void MidiReceiver::handleIncomingMidiMessage ( juce::MidiInput *  device, const juce::MidiMessage &  message  )

inlineoverrideprivate

   {
      messages_.push({rsj::MidiMessage(message), device});
   }

InitDevices()

void MidiReceiver::InitDevices ( )

private

{
   using namespace std::literals::chrono_literals;
   try {
      rsj::Log("Trying to open input devices.");
      TryToOpen();
      if (input_devices_.empty()) /* encountering errors first try on MacOS */
      {
         rsj::Log("Retrying to open input devices.");
         std::this_thread::sleep_for(20ms);
         rsj::Log("20ms sleep for open input devices.");
         TryToOpen();
         if (input_devices_.empty()) /* encountering errors second try on MacOS */
         {
            rsj::Log("Retrying second time to open input devices.");
            std::this_thread::sleep_for(80ms);
            rsj::Log("80ms sleep for open input devices.");
            TryToOpen();
         }
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

operator=() [1/2]

MidiReceiver & MidiReceiver::operator= ( const MidiReceiver &  other )

delete

operator=() [2/2]

MidiReceiver & MidiReceiver::operator= ( MidiReceiver &&  other )

delete

RescanDevices()

void MidiReceiver::RescanDevices

(

)

{
   try {
      for (const auto& dev : input_devices_) {
         dev->stop();
         rsj::Log(fmt::format(FMT_STRING("Stopped input device {}."),
             dev->getName().toStdString()));
      }
      input_devices_.clear();
      rsj::Log("Cleared input devices.");
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
   InitDevices(); /* initdevices has own try catch block */
}

Start()

void MidiReceiver::Start

(

)

{
   try {
      InitDevices();
      dispatch_messages_future_ = std::async(std::launch::async, [this] {
         rsj::LabelThread(MIDI2LR_UC_LITERAL("MidiReceiver dispatch messages thread"));
         MIDI2LR_FAST_FLOATS;
         DispatchMessages();
      });
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

Stop()

void MidiReceiver::Stop

(

)

{
   for (const auto& dev : input_devices_) {
      dev->stop();
      rsj::Log(fmt::format(FMT_STRING("Stopped input device {}."), dev->getName().toStdString()));
   }
   if (const auto remaining {messages_.clear_count_push({kTerminate, nullptr})}) {
      rsj::Log(fmt::format(FMT_STRING("{} left in queue in MidiReceiver StopRunning."), remaining));
   }
}

TryToOpen()

void MidiReceiver::TryToOpen ( )

private

{
   try {
      const auto available_devices {juce::MidiInput::getAvailableDevices()};
      for (const auto& device : available_devices) {
         if (auto open_device {juce::MidiInput::openDevice(device.identifier, this)}) {
            if (devices_.EnabledOrNew(open_device->getDeviceInfo(), "input")) {
               open_device->start();
               rsj::Log(fmt::format(FMT_STRING("Opened input device {}."),
                   open_device->getName().toStdString()));
               input_devices_.push_back(std::move(open_device));
            }
            else {
               rsj::Log(fmt::format(FMT_STRING("Ignored input device {}."),
                   open_device->getName().toStdString()));
            }
         }
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

Member Data Documentation

callbacks_

std::vector<std::function<void(rsj::MidiMessage)> > MidiReceiver::callbacks_

private

devices_

Devices& MidiReceiver::devices_

private

dispatch_messages_future_

std::future<void> MidiReceiver::dispatch_messages_future_

private

filters_

std::map<juce::MidiInput*, NrpnFilter> MidiReceiver::filters_ {}

private

{};

input_devices_

std::vector<std::unique_ptr<juce::MidiInput> > MidiReceiver::input_devices_

private

messages_

rsj::ConcurrentQueue<std::pair<rsj::MidiMessage, juce::MidiInput*> > MidiReceiver::messages_

private

---

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

• C:/Users/rsjaf/source/repos/MIDI2LR/src/application/MIDIReceiver.h
• C:/Users/rsjaf/source/repos/MIDI2LR/src/application/MIDIReceiver.cpp