MIDI2LR 6.2.0.1
MIDI2LR is an application that interfaces MIDI controllers with Lightroom 6+/CC Classic. It processes MIDI input into develop parameter updates and photo actions, and sends MIDI output when parameters are changed for motorized feedback (on controllers that have motorized faders). A listing of available LightRoom commands is in the Wiki. Assistance on the code and design is welcome.
Loading...
Searching...
No Matches
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, kMaxControlscc_high_ {}
 
std::array< int, kMaxControlscc_low_ {}
 
std::array< rsj::CCmethod, kMaxControlscc_method_ {}
 
std::array< std::atomic< int >, kMaxControlscurrent_v_ {}
 
std::atomic< int > pitch_wheel_current_ {kMaxNrpnHalf}
 
int pitch_wheel_max_ {kMaxNrpn}
 
int pitch_wheel_min_ {0}
 
std::vector< rsj::SettingsStructsettings_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
143{ CcDefaults(); }
void CcDefaults() noexcept
Definition ControlsModel.cpp:406

Member Function Documentation

◆ ActiveToSaved()

void ChannelModel::ActiveToSaved ( ) const
private
394{
395 try {
396 settings_to_save_.clear();
399 }
400 catch (const std::exception& e) {
401 rsj::ExceptionResponse(e, std::source_location::current());
402 throw;
403 }
404}
void SaveSettings(int start, int end, int maxVal) const
Definition ControlsModel.cpp:383
std::vector< rsj::SettingsStruct > settings_to_save_
Definition ControlsModel.h:209
static constexpr int kMaxMidi
Definition ControlsModel.h:136
static constexpr int kMaxNrpn
Definition ControlsModel.h:138
void ExceptionResponse(gsl::czstring id, gsl::czstring fu, const std::exception &e) noexcept

◆ CcDefaults()

void ChannelModel::CcDefaults ( )
privatenoexcept
407{
408 cc_low_.fill(0);
409 cc_high_.fill(kMaxNrpn);
411#ifdef __cpp_lib_atomic_ref
413 std::fill_n(cc_high_.begin(), kMaxMidi + 1, kMaxMidi);
414 std::fill_n(current_v_.begin(), kMaxMidi + 1, kMaxMidiHalf);
415#else
416 for (auto&& a : current_v_) { a.store(kMaxNrpnHalf, std::memory_order_relaxed); }
417 std::fill_n(cc_high_.begin(), kMaxMidi + 1, kMaxMidi);
418 for (size_t a {0}; a <= kMaxMidi; ++a) {
419 current_v_.at(a).store(kMaxMidiHalf, std::memory_order_relaxed);
420 }
421#endif
422}
std::array< int, kMaxControls > cc_low_
Definition ControlsModel.h:215
std::array< rsj::CCmethod, kMaxControls > cc_method_
Definition ControlsModel.h:213
static constexpr int kMaxNrpnHalf
Definition ControlsModel.h:139
std::array< int, kMaxControls > cc_high_
Definition ControlsModel.h:214
static constexpr int kMaxMidiHalf
Definition ControlsModel.h:137
std::array< std::atomic< int >, kMaxControls > current_v_
Definition ControlsModel.h:219

◆ CenterCc()

int ChannelModel::CenterCc ( int  controlnumber) const
inlineprivatenoexcept
180 {
181 return (cc_high_.at(controlnumber) - cc_low_.at(controlnumber)) / 2
182 + cc_low_.at(controlnumber)
183 + (cc_high_.at(controlnumber) - cc_low_.at(controlnumber)) % 2;
184 }

◆ CenterPw()

int ChannelModel::CenterPw ( ) const
inlineprivatenoexcept
187 {
190 }
int pitch_wheel_min_
Definition ControlsModel.h:211
int pitch_wheel_max_
Definition ControlsModel.h:210

◆ ControllerToPlugin()

