ChannelModel Class Reference

#include <ControlsModel.h>

Public Member Functions
	ChannelModel () noexcept
double	ControllerToPlugin (rsj::MessageType controltype, int controlnumber, int value, bool wrap)
int	GetCcMax (int controlnumber) const
rsj::CCmethod	GetCcMethod (int controlnumber) const
int	GetCcMin (int controlnumber) const
int	GetPwMax () const noexcept
int	GetPwMin () const noexcept
int	MeasureChange (rsj::MessageType controltype, int controlnumber, int value)
int	PluginToController (rsj::MessageType controltype, int controlnumber, double value)
void	SetCc (int controlnumber, int min, int max, rsj::CCmethod controltype)
void	SetCcAll (int controlnumber, int min, int max, rsj::CCmethod controltype)
void	SetCcMax (int controlnumber, int value)
void	SetCcMethod (int controlnumber, rsj::CCmethod value)
void	SetCcMin (int controlnumber, int value)
void	SetPwMax (int value) noexcept
void	SetPwMin (int value) noexcept
int	SetToCenter (rsj::MessageType controltype, int controlnumber)

Private Member Functions
void	ActiveToSaved () const
void	CcDefaults () noexcept
int	CenterCc (int controlnumber) const noexcept
int	CenterPw () const noexcept
bool	IsNrpn (int controlnumber) const noexcept
template<class Archive>
void	load (Archive &archive, const uint32_t version)
double	OffsetResult (int diff, int controlnumber, bool wrap)
template<class Archive>
void	save (Archive &archive, const uint32_t version) const
void	SavedToActive ()
void	SaveSettings (int start, int end, int maxVal) const

Private Attributes
std::array< int, kMaxControls >	cc_high_ {}
std::array< int, kMaxControls >	cc_low_ {}
std::array< rsj::CCmethod, kMaxControls >	cc_method_ {}
std::array< std::atomic< int >, kMaxControls >	current_v_ {}
std::atomic< int >	pitch_wheel_current_ {kMaxNrpnHalf}
int	pitch_wheel_max_ {kMaxNrpn}
int	pitch_wheel_min_ {0}
std::vector< rsj::SettingsStruct >	settings_to_save_ {}

Static Private Attributes
static constexpr int	kBit14 {0x2000}
static constexpr int	kBit7 {0x40}
static constexpr int	kLow13Bits {0x1FFF}
static constexpr int	kLow6Bits {0x3F}
static constexpr size_t	kMaxControls {0x4000}
static constexpr int	kMaxMidi {0x7F}
static constexpr int	kMaxMidiHalf {kMaxMidi / 2}
static constexpr int	kMaxNrpn {0x3FFF}
static constexpr int	kMaxNrpnHalf {kMaxNrpn / 2}

Friends
class	cereal::access

Constructor & Destructor Documentation

ChannelModel()

ChannelModel::ChannelModel ( )

inlinenoexcept

{ CcDefaults(); }

References CcDefaults().

Member Function Documentation

ActiveToSaved()

void ChannelModel::ActiveToSaved ( ) const

private

