MidiSender Class Reference

#include <MIDISender.h>

Public Member Functions
	MidiSender (const MidiSender &other)=delete
	MidiSender (Devices &devices) noexcept
	MidiSender (MidiSender &&other) noexcept=delete
	~MidiSender ()
MidiSender &	operator= (const MidiSender &other)=delete
MidiSender &	operator= (MidiSender &&other) noexcept=delete
void	RescanDevices ()
void	Send (rsj::MidiMessageId id, int value) const
void	Start ()

Private Member Functions
void	InitDevices ()
void	SendControllerEvent (rsj::MidiMessageId id, int value) const
void	SendNoteOn (rsj::MidiMessageId id, int value) const
void	SendNrpn (rsj::MidiMessageId id, int value) const
void	SendPitchWheel (rsj::MidiMessageId id, int value) const
bool	ShouldOpenDevice (const std::string &devname, const auto &open_device)

Private Attributes
Devices &	devices_
std::vector< std::unique_ptr< juce::MidiOutput > >	output_devices_

Constructor & Destructor Documentation

MidiSender() [1/3]

MidiSender::MidiSender ( Devices &  devices )

inlineexplicitnoexcept

: devices_(devices) {}

~MidiSender()

MidiSender::~MidiSender ( )

inline

{ output_devices_.clear(); /* close devices */ }

MidiSender() [2/3]

MidiSender::MidiSender ( const MidiSender &  other )

delete

MidiSender() [3/3]

MidiSender::MidiSender ( MidiSender &&  other )

deletenoexcept

Member Function Documentation

InitDevices()

void MidiSender::InitDevices ( )

private

{
   try {
      const auto available_devices {juce::MidiOutput::getAvailableDevices()};
      for (const auto& device : available_devices) {
         if (auto open_device {juce::MidiOutput::openDevice(device.identifier)}) {
            const auto devname {open_device->getName().toStdString()};
            if (ShouldOpenDevice(devname, open_device)) {
               rsj::Log(fmt::format(FMT_STRING("Opened output device {}."), devname));
               output_devices_.push_back(std::move(open_device));
            }
            else {
               rsj::Log(fmt::format(FMT_STRING("Ignored output device {}."), devname));
            }
         }
      } /* devices that are skipped have their pointers deleted and are automatically closed*/
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

operator=() [1/2]

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

delete

operator=() [2/2]

MidiSender & MidiSender::operator= ( MidiSender &&  other )

deletenoexcept

RescanDevices()

void MidiSender::RescanDevices

(

)

{
   try {
      output_devices_.clear();
      rsj::Log("Cleared output devices.");
      InitDevices();
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

Send()

void MidiSender::Send	(	rsj::MidiMessageId	id,
		int	value
	)		const

{
   try {
      if (id.msg_id_type == rsj::MessageType::kCc) { SendControllerEvent(id, value); }
      else if (id.msg_id_type == rsj::MessageType::kNoteOn) {
         SendNoteOn(id, value);
      }
      else if (id.msg_id_type == rsj::MessageType::kPw) {
         SendPitchWheel(id, value);
      }
      else {
         LogUnexpectedDataType(id);
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

SendControllerEvent()

void MidiSender::SendControllerEvent ( rsj::MidiMessageId  id, int  value  ) const

private

{
   if (id.control_number < 128 && value < 128) {
      /* regular message */
      const auto msg {juce::MidiMessage::controllerEvent(id.channel, id.control_number, value)};
      for (const auto& dev : output_devices_) { dev->sendMessageNow(msg); }
   }
   else {
      /* NPRN */
      SendNrpn(id, value);
   }
}

SendNoteOn()

void MidiSender::SendNoteOn ( rsj::MidiMessageId  id, int  value  ) const

private

{
   const auto msg {juce::MidiMessage::noteOn(id.channel, id.control_number,
       gsl::narrow_cast<juce::uint8>(value))};
   for (const auto& dev : output_devices_) { dev->sendMessageNow(msg); }
}

SendNrpn()

void MidiSender::SendNrpn ( rsj::MidiMessageId  id, int  value  ) const

private

{
   const auto msg_parm_msb {
       juce::MidiMessage::controllerEvent(id.channel, 99, id.control_number >> 7 & 0x7F)};
   const auto msg_parm_lsb {
       juce::MidiMessage::controllerEvent(id.channel, 98, id.control_number & 0x7f)};
   const auto msg_val_msb {juce::MidiMessage::controllerEvent(id.channel, 6, value >> 7 & 0x7F)};
   const auto msg_val_lsb {juce::MidiMessage::controllerEvent(id.channel, 38, value & 0x7f)};
   for (const auto& dev : output_devices_) {
      dev->sendMessageNow(msg_parm_msb);
      dev->sendMessageNow(msg_parm_lsb);
      dev->sendMessageNow(msg_val_msb);
      dev->sendMessageNow(msg_val_lsb);
   }
}

SendPitchWheel()

void MidiSender::SendPitchWheel ( rsj::MidiMessageId  id, int  value  ) const

private

{
   const auto msg {juce::MidiMessage::pitchWheel(id.channel, value)};
   for (const auto& dev : output_devices_) { dev->sendMessageNow(msg); }
}

ShouldOpenDevice()

bool MidiSender::ShouldOpenDevice ( const std::string &  devname, const auto &  open_device  )

private

{
   if constexpr (MSWindows) {
      return devname != "Microsoft GS Wavetable Synth"
             && devices_.EnabledOrNew(open_device->getDeviceInfo(), "output");
   }
   else {
      return devices_.EnabledOrNew(open_device->getDeviceInfo(), "output");
   }
}

Start()

void MidiSender::Start

(

)

{
   try {
      InitDevices();
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

Member Data Documentation

devices_

Devices& MidiSender::devices_

private

output_devices_

std::vector<std::unique_ptr<juce::MidiOutput> > MidiSender::output_devices_

private

---

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

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