double ChannelModel::ControllerToPlugin ( rsj::MessageType  controltype,
int  controlnumber,
int  value,
bool  wrap 
)
55{
56 try {
57 const auto cc_method = cc_method_.at(controlnumber);
58 const auto cc_low = cc_low_.at(controlnumber);
59 const auto cc_high = cc_high_.at(controlnumber);
60 Expects(controltype == rsj::MessageType::kCc && cc_method == rsj::CCmethod::kAbsolute
61 ? cc_low < cc_high
62 : 1);
63 Expects(controltype == rsj::MessageType::kPw ? pitch_wheel_max_ > pitch_wheel_min_ : 1);
64 Expects(controltype == rsj::MessageType::kPw
65 ? value >= pitch_wheel_min_ && value <= pitch_wheel_max_
66 : 1);
67 /* note that the value is not msb,lsb, but rather the calculated value. Since lsb is only 7
68 * bits, high bits are shifted one right when placed into int. */
69 switch (controltype) {
71 pitch_wheel_current_.store(value, std::memory_order_release);
72#pragma warning(suppress : 26451) /* int subtraction won't overflow 4 bytes here */
73 return static_cast<double>(value - pitch_wheel_min_)
74 / static_cast<double>(pitch_wheel_max_ - pitch_wheel_min_);
76 switch (cc_method) {
78#ifdef __cpp_lib_atomic_ref
79 std::atomic_ref(current_v_.at(controlnumber)).store(value, std::memory_order_release);
80#else
81 current_v_.at(controlnumber).store(value, std::memory_order_release);
82#endif
83#pragma warning(suppress : 26451) /* int subtraction won't overflow 4 bytes here */
84 return static_cast<double>(value - cc_low) / static_cast<double>(cc_high - cc_low);
86 if (IsNrpn(controlnumber)) { return OffsetResult(value - kBit14, controlnumber, wrap); }
87 return OffsetResult(value - kBit7, controlnumber, wrap);
89 if (IsNrpn(controlnumber)) {
90 return OffsetResult(value & kBit14 ? -(value & kLow13Bits) : value, controlnumber,
91 wrap);
92 }
93 return OffsetResult(value & kBit7 ? -(value & kLow6Bits) : value, controlnumber, wrap);
95 /* SEE:https://en.wikipedia.org/wiki/Signed_number_representations#Two.27s_complement
96 * flip twos comp and subtract--independent of processor architecture */
97 if (IsNrpn(controlnumber)) {
98 return OffsetResult(value & kBit14 ? -((value ^ kMaxNrpn) + 1) : value,
99 controlnumber, wrap);
100 }
101 return OffsetResult(value & kBit7 ? -((value ^ kMaxMidi) + 1) : value, controlnumber,
102 wrap);
103 }
105 return static_cast<double>(value)
106 / static_cast<double>((IsNrpn(controlnumber) ? kMaxNrpn : kMaxMidi));
108 return 0.0;
113 throw std::invalid_argument(fmt::format(FMT_STRING(
114 "ChannelModel::ControllerToPlugin unexpected "
115 "control type. " "Controltype {}, "
116 "controlnumber {}, value {}, "
117 "wrap {}."),
118 controltype, controlnumber, value, wrap));
119 }
120 throw std::domain_error(
121 fmt::format(FMT_STRING("Undefined control type in " "ChannelModel::PluginToController. "
122 "Control type {}."),
123 controltype));
124 }
125 catch (const std::exception& e) {
126 rsj::ExceptionResponse(e, std::source_location::current());
127 throw;
128 }
129}
double OffsetResult(int diff, int controlnumber, bool wrap)
Definition ControlsModel.cpp:21
static constexpr int kLow6Bits
Definition ControlsModel.h:135
static constexpr int kBit14
Definition ControlsModel.h:132
static constexpr int kBit7
Definition ControlsModel.h:133
static constexpr int kLow13Bits
Definition ControlsModel.h:134
std::atomic< int > pitch_wheel_current_
Definition ControlsModel.h:212
bool IsNrpn(int controlnumber) const noexcept
Definition ControlsModel.h:193

◆ GetCcMax()

int ChannelModel::GetCcMax ( int  controlnumber) const
inline
154{ return cc_high_.at(controlnumber); }

◆ GetCcMethod()

rsj::CCmethod ChannelModel::GetCcMethod ( int  controlnumber) const
inline
150 {
151 return cc_method_.at(controlnumber);
152 }

◆ GetCcMin()

int ChannelModel::GetCcMin ( int  controlnumber) const
inline
156{ return cc_low_.at(controlnumber); }

