ChannelModel Class Reference

#include <ControlsModel.h>

Public Member Functions
	ChannelModel ()
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 ()
int	CenterCc (int controlnumber) const noexcept
int	CenterPw () const noexcept
bool	IsNrpn (int controlnumber) const
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

(

)

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

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);
      throw;
   }
}

CcDefaults()

void ChannelModel::CcDefaults ( )

private

{
   try {
      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
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

CenterCc()

int ChannelModel::CenterCc ( int  controlnumber ) const

inlineprivatenoexcept

   {
      return (cc_high_.at(controlnumber) - cc_low_.at(controlnumber)) / 2
             + cc_low_.at(controlnumber)
             + (cc_high_.at(controlnumber) - cc_low_.at(controlnumber)) % 2;
   }

CenterPw()

int ChannelModel::CenterPw ( ) const

inlineprivatenoexcept

   {
      return (pitch_wheel_max_ - pitch_wheel_min_) / 2 + pitch_wheel_min_
             + (pitch_wheel_max_ - pitch_wheel_min_) % 2;
   }

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);
      Expects(controltype == rsj::MessageType::kCc && cc_method == rsj::CCmethod::kAbsolute
                  ? cc_low < cc_high
                  : 1);
      Expects(controltype == rsj::MessageType::kPw ? pitch_wheel_max_ > pitch_wheel_min_ : 1);
      Expects(controltype == rsj::MessageType::kPw
                  ? value >= pitch_wheel_min_ && value <= pitch_wheel_max_
                  : 1);
      /* 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(FMT_STRING("ChannelModel::ControllerToPlugin unexpected control type. "
                                    "Controltype {}, controlnumber {}, value {}, wrap {}."),
                 controltype, controlnumber, value, wrap));
      }
      throw std::domain_error(fmt::format(FMT_STRING("Undefined control type in "
                                                     "ChannelModel::PluginToController. Control "
                                                     "type {}."),
          controltype));
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

GetCcMax()

int ChannelModel::GetCcMax ( int  controlnumber ) const

inline

{ return cc_high_.at(controlnumber); }

GetCcMethod()

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

inline

   {
      return cc_method_.at(controlnumber);
   }

GetCcMin()

int ChannelModel::GetCcMin ( int  controlnumber ) const

inline

{ return cc_low_.at(controlnumber); }

GetPwMax()

int ChannelModel::GetPwMax ( ) const

inlinenoexcept

{ return pitch_wheel_max_; }

GetPwMin()

int ChannelModel::GetPwMin ( ) const

inlinenoexcept

{ return pitch_wheel_min_; }

IsNrpn()

bool ChannelModel::IsNrpn ( int  controlnumber ) const

inlineprivate

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

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(juce::translate(msg).toStdString(), version),
                fmt::format(msg, version));
         }
         break;
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

MeasureChange()

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

{
   try {
      Expects(controltype == rsj::MessageType::kCc
                      && cc_method_.at(controlnumber) == rsj::CCmethod::kAbsolute
                  ? cc_low_.at(controlnumber) < cc_high_.at(controlnumber)
                  : 1);
      Expects(controltype == rsj::MessageType::kPw ? pitch_wheel_max_ > pitch_wheel_min_ : 1);
      Expects(controltype == rsj::MessageType::kPw
                  ? value >= pitch_wheel_min_ && value <= pitch_wheel_max_
                  : 1);
      /* 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(FMT_STRING("ChannelModel::MeasureChange unexpected control type. "
                                    "Controltype {}, controlnumber {}, value {}."),
                 controltype, controlnumber, value));
      }
      throw std::domain_error(fmt::format(FMT_STRING("Undefined control type in "
                                                     "ChannelModel::PluginToController. "
                                                     "Control type {}."),
          controltype));
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

OffsetResult()

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

private

{
   try {
      const auto high_limit {cc_high_.at(controlnumber)};
      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) {
         do {
            new_v = (old_v + diff + high_limit) % high_limit;
         } 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);
      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)};
#ifdef _WIN32
            const auto newv {
                std::clamp(_cvt_dtoi_fast(value * static_cast<double>(chigh - clow) + 0.5) + clow,
                    clow, chigh)};
#else
            const auto newv {std::clamp(
                gsl::narrow_cast<int>(value * static_cast<double>(chigh - clow) + 0.5) + clow, clow,
                chigh)};
#endif
#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(FMT_STRING("Unexpected control type in "
                                                            "ChannelModel::PluginToController. "
                                                            "Control type {}."),
             controltype));
      }
      throw std::domain_error(fmt::format(FMT_STRING("Undefined control type in "
                                                     "ChannelModel::PluginToController. "
                                                     "Control type {}."),
          controltype));
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

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(juce::translate(msg).toStdString(), version),
                fmt::format(msg, version));
         }
         break;
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      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);
      throw;
   }
}

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));
      }
   }
}

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);
      throw;
   }
}

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);
      throw;
   }
}

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);
      throw;
   }
}

SetCcMethod()

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

inline

   {
      cc_method_.at(controlnumber) = value;
   }

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);
      throw;
   }
}

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);
}

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);
}

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);
      throw;
   }
}

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

constexpr int ChannelModel::kBit14 {0x2000}

staticconstexprprivate

{0x2000};

kBit7

constexpr int ChannelModel::kBit7 {0x40}

staticconstexprprivate

{0x40};

kLow13Bits

constexpr int ChannelModel::kLow13Bits {0x1FFF}

staticconstexprprivate

{0x1FFF};

kLow6Bits

constexpr int ChannelModel::kLow6Bits {0x3F}

staticconstexprprivate

{0x3F};

kMaxControls

constexpr size_t ChannelModel::kMaxControls {0x4000}

staticconstexprprivate

{0x4000};

kMaxMidi

constexpr int ChannelModel::kMaxMidi {0x7F}

staticconstexprprivate

{0x7F};

kMaxMidiHalf

constexpr int ChannelModel::kMaxMidiHalf {kMaxMidi / 2}

staticconstexprprivate

{kMaxMidi / 2};

kMaxNrpn

constexpr int ChannelModel::kMaxNrpn {0x3FFF}

staticconstexprprivate

{0x3FFF};

kMaxNrpnHalf

constexpr 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};

pitch_wheel_min_

int ChannelModel::pitch_wheel_min_ {0}

private

{0};

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