{
   try {
      settings_to_save_.clear();
      SaveSettings(0, kMaxMidi, kMaxMidi);
      SaveSettings(kMaxMidi + 1, kMaxNrpn, kMaxNrpn);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References kMaxMidi, kMaxNrpn, and SaveSettings().

CcDefaults()

void ChannelModel::CcDefaults ( )

privatenoexcept

{
   cc_low_.fill(0);
   cc_high_.fill(kMaxNrpn);
   cc_method_.fill(rsj::CCmethod::kAbsolute);
#ifdef __cpp_lib_atomic_ref
   current_v_.fill(kMaxNrpnHalf);
   std::fill_n(cc_high_.begin(), kMaxMidi + 1, kMaxMidi);
   std::fill_n(current_v_.begin(), kMaxMidi + 1, kMaxMidiHalf);
#else
   for (auto&& a : current_v_) { a.store(kMaxNrpnHalf, std::memory_order_relaxed); }
   std::fill_n(cc_high_.begin(), kMaxMidi + 1, kMaxMidi);
   for (size_t a {0}; a <= kMaxMidi; ++a) {
      current_v_.at(a).store(kMaxMidiHalf, std::memory_order_relaxed);
   }
#endif
}

References kMaxMidi.

Referenced by ChannelModel(), and SavedToActive().

CenterCc()

int ChannelModel::CenterCc ( int controlnumber ) const

inlinenodiscardprivatenoexcept

   {
      auto diff {cc_high_.at(controlnumber) - cc_low_.at(controlnumber)};
      MIDI2LR_ASSUME(diff >= 0);
      return diff / 2 + cc_low_.at(controlnumber) + diff % 2;
   }

Referenced by SetToCenter().

CenterPw()

int ChannelModel::CenterPw ( ) const

inlinenodiscardprivatenoexcept

   {
      auto diff {pitch_wheel_max_ - pitch_wheel_min_};
      MIDI2LR_ASSUME(diff >= 0);
      return diff / 2 + pitch_wheel_min_ + diff % 2;
   }

References pitch_wheel_max_, and pitch_wheel_min_.

Referenced by SetToCenter().

ControllerToPlugin()

double ChannelModel::ControllerToPlugin	(	rsj::MessageType	controltype,
		int	controlnumber,
		int	value,
		bool	wrap )

{
   try {
      const auto cc_method {cc_method_.at(controlnumber)};
      const auto cc_low {cc_low_.at(controlnumber)};
      const auto cc_high {cc_high_.at(controlnumber)};
      // clearer precondition checks instead of ternary expressions
      if (controltype == rsj::MessageType::kCc && cc_method == rsj::CCmethod::kAbsolute) {
         Expects(cc_low < cc_high);
      }
      if (controltype == rsj::MessageType::kPw) {
         Expects(pitch_wheel_max_ > pitch_wheel_min_);
         Expects(value >= pitch_wheel_min_ && value <= pitch_wheel_max_);
      }
      /* note that the value is not msb,lsb, but rather the calculated value. Since lsb is only 7
       * bits, high bits are shifted one right when placed into int. */
      switch (controltype) {
      case rsj::MessageType::kPw:
         pitch_wheel_current_.store(value, std::memory_order_release);
#pragma warning(suppress : 26451) /* int subtraction won't overflow 4 bytes here */
         return static_cast<double>(value - pitch_wheel_min_)
                / static_cast<double>(pitch_wheel_max_ - pitch_wheel_min_);
      case rsj::MessageType::kCc:
         switch (cc_method) {
         case rsj::CCmethod::kAbsolute:
#ifdef __cpp_lib_atomic_ref
            std::atomic_ref(current_v_.at(controlnumber)).store(value, std::memory_order_release);
#else
            current_v_.at(controlnumber).store(value, std::memory_order_release);
#endif
#pragma warning(suppress : 26451) /* int subtraction won't overflow 4 bytes here */
            return static_cast<double>(value - cc_low) / static_cast<double>(cc_high - cc_low);
         case rsj::CCmethod::kBinaryOffset:
            if (IsNrpn(controlnumber)) { return OffsetResult(value - kBit14, controlnumber, wrap); }
            return OffsetResult(value - kBit7, controlnumber, wrap);
         case rsj::CCmethod::kSignMagnitude:
            if (IsNrpn(controlnumber)) {
               return OffsetResult(value & kBit14 ? -(value & kLow13Bits) : value, controlnumber,
                   wrap);
            }
            return OffsetResult(value & kBit7 ? -(value & kLow6Bits) : value, controlnumber, wrap);
         case rsj::CCmethod::kTwosComplement:
            /* SEE:https://en.wikipedia.org/wiki/Signed_number_representations#Two.27s_complement
             * flip twos comp and subtract--independent of processor architecture */
            if (IsNrpn(controlnumber)) {
               return OffsetResult(value & kBit14 ? -((value ^ kMaxNrpn) + 1) : value,
                   controlnumber, wrap);
            }
            return OffsetResult(value & kBit7 ? -((value ^ kMaxMidi) + 1) : value, controlnumber,
                wrap);
         }
      case rsj::MessageType::kNoteOn:
         return static_cast<double>(value)
                / static_cast<double>((IsNrpn(controlnumber) ? kMaxNrpn : kMaxMidi));
      case rsj::MessageType::kNoteOff:
         return 0.0;
      case rsj::MessageType::kChanPressure:
      case rsj::MessageType::kKeyPressure:
      case rsj::MessageType::kPgmChange:
      case rsj::MessageType::kSystem:
         throw std::invalid_argument(fmt::format("ChannelModel::ControllerToPlugin unexpected "
                                                 "control type. Controltype {}, controlnumber {}, "
                                                 "value {}, wrap {}.",
             controltype, controlnumber, value, wrap));
      }
      throw std::domain_error(fmt::format("Undefined control type in "
                                          "ChannelModel::PluginToController. Control type {}.",
          controltype));
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References IsNrpn(), rsj::kAbsolute, rsj::kBinaryOffset, kBit14, kBit7, rsj::kCc, rsj::kChanPressure, rsj::kKeyPressure, kLow13Bits, kLow6Bits, kMaxMidi, kMaxNrpn, rsj::kNoteOff, rsj::kNoteOn, rsj::kPgmChange, rsj::kPw, rsj::kSignMagnitude, rsj::kSystem, rsj::kTwosComplement, pitch_wheel_max_, and pitch_wheel_min_.

GetCcMax()

int ChannelModel::GetCcMax ( int controlnumber ) const

inlinenodiscard

{ return cc_high_.at(controlnumber); }

GetCcMethod()

rsj::CCmethod ChannelModel::GetCcMethod ( int controlnumber ) const

inlinenodiscard

   {
      return cc_method_.at(controlnumber);
   }

GetCcMin()

int ChannelModel::GetCcMin ( int controlnumber ) const

inlinenodiscard

{ return cc_low_.at(controlnumber); }

GetPwMax()

int ChannelModel::GetPwMax ( ) const

inlinenodiscardnoexcept

{ return pitch_wheel_max_; }

References pitch_wheel_max_.

GetPwMin()

int ChannelModel::GetPwMin ( ) const

inlinenodiscardnoexcept

{ return pitch_wheel_min_; }

References pitch_wheel_min_.

IsNrpn()

bool ChannelModel::IsNrpn ( int controlnumber ) const

inlinenodiscardprivatenoexcept

   {
      Expects(controlnumber <= kMaxNrpn && controlnumber >= 0);
      return controlnumber > kMaxMidi;
   }

References kMaxMidi.

Referenced by ControllerToPlugin(), MeasureChange(), SetCcAll(), and SetCcMax().

load()

template<class Archive>

void ChannelModel::load ( Archive & archive, const uint32_t version )

private

{
   try {
      switch (version) {
      case 1:
         archive(cc_method_, cc_high_, cc_low_, pitch_wheel_max_, pitch_wheel_min_);
         break;
      case 2:
         archive(settings_to_save_);
         SavedToActive();
         break;
      case 3:
         archive(settings_to_save_, cereal::make_nvp("PWmax", pitch_wheel_max_),
             cereal::make_nvp("PWmin", pitch_wheel_min_));
         SavedToActive();
         break;
      default:
         {
            constexpr auto msg {
                "The file, 'settings.xml', is marked as a version not supported by the current "
                "version of MIDI2LR ChannelModel, and won't be loaded. File version: {}."};
            rsj::LogAndAlertError(fmt::format(fmt::runtime(juce::translate(msg).toStdString()),
                                      version),
                fmt::format(fmt::runtime(msg), version), std::source_location::current());
         }
         break;
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

MeasureChange()

int ChannelModel::MeasureChange	(	rsj::MessageType	controltype,
		int	controlnumber,
		int	value )

{
   try {
      if (controltype == rsj::MessageType::kCc
          && cc_method_.at(controlnumber) == rsj::CCmethod::kAbsolute) {
         Expects(cc_low_.at(controlnumber) < cc_high_.at(controlnumber));
      }
      if (controltype == rsj::MessageType::kPw) {
         Expects(pitch_wheel_max_ > pitch_wheel_min_);
         Expects(value >= pitch_wheel_min_ && value <= pitch_wheel_max_);
      }
      /* note that the value is not msb,lsb, but rather the calculated value. Since lsb is only 7
       * bits, high bits are shifted one right when placed into int. */
      switch (controltype) {
      case rsj::MessageType::kPw:
         return value - pitch_wheel_current_.exchange(value, std::memory_order_acq_rel);
      case rsj::MessageType::kCc:
         switch (cc_method_.at(controlnumber)) {
         case rsj::CCmethod::kAbsolute:
#ifdef __cpp_lib_atomic_ref
            return value
                   - std::atomic_ref(current_v_.at(controlnumber))
                         .exchange(value, std::memory_order_acq_rel);
#else
            return value - current_v_.at(controlnumber).exchange(value, std::memory_order_acq_rel);
#endif
         case rsj::CCmethod::kBinaryOffset:
            if (IsNrpn(controlnumber)) { return value - kBit14; }
            return value - kBit7;
         case rsj::CCmethod::kSignMagnitude:
            if (IsNrpn(controlnumber)) { return value & kBit14 ? -(value & kLow13Bits) : value; }
            return value & kBit7 ? -(value & kLow6Bits) : value;
         case rsj::CCmethod::kTwosComplement:
            /* SEE:https://en.wikipedia.org/wiki/Signed_number_representations#Two.27s_complement
             * flip twos comp and subtract--independent of processor architecture */
            if (IsNrpn(controlnumber)) {
               return value & kBit14 ? -((value ^ kMaxNrpn) + 1) : value;
            }
            return value & kBit7 ? -((value ^ kMaxMidi) + 1) : value;
         }
      case rsj::MessageType::kNoteOff:
      case rsj::MessageType::kNoteOn:
         return int {0};
      case rsj::MessageType::kChanPressure:
      case rsj::MessageType::kKeyPressure:
      case rsj::MessageType::kPgmChange:
      case rsj::MessageType::kSystem:
         throw std::invalid_argument(fmt::format("ChannelModel::MeasureChange unexpected control "
                                                 "type. Controltype {}, controlnumber {}, value "
                                                 "{}.",
             controltype, controlnumber, value));
      }
      throw std::domain_error(fmt::format("Undefined control type in "
                                          "ChannelModel::PluginToController. Control type {}.",
          controltype));
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References IsNrpn(), kBit14, kBit7, rsj::kCc, rsj::kChanPressure, rsj::kKeyPressure, kLow13Bits, kLow6Bits, kMaxMidi, kMaxNrpn, rsj::kNoteOff, rsj::kNoteOn, rsj::kPgmChange, rsj::kPw, rsj::kSystem, pitch_wheel_max_, and pitch_wheel_min_.

OffsetResult()

double ChannelModel::OffsetResult ( int diff, int controlnumber, bool wrap )

private

{
   try {
      const auto high_limit {cc_high_.at(controlnumber)};
      Expects(high_limit > 0); // guard against divide/modulo by zero
      Expects(diff <= high_limit && diff >= -high_limit);
#ifdef __cpp_lib_atomic_ref
      std::atomic_ref cv {current_v_.at(controlnumber)};
#else
      auto& cv {current_v_.at(controlnumber)};
#endif
      auto old_v {cv.load(std::memory_order_relaxed)};
      int new_v {};
      if (wrap) {
         const auto mod {high_limit + 1}; // inclusive range 0..high_limit
         do {
            auto old_diff_mod {old_v + diff + mod};
            MIDI2LR_ASSUME(old_diff_mod >= 0);
            new_v = old_diff_mod % mod;
         } while (!cv.compare_exchange_weak(old_v, new_v, std::memory_order_release,
             std::memory_order_relaxed));
      }
      else [[likely]] {
         do {
            new_v = std::clamp(old_v + diff, 0, high_limit);
         } while (!cv.compare_exchange_weak(old_v, new_v, std::memory_order_release,
             std::memory_order_relaxed));
      }
      return static_cast<double>(new_v) / static_cast<double>(high_limit);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

PluginToController()

int ChannelModel::PluginToController	(	rsj::MessageType	controltype,
		int	controlnumber,
		double	value )

{
   try {
      /* value effectively clamped to 0-1 by clamp calls below */
      switch (controltype) {
      case rsj::MessageType::kPw:
         {
            /* TODO(C26451): int subtraction: can it overflow? */
            const auto newv {
                std::clamp(gsl::narrow<int>(std::lrint(
                               value * static_cast<double>(pitch_wheel_max_ - pitch_wheel_min_)))
                               + pitch_wheel_min_,
                    pitch_wheel_min_, pitch_wheel_max_)};
            pitch_wheel_current_.store(newv, std::memory_order_release);
            return newv;
         }
      case rsj::MessageType::kCc:
         {
            /* TODO(C26451): int subtraction: can it overflow? */
            const auto clow {cc_low_.at(controlnumber)};
            const auto chigh {cc_high_.at(controlnumber)};
            const auto newv {std::clamp(
                gsl::narrow_cast<int>(std::lrint(value * static_cast<double>(chigh - clow))) + clow,
                clow, chigh)};
#ifdef __cpp_lib_atomic_ref
            std::atomic_ref(current_v_.at(controlnumber)).store(newv, std::memory_order_release);
#else
            current_v_.at(controlnumber).store(newv, std::memory_order_release);
#endif
            return newv;
         }
      case rsj::MessageType::kNoteOn:
         return kMaxMidi;
      case rsj::MessageType::kChanPressure:
      case rsj::MessageType::kKeyPressure:
      case rsj::MessageType::kNoteOff:
      case rsj::MessageType::kPgmChange:
      case rsj::MessageType::kSystem:
         throw std::invalid_argument(fmt::format(
             "Unexpected control type in ChannelModel::PluginToController. Control type {}.",
             controltype));
      }
      throw std::domain_error(fmt::format("Undefined control type in "
                                          "ChannelModel::PluginToController. Control type {}.",
          controltype));
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References rsj::kCc, rsj::kChanPressure, rsj::kKeyPressure, kMaxMidi, rsj::kNoteOff, rsj::kNoteOn, rsj::kPgmChange, rsj::kPw, and rsj::kSystem.

save()

template<class Archive>

void ChannelModel::save ( Archive & archive, const uint32_t version ) const

private

{
   try {
      switch (version) {
      case 1:
         archive(cc_method_, cc_high_, cc_low_, pitch_wheel_max_, pitch_wheel_min_);
         break;
      case 2:
         ActiveToSaved();
         archive(settings_to_save_);
         break;
      case 3:
         ActiveToSaved();
         archive(settings_to_save_, cereal::make_nvp("PWmax", pitch_wheel_max_),
             cereal::make_nvp("PWmin", pitch_wheel_min_));
         break;
      default:
         {
            constexpr auto msg {
                "The file, 'settings.xml', is marked as a version not supported by the current "
                "version of MIDI2LR ChannelModel, and won't be loaded. File version: {}."};
            rsj::LogAndAlertError(fmt::format(fmt::runtime(juce::translate(msg).toStdString()),
                                      version),
                fmt::format(fmt::runtime(msg), version), std::source_location::current());
         }
         break;
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

SavedToActive()

void ChannelModel::SavedToActive ( )

private

{
   try {
      CcDefaults();
      for (const auto& set : settings_to_save_) {
         SetCc(set.control_number, set.low, set.high, set.method);
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References CcDefaults().

SaveSettings()

void ChannelModel::SaveSettings ( int start, int end, int maxVal ) const

private

{
   for (auto i {start}; i <= end; ++i) {
      if (cc_method_.at(i) != rsj::CCmethod::kAbsolute || cc_high_.at(i) != maxVal
          || cc_low_.at(i) != 0) {
         settings_to_save_.emplace_back(i, cc_low_.at(i), cc_high_.at(i), cc_method_.at(i));
      }
   }
}

Referenced by ActiveToSaved().

SetCc()

void ChannelModel::SetCc	(	int	controlnumber,
		int	min,
		int	max,
		rsj::CCmethod	controltype )

{
   try {
      /* CcMethod has to be set before others or ranges won't be correct */
      SetCcMethod(controlnumber, controltype);
      SetCcMin(controlnumber, min);
      SetCcMax(controlnumber, max);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References SetCcMax(), SetCcMethod(), and SetCcMin().

SetCcAll()

void ChannelModel::SetCcAll	(	int	controlnumber,
		int	min,
		int	max,
		rsj::CCmethod	controltype )

{
   try {
      if (IsNrpn(controlnumber)) {
         for (auto a {kMaxMidi + 1}; a <= kMaxNrpn; ++a) { SetCc(a, min, max, controltype); }
      }
      else {
         for (auto a {0}; a <= kMaxMidi; ++a) { SetCc(a, min, max, controltype); }
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References IsNrpn(), kMaxMidi, and kMaxNrpn.

SetCcMax()

void ChannelModel::SetCcMax	(	int	controlnumber,
		int	value )

{
   try {
      Expects(value <= kMaxNrpn && value >= 0);
      if (cc_method_.at(controlnumber) != rsj::CCmethod::kAbsolute) {
         cc_high_.at(controlnumber) = value < 0 ? 1000 : value;
      }
      else {
         const auto max {IsNrpn(controlnumber) ? kMaxNrpn : kMaxMidi};
         cc_high_.at(controlnumber) =
             value <= cc_low_.at(controlnumber) || value > max ? max : value;
      }
#ifdef __cpp_lib_atomic_ref
      std::atomic_ref(current_v_.at(controlnumber))
          .store(CenterCc(controlnumber), std::memory_order_release);
#else
      current_v_.at(controlnumber).store(CenterCc(controlnumber), std::memory_order_release);
#endif
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References IsNrpn(), kMaxMidi, and kMaxNrpn.

Referenced by SetCc().

SetCcMethod()

void ChannelModel::SetCcMethod ( int controlnumber, rsj::CCmethod value )

inline

   {
      cc_method_.at(controlnumber) = value;
   }

Referenced by SetCc().

SetCcMin()

void ChannelModel::SetCcMin	(	int	controlnumber,
		int	value )

{
   try {
      if (cc_method_.at(controlnumber) != rsj::CCmethod::kAbsolute) {
         cc_low_.at(controlnumber) = 0;
      }
      else {
         cc_low_.at(controlnumber) = value < 0 || value >= cc_high_.at(controlnumber) ? 0 : value;
      }
#ifdef __cpp_lib_atomic_ref
      std::atomic_ref(current_v_.at(controlnumber))
          .store(CenterCc(controlnumber), std::memory_order_release);
#else
      current_v_.at(controlnumber).store(CenterCc(controlnumber), std::memory_order_release);
#endif
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

Referenced by SetCc().

SetPwMax()

void ChannelModel::SetPwMax ( int value )

noexcept

{
   pitch_wheel_max_ = value > kMaxNrpn || value <= pitch_wheel_min_ ? kMaxNrpn : value;
   pitch_wheel_current_.store(CenterPw(), std::memory_order_release);
}

References kMaxNrpn, pitch_wheel_max_, and pitch_wheel_min_.

SetPwMin()

void ChannelModel::SetPwMin ( int value )

noexcept

{
   pitch_wheel_min_ = value < 0 || value >= pitch_wheel_max_ ? 0 : value;
   pitch_wheel_current_.store(CenterPw(), std::memory_order_release);
}

References pitch_wheel_max_, and pitch_wheel_min_.

SetToCenter()

int ChannelModel::SetToCenter	(	rsj::MessageType	controltype,
		int	controlnumber )

{
   try {
      auto retval {0};
      switch (controltype) {
      case rsj::MessageType::kPw:
         retval = CenterPw();
         pitch_wheel_current_.store(retval, std::memory_order_release);
         break;
      case rsj::MessageType::kCc:
         if (cc_method_.at(controlnumber) == rsj::CCmethod::kAbsolute) {
            retval = CenterCc(controlnumber);
#ifdef __cpp_lib_atomic_ref
            std::atomic_ref(current_v_.at(controlnumber)).store(retval, std::memory_order_release);
#else
            current_v_.at(controlnumber).store(retval, std::memory_order_release);
#endif
         }
         break;
      case rsj::MessageType::kChanPressure:
      case rsj::MessageType::kKeyPressure:
      case rsj::MessageType::kNoteOff:
      case rsj::MessageType::kNoteOn:
      case rsj::MessageType::kPgmChange:
      case rsj::MessageType::kSystem:
         break;
      }
      return retval;
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

References CenterCc(), CenterPw(), rsj::kCc, rsj::kChanPressure, rsj::kKeyPressure, rsj::kNoteOff, rsj::kNoteOn, rsj::kPgmChange, rsj::kPw, and rsj::kSystem.

Friends And Related Symbol Documentation

cereal::access

friend class cereal::access

friend

Member Data Documentation

cc_high_

std::array<int, kMaxControls> ChannelModel::cc_high_ {}

private

{};

cc_low_

std::array<int, kMaxControls> ChannelModel::cc_low_ {}

private

{};

cc_method_

std::array<rsj::CCmethod, kMaxControls> ChannelModel::cc_method_ {}

private

{};

current_v_

std::array<std::atomic<int>, kMaxControls> ChannelModel::current_v_ {}

private

{};

kBit14

int ChannelModel::kBit14 {0x2000}

staticconstexprprivate

{0x2000};

Referenced by ControllerToPlugin(), and MeasureChange().

kBit7

int ChannelModel::kBit7 {0x40}

staticconstexprprivate

{0x40};

Referenced by ControllerToPlugin(), and MeasureChange().

kLow13Bits

int ChannelModel::kLow13Bits {0x1FFF}

staticconstexprprivate

{0x1FFF};

Referenced by ControllerToPlugin(), and MeasureChange().

kLow6Bits

int ChannelModel::kLow6Bits {0x3F}

staticconstexprprivate

{0x3F};

Referenced by ControllerToPlugin(), and MeasureChange().

kMaxControls

size_t ChannelModel::kMaxControls {0x4000}

staticconstexprprivate

{0x4000};

kMaxMidi

int ChannelModel::kMaxMidi {0x7F}

staticconstexprprivate

{0x7F};

Referenced by ActiveToSaved(), CcDefaults(), ControllerToPlugin(), IsNrpn(), MeasureChange(), PluginToController(), SetCcAll(), and SetCcMax().

kMaxMidiHalf

int ChannelModel::kMaxMidiHalf {kMaxMidi / 2}

staticconstexprprivate

{kMaxMidi / 2};

kMaxNrpn

int ChannelModel::kMaxNrpn {0x3FFF}

staticconstexprprivate

{0x3FFF};

Referenced by ActiveToSaved(), ControllerToPlugin(), MeasureChange(), SetCcAll(), SetCcMax(), and SetPwMax().

kMaxNrpnHalf

int ChannelModel::kMaxNrpnHalf {kMaxNrpn / 2}

staticconstexprprivate

{kMaxNrpn / 2};

pitch_wheel_current_

std::atomic<int> ChannelModel::pitch_wheel_current_ {kMaxNrpnHalf}

private

{kMaxNrpnHalf};

pitch_wheel_max_

int ChannelModel::pitch_wheel_max_ {kMaxNrpn}

private

{kMaxNrpn};

Referenced by CenterPw(), ControllerToPlugin(), GetPwMax(), MeasureChange(), SetPwMax(), and SetPwMin().

pitch_wheel_min_

int ChannelModel::pitch_wheel_min_ {0}

private

{0};

Referenced by CenterPw(), ControllerToPlugin(), GetPwMin(), MeasureChange(), SetPwMax(), and SetPwMin().

settings_to_save_

std::vector<rsj::SettingsStruct> ChannelModel::settings_to_save_ {}

mutableprivate

{};

---

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

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