◆ GetPwMax()

int ChannelModel::GetPwMax ( ) const
inlinenoexcept
158{ return pitch_wheel_max_; }

◆ GetPwMin()

int ChannelModel::GetPwMin ( ) const
inlinenoexcept
160{ return pitch_wheel_min_; }

◆ IsNrpn()

bool ChannelModel::IsNrpn ( int  controlnumber) const
inlineprivatenoexcept
194 {
195 Expects(controlnumber <= kMaxNrpn && controlnumber >= 0);
196 return controlnumber > kMaxMidi;
197 }

◆ load()

template<class Archive >
void ChannelModel::load ( Archive &  archive,
const uint32_t  version 
)
private
329{
330 try {
331 switch (version) {
332 case 1:
334 break;
335 case 2:
336 archive(settings_to_save_);
338 break;
339 case 3:
340 archive(settings_to_save_, cereal::make_nvp("PWmax", pitch_wheel_max_),
341 cereal::make_nvp("PWmin", pitch_wheel_min_));
343 break;
344 default:
345 {
346 constexpr auto msg {
347 "The file, 'settings.xml', is marked as a version not supported by the current "
348 "version of MIDI2LR ChannelModel, and won't be loaded. File version: {}."};
349 rsj::LogAndAlertError(fmt::format(juce::translate(msg).toStdString(), version),
350 fmt::format(msg, version), std::source_location::current());
351 }
352 break;
353 }
354 }
355 catch (const std::exception& e) {
356 rsj::ExceptionResponse(e, std::source_location::current());
357 throw;
358 }
359}
void SavedToActive()
Definition ControlsModel.cpp:424
void LogAndAlertError(const juce::String &error_text, const std::source_location &location=std::source_location::current()) noexcept
Definition Misc.cpp:142

◆ MeasureChange()

int ChannelModel::MeasureChange ( rsj::MessageType  controltype,
int  controlnumber,
int  value 
)
170{
171 try {
172 Expects(controltype == rsj::MessageType::kCc
173 && cc_method_.at(controlnumber) == rsj::CCmethod::kAbsolute
174 ? cc_low_.at(controlnumber) < cc_high_.at(controlnumber)
175 : 1);
176 Expects(controltype == rsj::MessageType::kPw ? pitch_wheel_max_ > pitch_wheel_min_ : 1);
177 Expects(controltype == rsj::MessageType::kPw
178 ? value >= pitch_wheel_min_ && value <= pitch_wheel_max_
179 : 1);
180 /* note that the value is not msb,lsb, but rather the calculated value. Since lsb is only 7
181 * bits, high bits are shifted one right when placed into int. */
182 switch (controltype) {
184 return value - pitch_wheel_current_.exchange(value, std::memory_order_acq_rel);
186 switch (cc_method_.at(controlnumber)) {
188#ifdef __cpp_lib_atomic_ref
189 return value
190 - std::atomic_ref(current_v_.at(controlnumber))
191 .exchange(value, std::memory_order_acq_rel);
192#else
193 return value - current_v_.at(controlnumber).exchange(value, std::memory_order_acq_rel);
194#endif
196 if (IsNrpn(controlnumber)) { return value - kBit14; }
197 return value - kBit7;
199 if (IsNrpn(controlnumber)) { return value & kBit14 ? -(value & kLow13Bits) : value; }
200 return value & kBit7 ? -(value & kLow6Bits) : value;
202 /* SEE:https://en.wikipedia.org/wiki/Signed_number_representations#Two.27s_complement
203 * flip twos comp and subtract--independent of processor architecture */
204 if (IsNrpn(controlnumber)) {
205 return value & kBit14 ? -((value ^ kMaxNrpn) + 1) : value;
206 }
207 return value & kBit7 ? -((value ^ kMaxMidi) + 1) : value;
208 }
211 return int {0};
216 throw std::invalid_argument(fmt::format(FMT_STRING("ChannelModel::MeasureChange "
217 "unexpected control type. Controltype "
218 "{}, controlnumber {}, value {}."),
219 controltype, controlnumber, value));
220 }
221 throw std::domain_error(fmt::format(FMT_STRING("Undefined control type in "
222 "ChannelModel::PluginToController. Control "
223 "type {}."),
224 controltype));
225 }
226 catch (const std::exception& e) {
227 rsj::ExceptionResponse(e, std::source_location::current());
228 throw;
229 }
230}

◆ OffsetResult()

double ChannelModel::OffsetResult ( int  diff,
int  controlnumber,
bool  wrap 
)
private
22{
23 try {
24 const auto high_limit {cc_high_.at(controlnumber)};
25 Expects(diff <= high_limit && diff >= -high_limit);
26#ifdef __cpp_lib_atomic_ref
27 std::atomic_ref cv {current_v_.at(controlnumber)};
28#else
29 auto& cv {current_v_.at(controlnumber)};
30#endif
31 auto old_v {cv.load(std::memory_order_relaxed)};
32 int new_v {};
33 if (wrap) {
34 do {
35 new_v = (old_v + diff + high_limit) % high_limit;
36 } while (!cv.compare_exchange_weak(old_v, new_v, std::memory_order_release,
37 std::memory_order_relaxed));
38 }
39 else [[likely]] {
40 do {
41 new_v = std::clamp(old_v + diff, 0, high_limit);
42 } while (!cv.compare_exchange_weak(old_v, new_v, std::memory_order_release,
43 std::memory_order_relaxed));
44 }
45 return static_cast<double>(new_v) / static_cast<double>(high_limit);
46 }
47 catch (const std::exception& e) {
48 rsj::ExceptionResponse(e, std::source_location::current());
49 throw;
50 }
51}

◆ PluginToController()

int ChannelModel::PluginToController ( rsj::MessageType  controltype,
int  controlnumber,
double  value 
)
237{
238 try {
239 /* value effectively clamped to 0-1 by clamp calls below */
240 switch (controltype) {
242 {
243 /* TODO(C26451): int subtraction: can it overflow? */
244 const auto newv {
245 std::clamp(gsl::narrow<int>(std::lrint(
246 value * static_cast<double>(pitch_wheel_max_ - pitch_wheel_min_)))
249 pitch_wheel_current_.store(newv, std::memory_order_release);
250 return newv;
251 }
253 {
254 /* TODO(C26451): int subtraction: can it overflow? */
255 const auto clow {cc_low_.at(controlnumber)};
256 const auto chigh {cc_high_.at(controlnumber)};
257 const auto newv {std::clamp(
258 gsl::narrow_cast<int>(std::lrint(value * static_cast<double>(chigh - clow))) + clow,
259 clow, chigh)};
260#ifdef __cpp_lib_atomic_ref
261 std::atomic_ref(current_v_.at(controlnumber)).store(newv, std::memory_order_release);
262#else
263 current_v_.at(controlnumber).store(newv, std::memory_order_release);
264#endif
265 return newv;
266 }
268 return kMaxMidi;
274 throw std::invalid_argument(fmt::format(FMT_STRING("Unexpected control type in "
275 "ChannelModel::PluginToController. "
276 "Control type {}."),
277 controltype));
278 }
279 throw std::domain_error(
280 fmt::format(FMT_STRING("Undefined control type in " "ChannelModel::PluginToController. "
281 "Control type {}."),
282 controltype));
283 }
284 catch (const std::exception& e) {
285 rsj::ExceptionResponse(e, std::source_location::current());
286 throw;
287 }
288}

◆ save()

template<class Archive >
void ChannelModel::save ( Archive &  archive,
const uint32_t  version 
) const
private
362{
363 try {
364 switch (version) {
365 case 1:
367 break;
368 case 2:
370 archive(settings_to_save_);
371 break;
372 case 3:
374 archive(settings_to_save_, cereal::make_nvp("PWmax", pitch_wheel_max_),
375 cereal::make_nvp("PWmin", pitch_wheel_min_));
376 break;
377 default:
378 {
379 constexpr auto msg {
380 "The file, 'settings.xml', is marked as a version not supported by the current "
381 "version of MIDI2LR ChannelModel, and won't be loaded. File version: {}."};
382 rsj::LogAndAlertError(fmt::format(juce::translate(msg).toStdString(), version),
383 fmt::format(msg, version), std::source_location::current());
384 }
385 break;
386 }
387 }
388 catch (const std::exception& e) {
389 rsj::ExceptionResponse(e, std::source_location::current());
390 throw;
391 }
392}
void ActiveToSaved() const
Definition ControlsModel.cpp:393

◆ SavedToActive()

void ChannelModel::SavedToActive ( )
private
425{
426 try {
427 CcDefaults();
428 for (const auto& set : settings_to_save_) {
429 SetCc(set.control_number, set.low, set.high, set.method);
430 }
431 }
432 catch (const std::exception& e) {
433 rsj::ExceptionResponse(e, std::source_location::current());
434 throw;
435 }
436}
void SetCc(int controlnumber, int min, int max, rsj::CCmethod controltype)
Definition ControlsModel.cpp:292

◆ SaveSettings()

void ChannelModel::SaveSettings ( int  start,
int  end,
int  maxVal 
) const
private
384{
385 for (auto i {start}; i <= end; ++i) {
386 if (cc_method_.at(i) != rsj::CCmethod::kAbsolute || cc_high_.at(i) != maxVal
387 || cc_low_.at(i) != 0) {
388 settings_to_save_.emplace_back(i, cc_low_.at(i), cc_high_.at(i), cc_method_.at(i));
389 }
390 }
391}

◆ SetCc()

void ChannelModel::SetCc ( int  controlnumber,
int  min,
int  max,
rsj::CCmethod  controltype 
)
294{
295 try {
296 /* CcMethod has to be set before others or ranges won't be correct */
297 SetCcMethod(controlnumber, controltype);
298 SetCcMin(controlnumber, min);
299 SetCcMax(controlnumber, max);
300 }
301 catch (const std::exception& e) {
302 rsj::ExceptionResponse(e, std::source_location::current());
303 throw;
304 }
305}
void SetCcMethod(int controlnumber, rsj::CCmethod value)
Definition ControlsModel.h:167
void SetCcMax(int controlnumber, int value)
Definition ControlsModel.cpp:324
void SetCcMin(int controlnumber, int value)
Definition ControlsModel.cpp:349

◆ SetCcAll()

void ChannelModel::SetCcAll ( int  controlnumber,
int  min,
int  max,
rsj::CCmethod  controltype 
)
309{
310 try {
311 if (IsNrpn(controlnumber)) {
312 for (auto a {kMaxMidi + 1}; a <= kMaxNrpn; ++a) { SetCc(a, min, max, controltype); }
313 }
314 else {
315 for (auto a {0}; a <= kMaxMidi; ++a) { SetCc(a, min, max, controltype); }
316 }
317 }
318 catch (const std::exception& e) {
319 rsj::ExceptionResponse(e, std::source_location::current());
320 throw;
321 }
322}

◆ SetCcMax()

void ChannelModel::SetCcMax ( int  controlnumber,
int  value 
)
325{
326 try {
327 Expects(value <= kMaxNrpn && value >= 0);
328 if (cc_method_.at(controlnumber) != rsj::CCmethod::kAbsolute) {
329 cc_high_.at(controlnumber) = value < 0 ? 1000 : value;
330 }
331 else {
332 const auto max {IsNrpn(controlnumber) ? kMaxNrpn : kMaxMidi};
333 cc_high_.at(controlnumber) =
334 value <= cc_low_.at(controlnumber) || value > max ? max : value;
335 }
336#ifdef __cpp_lib_atomic_ref
337 std::atomic_ref(current_v_.at(controlnumber))
338 .store(CenterCc(controlnumber), std::memory_order_release);
339#else
340 current_v_.at(controlnumber).store(CenterCc(controlnumber), std::memory_order_release);
341#endif
342 }
343 catch (const std::exception& e) {
344 rsj::ExceptionResponse(e, std::source_location::current());
345 throw;
346 }
347}
int CenterCc(int controlnumber) const noexcept
Definition ControlsModel.h:179

◆ SetCcMethod()

void ChannelModel::SetCcMethod ( int  controlnumber,
rsj::CCmethod  value 
)
inline
168 {
169 cc_method_.at(controlnumber) = value;
170 }

◆ SetCcMin()

void ChannelModel::SetCcMin ( int  controlnumber,
int  value 
)
350{
351 try {
352 if (cc_method_.at(controlnumber) != rsj::CCmethod::kAbsolute) {
353 cc_low_.at(controlnumber) = 0;
354 }
355 else {
356 cc_low_.at(controlnumber) = value < 0 || value >= cc_high_.at(controlnumber) ? 0 : value;
357 }
358#ifdef __cpp_lib_atomic_ref
359 std::atomic_ref(current_v_.at(controlnumber))
360 .store(CenterCc(controlnumber), std::memory_order_release);
361#else
362 current_v_.at(controlnumber).store(CenterCc(controlnumber), std::memory_order_release);
363#endif
364 }
365 catch (const std::exception& e) {
366 rsj::ExceptionResponse(e, std::source_location::current());
367 throw;
368 }
369}

◆ SetPwMax()

void ChannelModel::SetPwMax ( int  value)
noexcept
372{
373 pitch_wheel_max_ = value > kMaxNrpn || value <= pitch_wheel_min_ ? kMaxNrpn : value;
374 pitch_wheel_current_.store(CenterPw(), std::memory_order_release);
375}
int CenterPw() const noexcept
Definition ControlsModel.h:186

◆ SetPwMin()

void ChannelModel::SetPwMin ( int  value)
noexcept
378{
379 pitch_wheel_min_ = value < 0 || value >= pitch_wheel_max_ ? 0 : value;
380 pitch_wheel_current_.store(CenterPw(), std::memory_order_release);
381}

◆ SetToCenter()

int ChannelModel::SetToCenter ( rsj::MessageType  controltype,
int  controlnumber 
)
134{
135 try {
136 auto retval {0};
137 switch (controltype) {
139 retval = CenterPw();
140 pitch_wheel_current_.store(retval, std::memory_order_release);
141 break;
143 if (cc_method_.at(controlnumber) == rsj::CCmethod::kAbsolute) {
144 retval = CenterCc(controlnumber);
145#ifdef __cpp_lib_atomic_ref
146 std::atomic_ref(current_v_.at(controlnumber)).store(retval, std::memory_order_release);
147#else
148 current_v_.at(controlnumber).store(retval, std::memory_order_release);
149#endif
150 }
151 break;
158 break;
159 }
160 return retval;
161 }
162 catch (const std::exception& e) {
163 rsj::ExceptionResponse(e, std::source_location::current());
164 throw;
165 }
166}

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
214{};

◆ cc_low_

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

◆ cc_method_

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

◆ current_v_

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

◆ kBit14

constexpr int ChannelModel::kBit14 {0x2000}
staticconstexprprivate
132{0x2000};

◆ kBit7

constexpr int ChannelModel::kBit7 {0x40}
staticconstexprprivate
133{0x40};

◆ kLow13Bits

constexpr int ChannelModel::kLow13Bits {0x1FFF}
staticconstexprprivate
134{0x1FFF};

◆ kLow6Bits

constexpr int ChannelModel::kLow6Bits {0x3F}
staticconstexprprivate
135{0x3F};

◆ kMaxControls

constexpr size_t ChannelModel::kMaxControls {0x4000}
staticconstexprprivate
140{0x4000};

◆ kMaxMidi

constexpr int ChannelModel::kMaxMidi {0x7F}
staticconstexprprivate
136{0x7F};

◆ kMaxMidiHalf

constexpr int ChannelModel::kMaxMidiHalf {kMaxMidi / 2}
staticconstexprprivate
137{kMaxMidi / 2};

◆ kMaxNrpn

constexpr int ChannelModel::kMaxNrpn {0x3FFF}
staticconstexprprivate
138{0x3FFF};

◆ kMaxNrpnHalf

constexpr int ChannelModel::kMaxNrpnHalf {kMaxNrpn / 2}
staticconstexprprivate
139{kMaxNrpn / 2};

◆ pitch_wheel_current_

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

◆ pitch_wheel_max_

int ChannelModel::pitch_wheel_max_ {kMaxNrpn}
private
210{kMaxNrpn};

◆ pitch_wheel_min_

int ChannelModel::pitch_wheel_min_ {0}
private
211{0};

◆ settings_to_save_

std::vector<rsj::SettingsStruct> ChannelModel::settings_to_save_ {}
mutableprivate
209{};

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