Debian Codegraph @

BambooTracker/instrument/instruments_manager.cpp

raw
1 /*
2 * Copyright (C) 2018-2023 Rerrah
3 *
4 * Permission is hereby granted, free of charge, to any person
5 * obtaining a copy of this software and associated documentation
6 * files (the "Software"), to deal in the Software without
7 * restriction, including without limitation the rights to use,
8 * copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following
11 * conditions:
12 *
13 * The above copyright notice and this permission notice shall be
14 * included in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 * OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26 #include "instruments_manager.hpp"
27 #include <utility>
28 #include <unordered_map>
29 #include <algorithm>
30 #include <functional>
31 #include <type_traits>
32 #include <stdexcept>
33 #include "instrument.hpp"
34 #include "note.hpp"
35 #include "utils.hpp"
36
37 namespace
38 {
39 // Constant
40 const FMEnvelopeParameter ENV_FM_PARAMS[] = {
41 FMEnvelopeParameter::AL, FMEnvelopeParameter::FB, FMEnvelopeParameter::AR1,
42 FMEnvelopeParameter::DR1, FMEnvelopeParameter::SR1, FMEnvelopeParameter::RR1,
43 FMEnvelopeParameter::SL1, FMEnvelopeParameter::TL1, FMEnvelopeParameter::KS1,
44 FMEnvelopeParameter::ML1, FMEnvelopeParameter::DT1, FMEnvelopeParameter::AR2,
45 FMEnvelopeParameter::DR2, FMEnvelopeParameter::SR2, FMEnvelopeParameter::RR2,
46 FMEnvelopeParameter::SL2, FMEnvelopeParameter::TL2, FMEnvelopeParameter::KS2,
47 FMEnvelopeParameter::ML2, FMEnvelopeParameter::DT2, FMEnvelopeParameter::AR3,
48 FMEnvelopeParameter::DR3, FMEnvelopeParameter::SR3, FMEnvelopeParameter::RR3,
49 FMEnvelopeParameter::SL3, FMEnvelopeParameter::TL3, FMEnvelopeParameter::KS3,
50 FMEnvelopeParameter::ML3, FMEnvelopeParameter::DT3, FMEnvelopeParameter::AR4,
51 FMEnvelopeParameter::DR4, FMEnvelopeParameter::SR4, FMEnvelopeParameter::RR4,
52 FMEnvelopeParameter::SL4, FMEnvelopeParameter::TL4, FMEnvelopeParameter::KS4,
53 FMEnvelopeParameter::ML4, FMEnvelopeParameter::DT4 };
54
55 const FMOperatorType FM_OP_TYPES[] = {
56 FMOperatorType::All, FMOperatorType::Op1, FMOperatorType::Op2,
57 FMOperatorType::Op3, FMOperatorType::Op4
58 };
59
60 // Property initialization helper
61 inline auto makeEnvelopeFMSharedPtr(int n)
62 {
63 return std::make_shared<EnvelopeFM>(n);
64 }
65
66 inline auto makeLFOFMSharedPtr(int n)
67 {
68 return std::make_shared<LFOFM>(n);
69 }
70
71 inline auto makeOperatorSequenceFMSharedPtr(int n)
72 {
73 return std::make_shared<InstrumentSequenceProperty<
74 FMOperatorSequenceUnit>>(n, SequenceType::PlainSequence, FMOperatorSequenceUnit(0), FMOperatorSequenceUnit());
75 }
76
77 inline auto makeArpeggioSharedPtr(int n)
78 {
79 return std::make_shared<InstrumentSequenceProperty<
80 ArpeggioUnit>>(n, SequenceType::AbsoluteSequence, ArpeggioUnit(Note::DEFAULT_NOTE_NUM), ArpeggioUnit());
81 }
82
83 inline auto makePitchSharedPtr(int n)
84 {
85 return std::make_shared<InstrumentSequenceProperty<
86 PitchUnit>>(n, SequenceType::AbsoluteSequence, PitchUnit(SEQ_PITCH_CENTER), PitchUnit());
87 }
88
89 inline auto makePanSharedPtr(int n)
90 {
91 return std::make_shared<InstrumentSequenceProperty<
92 PanUnit>>(n, SequenceType::AbsoluteSequence, PanUnit(PanType::CENTER), PanUnit());
93 }
94
95 inline auto makeWaveformSSGSharedPtr(int n)
96 {
97 return std::make_shared<InstrumentSequenceProperty<
98 SSGWaveformUnit>>(n, SequenceType::PlainSequence,
99 SSGWaveformUnit::makeOnlyDataUnit(SSGWaveformType::SQUARE),
100 SSGWaveformUnit());
101 }
102
103 inline auto makeToneNoiseSSGSharedPtr(int n)
104 {
105 return std::make_shared<InstrumentSequenceProperty<
106 SSGToneNoiseUnit>>(n, SequenceType::PlainSequence, SSGToneNoiseUnit(0), SSGToneNoiseUnit());
107 }
108
109 inline auto makeEnvelopeSSGSharedPtr(int n)
110 {
111 return std::make_shared<InstrumentSequenceProperty<
112 SSGWaveformUnit>>(n, SequenceType::PlainSequence,
113 SSGEnvelopeUnit::makeOnlyDataUnit(15), SSGEnvelopeUnit(), 15);
114 }
115
116 inline auto makeSampleADPCMSharedPtr(int n)
117 {
118 return std::make_shared<SampleADPCM>(n);
119 }
120
121 inline auto makeEnvelopeADPCMSharedPtr(int n)
122 {
123 return std::make_shared<InstrumentSequenceProperty<
124 ADPCMEnvelopeUnit>>(n, SequenceType::PlainSequence,
125 ADPCMEnvelopeUnit(255), ADPCMEnvelopeUnit(), 127);
126 }
127
128 // Utility functor
129 template <class propArray>
130 struct IsUsed
131 {
132 using ArgType = typename std::add_const<propArray>::type::const_reference;
133 bool operator()(ArgType prop) const
134 {
135 return prop->isUserInstrument();
136 }
137 };
138
139 template <class propArray>
140 struct IsEdited
141 {
142 using ArgType = typename std::add_const<propArray>::type::const_reference;
143 bool operator()(ArgType prop) const
144 {
145 return prop->isEdited();
146 }
147 };
148
149 template <class propArray>
150 struct IsUsedOrEdited
151 {
152 using ArgType = typename std::add_const<propArray>::type::const_reference;
153 bool operator()(ArgType prop) const
154 {
155 return (prop->isUserInstrument() || prop->isEdited());
156 }
157 };
158
159 // Common process for properties
160 template <class propArray>
161 int cloneProperty(propArray& aryRef, int srcNum)
162 {
163 // Must find an unused property since the count of used properties <= the count of instruments
164 auto&& it = std::find_if_not(aryRef.begin(), aryRef.end(), IsUsed<propArray>());
165 int cloneNum = std::distance(aryRef.begin(), it);
166 *it = aryRef.at(static_cast<size_t>(srcNum))->clone();
167 (*it)->setNumber(cloneNum);
168 return cloneNum;
169 }
170
171 template <class propArray>
172 int findFirstAssignableProperty(propArray& aryRef, bool regardingUnedited, int startOffs = 0)
173 {
174 std::function<bool(typename propArray::const_reference)> cond;
175 if (regardingUnedited) cond = IsUsedOrEdited<propArray>();
176 else cond = IsUsed<propArray>();
177 auto&& it = std::find_if_not(aryRef.cbegin() + startOffs, aryRef.cend(), cond);
178
179 if (it == aryRef.cend()) return -1;
180
181 if (!regardingUnedited) (*it)->clearParameters();
182 return std::distance(aryRef.cbegin(), it);
183 }
184 }
185
186 InstrumentsManager::InstrumentsManager(bool unedited)
187 : regardingUnedited_(unedited)
188 {
189 clearAll();
190 }
191
192 void InstrumentsManager::addInstrument(int instNum, InstrumentType type, const std::string& name)
193 {
194 if (instNum < 0 || static_cast<int>(insts_.size()) <= instNum) return;
195
196 switch (type) {
197 case InstrumentType::FM:
198 {
199 auto fm = new InstrumentFM(instNum, name, this);
200 int envNum = findFirstAssignableEnvelopeFM();
201 if (envNum == -1) envNum = static_cast<int>(envFM_.size()) - 1;
202 fm->setEnvelopeNumber(envNum);
203 envFM_.at(static_cast<size_t>(envNum))->registerUserInstrument(instNum);
204 int lfoNum = findFirstAssignableLFOFM();
205 if (lfoNum == -1) lfoNum = static_cast<int>(lfoFM_.size()) - 1;
206 fm->setLFONumber(lfoNum);
207 fm->setLFOEnabled(false);
208 for (auto param : ENV_FM_PARAMS) {
209 int opSeqNum = findFirstAssignableOperatorSequenceFM(param);
210 if (opSeqNum == -1) opSeqNum = static_cast<int>(opSeqFM_.at(param).size()) - 1;
211 fm->setOperatorSequenceNumber(param, opSeqNum);
212 fm->setOperatorSequenceEnabled(param, false);
213 }
214 int arpNum = findFirstAssignableArpeggioFM();
215 if (arpNum == -1) arpNum = static_cast<int>(arpFM_.size()) - 1;
216 int ptNum = findFirstAssignablePitchFM();
217 if (ptNum == -1) ptNum = static_cast<int>(ptFM_.size()) - 1;
218 for (auto type : FM_OP_TYPES) {
219 fm->setArpeggioNumber(type, arpNum);
220 fm->setArpeggioEnabled(type, false);
221 fm->setPitchNumber(type, ptNum);
222 fm->setPitchEnabled(type, false);
223 }
224 int panNum = findFirstAssignablePanFM();
225 if (panNum == -1) panNum = static_cast<int>(panFM_.size()) - 1;
226 fm->setPanNumber(panNum);
227 fm->setPanEnabled(false);
228 insts_.at(static_cast<size_t>(instNum)).reset(fm);
229 break;
230 }
231 case InstrumentType::SSG:
232 {
233 auto ssg = new InstrumentSSG(instNum, name, this);
234 int wfNum = findFirstAssignableWaveformSSG();
235 if (wfNum == -1) wfNum = static_cast<int>(wfSSG_.size()) - 1;
236 ssg->setWaveformNumber(wfNum);
237 ssg->setWaveformEnabled(false);
238 int tnNum = findFirstAssignableToneNoiseSSG();
239 if (tnNum == -1) tnNum = static_cast<int>(tnSSG_.size()) - 1;
240 ssg->setToneNoiseNumber(tnNum);
241 ssg->setToneNoiseEnabled(false);
242 int envNum = findFirstAssignableEnvelopeSSG();
243 if (envNum == -1) envNum = static_cast<int>(envSSG_.size()) - 1;
244 ssg->setEnvelopeNumber(envNum);
245 ssg->setEnvelopeEnabled(false);
246 int arpNum = findFirstAssignableArpeggioSSG();
247 if (arpNum == -1) arpNum = static_cast<int>(arpSSG_.size()) - 1;
248 ssg->setArpeggioNumber(arpNum);
249 ssg->setArpeggioEnabled(false);
250 int ptNum = findFirstAssignablePitchSSG();
251 if (ptNum == -1) ptNum = static_cast<int>(ptSSG_.size()) - 1;
252 ssg->setPitchNumber(ptNum);
253 ssg->setPitchEnabled(false);
254 insts_.at(static_cast<size_t>(instNum)).reset(ssg);
255 break;
256 }
257 case InstrumentType::ADPCM:
258 {
259 auto adpcm = new InstrumentADPCM(instNum, name, this);
260 int sampNum = findFirstAssignableSampleADPCM();
261 if (sampNum == -1) sampNum = static_cast<int>(sampADPCM_.size()) - 1;
262 adpcm->setSampleNumber(sampNum);
263 sampADPCM_.at(static_cast<size_t>(sampNum))->registerUserInstrument(instNum);
264 int envNum = findFirstAssignableEnvelopeADPCM();
265 if (envNum == -1) envNum = static_cast<int>(envADPCM_.size()) - 1;
266 adpcm->setEnvelopeNumber(envNum);
267 adpcm->setEnvelopeEnabled(false);
268 int arpNum = findFirstAssignableArpeggioADPCM();
269 if (arpNum == -1) arpNum = static_cast<int>(arpADPCM_.size()) - 1;
270 adpcm->setArpeggioNumber(arpNum);
271 adpcm->setArpeggioEnabled(false);
272 int ptNum = findFirstAssignablePitchADPCM();
273 if (ptNum == -1) ptNum = static_cast<int>(ptADPCM_.size()) - 1;
274 adpcm->setPitchNumber(ptNum);
275 adpcm->setPitchEnabled(false);
276 int panNum = findFirstAssignablePanADPCM();
277 if (panNum == -1) panNum = static_cast<int>(panADPCM_.size()) - 1;
278 adpcm->setPanNumber(panNum);
279 adpcm->setPanEnabled(false);
280 insts_.at(static_cast<size_t>(instNum)).reset(adpcm);
281 break;
282 }
283 case InstrumentType::Drumkit:
284 {
285 insts_.at(static_cast<size_t>(instNum)).reset(new InstrumentDrumkit(instNum, name, this));
286 break;
287 }
288 default:
289 throw std::invalid_argument("invalid instrument type");
290 }
291 }
292
293 void InstrumentsManager::addInstrument(AbstractInstrument* newInstPtr)
294 {
295 int num = newInstPtr->getNumber();
296 std::shared_ptr<AbstractInstrument>& inst = insts_.at(static_cast<size_t>(num));
297 inst.reset(newInstPtr);
298
299 switch (inst->getType()) {
300 case InstrumentType::FM:
301 {
302 auto fm = std::dynamic_pointer_cast<InstrumentFM>(inst);
303 envFM_.at(static_cast<size_t>(fm->getEnvelopeNumber()))->registerUserInstrument(num);
304 if (fm->getLFOEnabled()) lfoFM_.at(static_cast<size_t>(fm->getLFONumber()))->registerUserInstrument(num);
305 for (auto p : ENV_FM_PARAMS) {
306 if (fm->getOperatorSequenceEnabled(p))
307 opSeqFM_.at(p).at(static_cast<size_t>(fm->getOperatorSequenceNumber(p)))
308 ->registerUserInstrument(num);
309 }
310 for (auto t : FM_OP_TYPES) {
311 if (fm->getArpeggioEnabled(t))
312 arpFM_.at(static_cast<size_t>(fm->getArpeggioNumber(t)))->registerUserInstrument(num);
313 if (fm->getPitchEnabled(t))
314 ptFM_.at(static_cast<size_t>(fm->getPitchNumber(t)))->registerUserInstrument(num);
315 }
316 if (fm->getPanEnabled())
317 panFM_.at(static_cast<size_t>(fm->getPanNumber()))->registerUserInstrument(num);
318 break;
319 }
320 case InstrumentType::SSG:
321 {
322 auto ssg = std::dynamic_pointer_cast<InstrumentSSG>(inst);
323 if (ssg->getWaveformEnabled())
324 wfSSG_.at(static_cast<size_t>(ssg->getWaveformNumber()))->registerUserInstrument(num);
325 if (ssg->getToneNoiseEnabled())
326 tnSSG_.at(static_cast<size_t>(ssg->getToneNoiseNumber()))->registerUserInstrument(num);
327 if (ssg->getEnvelopeEnabled())
328 envSSG_.at(static_cast<size_t>(ssg->getEnvelopeNumber()))->registerUserInstrument(num);
329 if (ssg->getArpeggioEnabled())
330 arpSSG_.at(static_cast<size_t>(ssg->getArpeggioNumber()))->registerUserInstrument(num);
331 if (ssg->getPitchEnabled())
332 ptSSG_.at(static_cast<size_t>(ssg->getPitchNumber()))->registerUserInstrument(num);
333 break;
334 }
335 case InstrumentType::ADPCM:
336 {
337 auto adpcm = std::dynamic_pointer_cast<InstrumentADPCM>(inst);
338 sampADPCM_.at(static_cast<size_t>(adpcm->getSampleNumber()))->registerUserInstrument(num);
339 if (adpcm->getEnvelopeEnabled())
340 envADPCM_.at(static_cast<size_t>(adpcm->getEnvelopeNumber()))->registerUserInstrument(num);
341 if (adpcm->getArpeggioEnabled())
342 arpADPCM_.at(static_cast<size_t>(adpcm->getArpeggioNumber()))->registerUserInstrument(num);
343 if (adpcm->getPitchEnabled())
344 ptADPCM_.at(static_cast<size_t>(adpcm->getPitchNumber()))->registerUserInstrument(num);
345 if (adpcm->getPanEnabled())
346 panADPCM_.at(static_cast<size_t>(adpcm->getPanNumber()))->registerUserInstrument(num);
347 break;
348 }
349 case InstrumentType::Drumkit:
350 {
351 auto kit = std::dynamic_pointer_cast<InstrumentDrumkit>(inst);
352 for (const auto& key : kit->getAssignedKeys()) {
353 sampADPCM_.at(static_cast<size_t>(kit->getSampleNumber(key)))->registerUserInstrument(num);
354 }
355 break;
356 }
357 default:
358 throw std::invalid_argument("invalid instrument type");
359 }
360 }
361
362 std::unique_ptr<AbstractInstrument> InstrumentsManager::removeInstrument(int instNum)
363 {
364 std::shared_ptr<AbstractInstrument>& inst = insts_.at(static_cast<size_t>(instNum));
365 switch (inst->getType()) {
366 case InstrumentType::FM:
367 {
368 auto fm = std::dynamic_pointer_cast<InstrumentFM>(inst);
369 envFM_.at(static_cast<size_t>(fm->getEnvelopeNumber()))->deregisterUserInstrument(instNum);
370 if (fm->getLFOEnabled())
371 lfoFM_.at(static_cast<size_t>(fm->getLFONumber()))->deregisterUserInstrument(instNum);
372 for (auto p : ENV_FM_PARAMS) {
373 if (fm->getOperatorSequenceEnabled(p))
374 opSeqFM_.at(p).at(static_cast<size_t>(fm->getOperatorSequenceNumber(p)))
375 ->deregisterUserInstrument(instNum);
376 }
377 for (auto t : FM_OP_TYPES) {
378 if (fm->getArpeggioEnabled(t))
379 arpFM_.at(static_cast<size_t>(fm->getArpeggioNumber(t)))->deregisterUserInstrument(instNum);
380 if (fm->getPitchEnabled(t))
381 ptFM_.at(static_cast<size_t>(fm->getPitchNumber(t)))->deregisterUserInstrument(instNum);
382 }
383 if (fm->getPanEnabled())
384 panFM_.at(static_cast<size_t>(fm->getPanNumber()))->deregisterUserInstrument(instNum);
385 break;
386 }
387 case InstrumentType::SSG:
388 {
389 auto ssg = std::dynamic_pointer_cast<InstrumentSSG>(inst);
390 if (ssg->getWaveformEnabled())
391 wfSSG_.at(static_cast<size_t>(ssg->getWaveformNumber()))->deregisterUserInstrument(instNum);
392 if (ssg->getToneNoiseEnabled())
393 tnSSG_.at(static_cast<size_t>(ssg->getToneNoiseNumber()))->deregisterUserInstrument(instNum);
394 if (ssg->getEnvelopeEnabled())
395 envSSG_.at(static_cast<size_t>(ssg->getEnvelopeNumber()))->deregisterUserInstrument(instNum);
396 if (ssg->getArpeggioEnabled())
397 arpSSG_.at(static_cast<size_t>(ssg->getArpeggioNumber()))->deregisterUserInstrument(instNum);
398 if (ssg->getPitchEnabled())
399 ptSSG_.at(static_cast<size_t>(ssg->getPitchNumber()))->deregisterUserInstrument(instNum);
400 break;
401 }
402 case InstrumentType::ADPCM:
403 {
404 auto adpcm = std::dynamic_pointer_cast<InstrumentADPCM>(inst);
405 sampADPCM_.at(static_cast<size_t>(adpcm->getSampleNumber()))->deregisterUserInstrument(instNum);
406 if (adpcm->getEnvelopeEnabled())
407 envADPCM_.at(static_cast<size_t>(adpcm->getEnvelopeNumber()))->deregisterUserInstrument(instNum);
408 if (adpcm->getArpeggioEnabled())
409 arpADPCM_.at(static_cast<size_t>(adpcm->getArpeggioNumber()))->deregisterUserInstrument(instNum);
410 if (adpcm->getPitchEnabled())
411 ptADPCM_.at(static_cast<size_t>(adpcm->getPitchNumber()))->deregisterUserInstrument(instNum);
412 if (adpcm->getPanEnabled())
413 panADPCM_.at(static_cast<size_t>(adpcm->getPanNumber()))->deregisterUserInstrument(instNum);
414 break;
415 }
416 case InstrumentType::Drumkit:
417 {
418 auto kit = std::dynamic_pointer_cast<InstrumentDrumkit>(inst);
419 for (const int& key : kit->getAssignedKeys()) {
420 sampADPCM_.at(static_cast<size_t>(kit->getSampleNumber(key)))->deregisterUserInstrument(instNum);
421 }
422 break;
423 }
424 default:
425 throw std::invalid_argument("invalid instrument type");
426 }
427
428 std::unique_ptr<AbstractInstrument> clone(inst->clone());
429 inst.reset();
430 return clone;
431 }
432
433 void InstrumentsManager::cloneInstrument(int cloneInstNum, int refInstNum)
434 {
435 std::shared_ptr<AbstractInstrument>& refInst = insts_.at(static_cast<size_t>(refInstNum));
436 addInstrument(cloneInstNum, refInst->getType(), refInst->getName());
437
438 switch (refInst->getType()) {
439 case InstrumentType::FM:
440 {
441 auto refFm = std::dynamic_pointer_cast<InstrumentFM>(refInst);
442 auto cloneFm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(cloneInstNum)));
443 setInstrumentFMEnvelope(cloneInstNum, refFm->getEnvelopeNumber());
444 setInstrumentFMLFO(cloneInstNum, refFm->getLFONumber());
445 if (refFm->getLFOEnabled()) setInstrumentFMLFOEnabled(cloneInstNum, true);
446 for (auto p : ENV_FM_PARAMS) {
447 setInstrumentFMOperatorSequence(cloneInstNum, p, refFm->getOperatorSequenceNumber(p));
448 if (refFm->getOperatorSequenceEnabled(p)) setInstrumentFMOperatorSequenceEnabled(cloneInstNum, p, true);
449 }
450 for (auto t : FM_OP_TYPES) {
451 setInstrumentFMArpeggio(cloneInstNum, t, refFm->getArpeggioNumber(t));
452 if (refFm->getArpeggioEnabled(t)) setInstrumentFMArpeggioEnabled(cloneInstNum, t, true);
453 setInstrumentFMPitch(cloneInstNum, t, refFm->getPitchNumber(t));
454 if (refFm->getPitchEnabled(t)) setInstrumentFMPitchEnabled(cloneInstNum, t, true);
455 setInstrumentFMEnvelopeResetEnabled(cloneInstNum, t, refFm->getEnvelopeResetEnabled(t));
456 }
457 break;
458 }
459 case InstrumentType::SSG:
460 {
461 auto refSsg = std::dynamic_pointer_cast<InstrumentSSG>(refInst);
462 auto cloneSsg = std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(cloneInstNum)));
463 setInstrumentSSGWaveform(cloneInstNum, refSsg->getWaveformNumber());
464 if (refSsg->getWaveformEnabled()) setInstrumentSSGWaveformEnabled(cloneInstNum, true);
465 setInstrumentSSGToneNoise(cloneInstNum, refSsg->getToneNoiseNumber());
466 if (refSsg->getToneNoiseEnabled()) setInstrumentSSGToneNoiseEnabled(cloneInstNum, true);
467 setInstrumentSSGEnvelope(cloneInstNum, refSsg->getEnvelopeNumber());
468 if (refSsg->getEnvelopeEnabled()) setInstrumentSSGEnvelopeEnabled(cloneInstNum, true);
469 setInstrumentSSGArpeggio(cloneInstNum, refSsg->getArpeggioNumber());
470 if (refSsg->getArpeggioEnabled()) setInstrumentSSGArpeggioEnabled(cloneInstNum, true);
471 setInstrumentSSGPitch(cloneInstNum, refSsg->getPitchNumber());
472 if (refSsg->getPitchEnabled()) setInstrumentSSGPitchEnabled(cloneInstNum, true);
473 break;
474 }
475 case InstrumentType::ADPCM:
476 {
477 auto refAdpcm = std::dynamic_pointer_cast<InstrumentADPCM>(refInst);
478 auto cloneAdpcm = std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(cloneInstNum)));
479 setInstrumentADPCMSample(cloneInstNum, refAdpcm->getSampleNumber());
480 setInstrumentADPCMEnvelope(cloneInstNum, refAdpcm->getEnvelopeNumber());
481 if (refAdpcm->getEnvelopeEnabled()) setInstrumentADPCMEnvelopeEnabled(cloneInstNum, true);
482 setInstrumentADPCMArpeggio(cloneInstNum, refAdpcm->getArpeggioNumber());
483 if (refAdpcm->getArpeggioEnabled()) setInstrumentADPCMArpeggioEnabled(cloneInstNum, true);
484 setInstrumentADPCMPitch(cloneInstNum, refAdpcm->getPitchNumber());
485 if (refAdpcm->getPitchEnabled()) setInstrumentADPCMPitchEnabled(cloneInstNum, true);
486 break;
487 }
488 case InstrumentType::Drumkit:
489 {
490 auto refKit = std::dynamic_pointer_cast<InstrumentDrumkit>(refInst);
491 auto cloneKit = std::dynamic_pointer_cast<InstrumentDrumkit>(insts_.at(static_cast<size_t>(cloneInstNum)));
492 for (const int& key : refKit->getAssignedKeys()) {
493 setInstrumentDrumkitSamples(cloneInstNum, key, refKit->getSampleNumber(key));
494 setInstrumentDrumkitPitch(cloneInstNum, key, refKit->getPitch(key));
495 setInstrumentDrumkitPan(cloneInstNum, key, refKit->getPan(key));
496 }
497 break;
498 }
499 default:
500 throw std::invalid_argument("invalid instrument type");
501 }
502 }
503
504 void InstrumentsManager::deepCloneInstrument(int cloneInstNum, int refInstNum)
505 {
506 std::shared_ptr<AbstractInstrument>& refInst = insts_.at(static_cast<size_t>(refInstNum));
507 addInstrument(cloneInstNum, refInst->getType(), refInst->getName());
508
509 switch (refInst->getType()) {
510 case InstrumentType::FM:
511 {
512 auto refFm = std::dynamic_pointer_cast<InstrumentFM>(refInst);
513 auto cloneFm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(cloneInstNum)));
514
515 envFM_[static_cast<size_t>(cloneFm->getEnvelopeNumber())]->deregisterUserInstrument(cloneInstNum); // Remove temporary number
516 int envNum = cloneProperty(envFM_, refFm->getEnvelopeNumber());
517 cloneFm->setEnvelopeNumber(envNum);
518 envFM_[static_cast<size_t>(envNum)]->registerUserInstrument(cloneInstNum);
519 if (refFm->getLFOEnabled()) {
520 cloneFm->setLFOEnabled(true);
521 int lfoNum = cloneProperty(lfoFM_, refFm->getLFONumber());
522 cloneFm->setLFONumber(lfoNum);
523 lfoFM_[static_cast<size_t>(lfoNum)]->registerUserInstrument(cloneInstNum);
524 }
525
526 for (auto envParam : ENV_FM_PARAMS) {
527 if (refFm->getOperatorSequenceEnabled(envParam)) {
528 cloneFm->setOperatorSequenceEnabled(envParam, true);
529 int opSeqNum = cloneProperty(opSeqFM_.at(envParam), refFm->getOperatorSequenceNumber(envParam));
530 cloneFm->setOperatorSequenceNumber(envParam, opSeqNum);
531 opSeqFM_.at(envParam)[static_cast<size_t>(opSeqNum)]->registerUserInstrument(cloneInstNum);
532 }
533 }
534
535 std::unordered_map<int, int> arpCloneMap;
536 for (auto opType : FM_OP_TYPES) {
537 if (refFm->getArpeggioEnabled(opType)) {
538 cloneFm->setArpeggioEnabled(opType, true);
539 int srcNum = refFm->getArpeggioNumber(opType);
540 if (!arpCloneMap.count(srcNum)) {
541 arpCloneMap[srcNum] = cloneProperty(arpFM_, srcNum);
542 }
543 cloneFm->setArpeggioNumber(opType, arpCloneMap[srcNum]);
544 arpFM_[static_cast<size_t>(arpCloneMap[srcNum])]->registerUserInstrument(cloneInstNum);
545 }
546 }
547
548 std::unordered_map<int, int> ptCloneMap;
549 for (auto opType : FM_OP_TYPES) {
550 if (refFm->getPitchEnabled(opType)) {
551 cloneFm->setPitchEnabled(opType, true);
552 int srcNum = refFm->getPitchNumber(opType);
553 if (!ptCloneMap.count(srcNum)) {
554 ptCloneMap[srcNum] = cloneProperty(ptFM_, srcNum);
555 }
556 cloneFm->setPitchNumber(opType, ptCloneMap[srcNum]);
557 ptFM_[static_cast<size_t>(ptCloneMap[srcNum])]->registerUserInstrument(cloneInstNum);
558 }
559 }
560
561 if (refFm->getPanEnabled()) {
562 cloneFm->setPanEnabled(true);
563 int panNum = cloneProperty(panFM_, refFm->getPanNumber());
564 cloneFm->setPanNumber(panNum);
565 panFM_[static_cast<size_t>(panNum)]->registerUserInstrument(cloneInstNum);
566 }
567
568 for (auto t : FM_OP_TYPES)
569 setInstrumentFMEnvelopeResetEnabled(cloneInstNum, t, refFm->getEnvelopeResetEnabled(t));
570 break;
571 }
572 case InstrumentType::SSG:
573 {
574 auto refSsg = std::dynamic_pointer_cast<InstrumentSSG>(refInst);
575 auto cloneSsg = std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(cloneInstNum)));
576
577 if (refSsg->getWaveformEnabled()) {
578 cloneSsg->setWaveformEnabled(true);
579 int wfNum = cloneProperty(wfSSG_, refSsg->getWaveformNumber());
580 cloneSsg->setWaveformNumber(wfNum);
581 wfSSG_[static_cast<size_t>(wfNum)]->registerUserInstrument(cloneInstNum);
582 }
583 if (refSsg->getToneNoiseEnabled()) {
584 cloneSsg->setToneNoiseEnabled(true);
585 int tnNum = cloneProperty(tnSSG_, refSsg->getToneNoiseNumber());
586 cloneSsg->setToneNoiseNumber(tnNum);
587 tnSSG_[static_cast<size_t>(tnNum)]->registerUserInstrument(cloneInstNum);
588 }
589 if (refSsg->getEnvelopeEnabled()) {
590 cloneSsg->setEnvelopeEnabled(true);
591 int envNum = cloneProperty(envSSG_, refSsg->getEnvelopeNumber());
592 cloneSsg->setEnvelopeNumber(envNum);
593 envSSG_[static_cast<size_t>(envNum)]->registerUserInstrument(cloneInstNum);
594 }
595 if (refSsg->getArpeggioEnabled()) {
596 cloneSsg->setArpeggioEnabled(true);
597 int arpNum = cloneProperty(arpSSG_, refSsg->getArpeggioNumber());
598 cloneSsg->setArpeggioNumber(arpNum);
599 arpSSG_[static_cast<size_t>(arpNum)]->registerUserInstrument(cloneInstNum);
600 }
601 if (refSsg->getPitchEnabled()) {
602 cloneSsg->setPitchEnabled(true);
603 int ptNum = cloneProperty(ptSSG_, refSsg->getPitchNumber());
604 cloneSsg->setPitchNumber(ptNum);
605 ptSSG_[static_cast<size_t>(ptNum)]->registerUserInstrument(cloneInstNum);
606 }
607 break;
608 }
609 case InstrumentType::ADPCM:
610 {
611 auto refAdpcm = std::dynamic_pointer_cast<InstrumentADPCM>(refInst);
612 auto cloneAdpcm = std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(cloneInstNum)));
613
614 sampADPCM_[static_cast<size_t>(cloneAdpcm->getSampleNumber())]->deregisterUserInstrument(cloneInstNum); // Remove temporary number
615 int sampNum = cloneProperty(sampADPCM_, refAdpcm->getSampleNumber());
616 cloneAdpcm->setSampleNumber(sampNum);
617 sampADPCM_[static_cast<size_t>(sampNum)]->registerUserInstrument(cloneInstNum);
618 if (refAdpcm->getEnvelopeEnabled()) {
619 cloneAdpcm->setEnvelopeEnabled(true);
620 int envNum = cloneProperty(envADPCM_, refAdpcm->getEnvelopeNumber());
621 cloneAdpcm->setEnvelopeNumber(envNum);
622 envADPCM_[static_cast<size_t>(envNum)]->registerUserInstrument(cloneInstNum);
623 }
624 if (refAdpcm->getArpeggioEnabled()) {
625 cloneAdpcm->setArpeggioEnabled(true);
626 int arpNum = cloneProperty(arpADPCM_, refAdpcm->getArpeggioNumber());
627 cloneAdpcm->setArpeggioNumber(arpNum);
628 arpADPCM_[static_cast<size_t>(arpNum)]->registerUserInstrument(cloneInstNum);
629 }
630 if (refAdpcm->getPitchEnabled()) {
631 cloneAdpcm->setPitchEnabled(true);
632 int ptNum = cloneProperty(ptADPCM_, refAdpcm->getPitchNumber());
633 cloneAdpcm->setPitchNumber(ptNum);
634 ptADPCM_[static_cast<size_t>(ptNum)]->registerUserInstrument(cloneInstNum);
635 }
636 if (refAdpcm->getPanEnabled()) {
637 cloneAdpcm->setPanEnabled(true);
638 int panNum = cloneProperty(panADPCM_, refAdpcm->getPanNumber());
639 cloneAdpcm->setPanNumber(panNum);
640 panADPCM_[static_cast<size_t>(panNum)]->registerUserInstrument(cloneInstNum);
641 }
642 break;
643 }
644 case InstrumentType::Drumkit:
645 {
646 auto refKit = std::dynamic_pointer_cast<InstrumentDrumkit>(refInst);
647 auto cloneKit = std::dynamic_pointer_cast<InstrumentDrumkit>(insts_.at(static_cast<size_t>(cloneInstNum)));
648 std::unordered_map<int, int> sampCloneMap;
649 for (const int& key : refKit->getAssignedKeys()) {
650 int srcNum = refKit->getSampleNumber(key);
651 if (!sampCloneMap.count(srcNum)) sampCloneMap[srcNum] = cloneProperty(sampADPCM_, srcNum);
652 cloneKit->setSampleNumber(key, sampCloneMap[srcNum]);
653 sampADPCM_[static_cast<size_t>(sampCloneMap[srcNum])]->registerUserInstrument(cloneInstNum);
654
655 setInstrumentDrumkitPitch(cloneInstNum, key, refKit->getPitch(key));
656 setInstrumentDrumkitPan(cloneInstNum, key, refKit->getPan(key));
657 }
658 break;
659 }
660 default:
661 throw std::invalid_argument("invalid instrument type");
662 }
663 }
664
665 void InstrumentsManager::swapInstruments(int inst1Num, int inst2Num)
666 {
667 std::unique_ptr<AbstractInstrument> inst1 = removeInstrument(inst1Num);
668 std::unique_ptr<AbstractInstrument> inst2 = removeInstrument(inst2Num);
669 inst1->setNumber(inst2Num);
670 inst2->setNumber(inst1Num);
671 addInstrument(inst1.release());
672 addInstrument(inst2.release());
673 }
674
675 /// [Return] instrument shared pointer or nullptr
676 std::shared_ptr<AbstractInstrument> InstrumentsManager::getInstrumentSharedPtr(int instNum)
677 {
678 if (0 <= instNum && instNum < static_cast<int>(insts_.size()))
679 return insts_[static_cast<size_t>(instNum)];
680 else
681 return std::shared_ptr<AbstractInstrument>();
682 }
683
684 void InstrumentsManager::clearAll()
685 {
686 for (auto p : ENV_FM_PARAMS) {
687 opSeqFM_.emplace(p, std::array<std::shared_ptr<InstrumentSequenceProperty<FMOperatorSequenceUnit>>, 128>());
688 }
689
690 for (size_t i = 0; i < 128; ++i) {
691 insts_[i].reset();
692
693 envFM_[i] = makeEnvelopeFMSharedPtr(i);
694 lfoFM_[i] = makeLFOFMSharedPtr(i);
695 for (auto& p : opSeqFM_) p.second[i] = makeOperatorSequenceFMSharedPtr(i);
696 arpFM_[i] = makeArpeggioSharedPtr(i);
697 ptFM_[i] = makePitchSharedPtr(i);
698 panFM_[i] = makePanSharedPtr(i);
699
700 wfSSG_[i] = makeWaveformSSGSharedPtr(i);
701 tnSSG_[i] = makeToneNoiseSSGSharedPtr(i);
702 envSSG_[i] = makeEnvelopeSSGSharedPtr(i);
703 arpSSG_[i] = makeArpeggioSharedPtr(i);
704 ptSSG_[i] = makePitchSharedPtr(i);
705
706 sampADPCM_[i] = makeSampleADPCMSharedPtr(i);
707 envADPCM_[i] = makeEnvelopeADPCMSharedPtr(i);
708 arpADPCM_[i] = makeArpeggioSharedPtr(i);
709 ptADPCM_[i] = makePitchSharedPtr(i);
710 panADPCM_[i] = makePanSharedPtr(i);
711 }
712 }
713
714 std::vector<int> InstrumentsManager::getInstrumentIndices() const
715 {
716 return utils::findIndicesIf(insts_, [](decltype(insts_)::const_reference inst) { return inst; });
717 }
718
719 void InstrumentsManager::setInstrumentName(int instNum, const std::string& name)
720 {
721 insts_.at(static_cast<size_t>(instNum))->setName(name);
722 }
723
724 std::string InstrumentsManager::getInstrumentName(int instNum) const
725 {
726 return insts_.at(static_cast<size_t>(instNum))->getName();
727 }
728
729 std::vector<std::string> InstrumentsManager::getInstrumentNameList() const
730 {
731 using InstRef = decltype(insts_)::const_reference;
732 return utils::transformIf(insts_, [](InstRef inst) { return inst; },
733 [](InstRef inst) { return inst->getName(); });
734 }
735
736 void InstrumentsManager::clearUnusedInstrumentProperties()
737 {
738 for (size_t i = 0; i < 128; ++i) {
739 if (!envFM_[i]->isUserInstrument())
740 envFM_[i] = makeEnvelopeFMSharedPtr(i);
741 if (!lfoFM_[i]->isUserInstrument())
742 lfoFM_[i] = makeLFOFMSharedPtr(i);
743 for (auto& p : opSeqFM_) {
744 if (!p.second[i]->isUserInstrument())
745 p.second[i] = makeOperatorSequenceFMSharedPtr(i);
746 }
747 if (!arpFM_[i]->isUserInstrument())
748 arpFM_[i] = makeArpeggioSharedPtr(i);
749 if (!ptFM_[i]->isUserInstrument())
750 ptFM_[i] = makePitchSharedPtr(i);
751 if (!panFM_[i]->isUserInstrument())
752 panFM_[i] = makePanSharedPtr(i);
753
754 if (!wfSSG_[i]->isUserInstrument())
755 wfSSG_[i] = makeWaveformSSGSharedPtr(i);
756 if (!tnSSG_[i]->isUserInstrument())
757 tnSSG_[i] = makeToneNoiseSSGSharedPtr(i);
758 if (!envSSG_[i]->isUserInstrument())
759 envSSG_[i] = makeEnvelopeSSGSharedPtr(i);
760 if (!arpSSG_[i]->isUserInstrument())
761 arpSSG_[i] = makeArpeggioSharedPtr(i);
762 if (!ptSSG_[i]->isUserInstrument())
763 ptSSG_[i] = makePitchSharedPtr(i);
764
765 if (!sampADPCM_[i]->isUserInstrument())
766 sampADPCM_[i] = makeSampleADPCMSharedPtr(i);
767 if (!envADPCM_[i]->isUserInstrument())
768 envADPCM_[i] = makeEnvelopeADPCMSharedPtr(i);
769 if (!arpADPCM_[i]->isUserInstrument())
770 arpADPCM_[i] = makeArpeggioSharedPtr(i);
771 if (!ptADPCM_[i]->isUserInstrument())
772 ptADPCM_[i] = makePitchSharedPtr(i);
773 if (!panADPCM_[i]->isUserInstrument())
774 panADPCM_[i] = makePanSharedPtr(i);
775 }
776 }
777
778 /// [Return]
779 /// -1: no free instrument
780 /// else: first free instrument number
781 int InstrumentsManager::findFirstFreeInstrument() const
782 {
783 auto&& it = std::find_if_not(insts_.cbegin(), insts_.cend(),
784 [](const std::shared_ptr<AbstractInstrument>& inst) { return inst; });
785 return (it == insts_.cend() ? -1 : std::distance(insts_.cbegin(), it));
786 }
787
788 std::unordered_map<int, int> InstrumentsManager::getDuplicateInstrumentMap() const
789 {
790 std::unordered_map<int, int> dupMap;
791 std::vector<int> idcs = getInstrumentIndices();
792 static const std::unordered_map<InstrumentType,
793 bool (InstrumentsManager::*)(std::shared_ptr<AbstractInstrument>,
794 std::shared_ptr<AbstractInstrument>) const> eqCheck = {
795 { InstrumentType::FM, &InstrumentsManager::equalPropertiesFM },
796 { InstrumentType::SSG, &InstrumentsManager::equalPropertiesSSG },
797 { InstrumentType::ADPCM, &InstrumentsManager::equalPropertiesADPCM },
798 { InstrumentType::Drumkit, &InstrumentsManager::equalPropertiesDrumkit }
799 };
800
801 for (size_t i = 0; i < idcs.size(); ++i) {
802 int baseIdx = idcs[i];
803 std::shared_ptr<AbstractInstrument> base = insts_[baseIdx];
804
805 for (size_t j = i + 1; j < idcs.size();) {
806 int tgtIdx = idcs[j];
807 std::shared_ptr<AbstractInstrument> tgt = insts_[tgtIdx];
808 if (base->getType() == tgt->getType() && (this->*eqCheck.at(base->getType()))(base, tgt)) {
809 dupMap[tgtIdx] = baseIdx;
810 idcs.erase(idcs.begin() + j);
811 continue;
812 }
813 ++j;
814 }
815 }
816
817 return dupMap;
818 }
819
820 //----- FM methods -----
821 void InstrumentsManager::setInstrumentFMEnvelope(int instNum, int envNum)
822 {
823 auto fm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)));
824 envFM_.at(static_cast<size_t>(fm->getEnvelopeNumber()))->deregisterUserInstrument(instNum);
825 envFM_.at(static_cast<size_t>(envNum))->registerUserInstrument(instNum);
826
827 fm->setEnvelopeNumber(envNum);
828 }
829
830 int InstrumentsManager::getInstrumentFMEnvelope(int instNum) const
831 {
832 return std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)))->getEnvelopeNumber();
833 }
834
835 void InstrumentsManager::setEnvelopeFMParameter(int envNum, FMEnvelopeParameter param, int value)
836 {
837 envFM_.at(static_cast<size_t>(envNum))->setParameterValue(param, value);
838 }
839
840 int InstrumentsManager::getEnvelopeFMParameter(int envNum, FMEnvelopeParameter param) const
841 {
842 return envFM_.at(static_cast<size_t>(envNum))->getParameterValue(param);
843 }
844
845 void InstrumentsManager::setEnvelopeFMOperatorEnabled(int envNum, int opNum, bool enabled)
846 {
847 envFM_.at(static_cast<size_t>(envNum))->setOperatorEnabled(opNum, enabled);
848 }
849
850 bool InstrumentsManager::getEnvelopeFMOperatorEnabled(int envNum, int opNum) const
851 {
852 return envFM_.at(static_cast<size_t>(envNum))->getOperatorEnabled(opNum);
853 }
854
855 std::multiset<int> InstrumentsManager::getEnvelopeFMUsers(int envNum) const
856 {
857 return envFM_.at(static_cast<size_t>(envNum))->getUserInstruments();
858 }
859
860 std::vector<int> InstrumentsManager::getEnvelopeFMEntriedIndices() const
861 {
862 return utils::findIndicesIf(envFM_, IsEdited<decltype(envFM_)>());
863 }
864
865 int InstrumentsManager::findFirstAssignableEnvelopeFM() const
866 {
867 return findFirstAssignableProperty(envFM_, regardingUnedited_);
868 }
869
870 void InstrumentsManager::setInstrumentFMLFOEnabled(int instNum, bool enabled)
871 {
872 auto fm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)));
873 fm->setLFOEnabled(enabled);
874 if (enabled) lfoFM_.at(static_cast<size_t>(fm->getLFONumber()))->registerUserInstrument(instNum);
875 else lfoFM_.at(static_cast<size_t>(fm->getLFONumber()))->deregisterUserInstrument(instNum);
876 }
877 bool InstrumentsManager::getInstrumentFMLFOEnabled(int instNum) const
878 {
879 return std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)))->getLFOEnabled();
880 }
881
882 void InstrumentsManager::setInstrumentFMLFO(int instNum, int lfoNum)
883 {
884 auto fm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)));
885 if (fm->getLFOEnabled()) {
886 lfoFM_.at(static_cast<size_t>(fm->getLFONumber()))->deregisterUserInstrument(instNum);
887 lfoFM_.at(static_cast<size_t>(lfoNum))->registerUserInstrument(instNum);
888 }
889 fm->setLFONumber(lfoNum);
890 }
891
892 int InstrumentsManager::getInstrumentFMLFO(int instNum) const
893 {
894 return std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)))->getLFONumber();
895 }
896
897 void InstrumentsManager::setLFOFMParameter(int lfoNum, FMLFOParameter param, int value)
898 {
899 lfoFM_.at(static_cast<size_t>(lfoNum))->setParameterValue(param, value);
900 }
901
902 int InstrumentsManager::getLFOFMparameter(int lfoNum, FMLFOParameter param) const
903 {
904 return lfoFM_.at(static_cast<size_t>(lfoNum))->getParameterValue(param);
905 }
906
907 std::multiset<int> InstrumentsManager::getLFOFMUsers(int lfoNum) const
908 {
909 return lfoFM_.at(static_cast<size_t>(lfoNum))->getUserInstruments();
910 }
911
912 std::vector<int> InstrumentsManager::getLFOFMEntriedIndices() const
913 {
914 return utils::findIndicesIf(lfoFM_, IsEdited<decltype(lfoFM_)>());
915 }
916
917 int InstrumentsManager::findFirstAssignableLFOFM() const
918 {
919 return findFirstAssignableProperty(lfoFM_, regardingUnedited_);
920 }
921
922 void InstrumentsManager::setInstrumentFMOperatorSequenceEnabled(int instNum, FMEnvelopeParameter param, bool enabled)
923 {
924 auto fm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)));
925 fm->setOperatorSequenceEnabled(param, enabled);
926 if (enabled)
927 opSeqFM_.at(param).at(static_cast<size_t>(fm->getOperatorSequenceNumber(param)))->registerUserInstrument(instNum);
928 else
929 opSeqFM_.at(param).at(static_cast<size_t>(fm->getOperatorSequenceNumber(param)))->deregisterUserInstrument(instNum);
930 }
931
932 bool InstrumentsManager::getInstrumentFMOperatorSequenceEnabled(int instNum, FMEnvelopeParameter param) const
933 {
934 return std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)))->getOperatorSequenceEnabled(param);
935 }
936
937 void InstrumentsManager::setInstrumentFMOperatorSequence(int instNum, FMEnvelopeParameter param, int opSeqNum)
938 {
939 auto fm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)));
940 if (fm->getOperatorSequenceEnabled(param)) {
941 opSeqFM_.at(param).at(static_cast<size_t>(fm->getOperatorSequenceNumber(param)))->deregisterUserInstrument(instNum);
942 opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->registerUserInstrument(instNum);
943 }
944 fm->setOperatorSequenceNumber(param, opSeqNum);
945 }
946
947 int InstrumentsManager::getInstrumentFMOperatorSequence(int instNum, FMEnvelopeParameter param)
948 {
949 return std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)))->getOperatorSequenceNumber(param);
950 }
951
952 void InstrumentsManager::addOperatorSequenceFMSequenceData(FMEnvelopeParameter param, int opSeqNum, int data)
953 {
954 opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->addSequenceUnit(FMOperatorSequenceUnit(data));
955 }
956
957 void InstrumentsManager::removeOperatorSequenceFMSequenceData(FMEnvelopeParameter param, int opSeqNum)
958 {
959 opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->removeSequenceUnit();
960 }
961
962 void InstrumentsManager::setOperatorSequenceFMSequenceData(FMEnvelopeParameter param, int opSeqNum, int cnt, int data)
963 {
964 opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->setSequenceUnit(cnt, FMOperatorSequenceUnit(data));
965 }
966
967 std::vector<FMOperatorSequenceUnit> InstrumentsManager::getOperatorSequenceFMSequence(FMEnvelopeParameter param, int opSeqNum)
968 {
969 return opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->getSequence();
970 }
971
972 void InstrumentsManager::addOperatorSequenceFMLoop(FMEnvelopeParameter param, int opSeqNum, const InstrumentSequenceLoop& loop)
973 {
974 opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->addLoop(loop);
975 }
976
977 void InstrumentsManager::removeOperatorSequenceFMLoop(FMEnvelopeParameter param, int opSeqNum, int begin, int end)
978 {
979 opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->removeLoop(begin, end);
980 }
981
982 void InstrumentsManager::changeOperatorSequenceFMLoop(FMEnvelopeParameter param, int opSeqNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
983 {
984 opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->changeLoop(prevBegin, prevEnd, loop);
985 }
986
987 void InstrumentsManager::clearOperatorSequenceFMLoops(FMEnvelopeParameter param, int opSeqNum)
988 {
989 opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->clearLoops();
990 }
991
992 InstrumentSequenceLoopRoot InstrumentsManager::getOperatorSequenceFMLoopRoot(FMEnvelopeParameter param, int opSeqNum) const
993 {
994 return opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->getLoopRoot();
995 }
996
997 void InstrumentsManager::setOperatorSequenceFMRelease(FMEnvelopeParameter param, int opSeqNum, const InstrumentSequenceRelease& release)
998 {
999 opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->setRelease(release);
1000 }
1001
1002 InstrumentSequenceRelease InstrumentsManager::getOperatorSequenceFMRelease(FMEnvelopeParameter param, int opSeqNum) const
1003 {
1004 return opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->getRelease();
1005 }
1006
1007 FMOperatorSequenceIter InstrumentsManager::getOperatorSequenceFMIterator(FMEnvelopeParameter param, int opSeqNum) const
1008 {
1009 return opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->getIterator();
1010 }
1011
1012 std::multiset<int> InstrumentsManager::getOperatorSequenceFMUsers(FMEnvelopeParameter param, int opSeqNum) const
1013 {
1014 return opSeqFM_.at(param).at(static_cast<size_t>(opSeqNum))->getUserInstruments();
1015 }
1016
1017 std::vector<int> InstrumentsManager::getOperatorSequenceFMEntriedIndices(FMEnvelopeParameter param) const
1018 {
1019 return utils::findIndicesIf(opSeqFM_.at(param), IsUsedOrEdited<decltype(opSeqFM_)::mapped_type>());
1020 }
1021
1022 int InstrumentsManager::findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter param) const
1023 {
1024 return findFirstAssignableProperty(opSeqFM_.at(param), regardingUnedited_);
1025 }
1026
1027 void InstrumentsManager::setInstrumentFMArpeggioEnabled(int instNum, FMOperatorType op, bool enabled)
1028 {
1029 auto fm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)));
1030 fm->setArpeggioEnabled(op, enabled);
1031 if (enabled)
1032 arpFM_.at(static_cast<size_t>(fm->getArpeggioNumber(op)))->registerUserInstrument(instNum);
1033 else
1034 arpFM_.at(static_cast<size_t>(fm->getArpeggioNumber(op)))->deregisterUserInstrument(instNum);
1035 }
1036
1037 bool InstrumentsManager::getInstrumentFMArpeggioEnabled(int instNum, FMOperatorType op) const
1038 {
1039 return std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)))->getArpeggioEnabled(op);
1040 }
1041
1042 void InstrumentsManager::setInstrumentFMArpeggio(int instNum, FMOperatorType op, int arpNum)
1043 {
1044 auto fm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)));
1045 if (fm->getArpeggioEnabled(op)) {
1046 arpFM_.at(static_cast<size_t>(fm->getArpeggioNumber(op)))->deregisterUserInstrument(instNum);
1047 arpFM_.at(static_cast<size_t>(arpNum))->registerUserInstrument(instNum);
1048 }
1049 fm->setArpeggioNumber(op, arpNum);
1050 }
1051
1052 int InstrumentsManager::getInstrumentFMArpeggio(int instNum, FMOperatorType op)
1053 {
1054 return std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)))->getArpeggioNumber(op);
1055 }
1056
1057 void InstrumentsManager::setArpeggioFMType(int arpNum, SequenceType type)
1058 {
1059 arpFM_.at(static_cast<size_t>(arpNum))->setType(type);
1060 }
1061
1062 SequenceType InstrumentsManager::getArpeggioFMType(int arpNum) const
1063 {
1064 return arpFM_.at(static_cast<size_t>(arpNum))->getType();
1065 }
1066
1067 void InstrumentsManager::addArpeggioFMSequenceData(int arpNum, int data)
1068 {
1069 arpFM_.at(static_cast<size_t>(arpNum))->addSequenceUnit(ArpeggioUnit(data));
1070 }
1071
1072 void InstrumentsManager::removeArpeggioFMSequenceData(int arpNum)
1073 {
1074 arpFM_.at(static_cast<size_t>(arpNum))->removeSequenceUnit();
1075 }
1076
1077 void InstrumentsManager::setArpeggioFMSequenceData(int arpNum, int cnt, int data)
1078 {
1079 arpFM_.at(static_cast<size_t>(arpNum))->setSequenceUnit(cnt, ArpeggioUnit(data));
1080 }
1081
1082 std::vector<ArpeggioUnit> InstrumentsManager::getArpeggioFMSequence(int arpNum)
1083 {
1084 return arpFM_.at(static_cast<size_t>(arpNum))->getSequence();
1085 }
1086
1087 void InstrumentsManager::addArpeggioFMLoop(int arpNum, const InstrumentSequenceLoop& loop)
1088 {
1089 arpFM_.at(static_cast<size_t>(arpNum))->addLoop(loop);
1090 }
1091
1092 void InstrumentsManager::removeArpeggioFMLoop(int arpNum, int begin, int end)
1093 {
1094 arpFM_.at(static_cast<size_t>(arpNum))->removeLoop(begin, end);
1095 }
1096
1097 void InstrumentsManager::changeArpeggioFMLoop(int arpNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
1098 {
1099 arpFM_.at(static_cast<size_t>(arpNum))->changeLoop(prevBegin, prevEnd, loop);
1100 }
1101
1102 void InstrumentsManager::clearArpeggioFMLoops(int arpNum)
1103 {
1104 arpFM_.at(static_cast<size_t>(arpNum))->clearLoops();
1105 }
1106
1107 InstrumentSequenceLoopRoot InstrumentsManager::getArpeggioFMLoopRoot(int arpNum) const
1108 {
1109 return arpFM_.at(static_cast<size_t>(arpNum))->getLoopRoot();
1110 }
1111
1112 void InstrumentsManager::setArpeggioFMRelease(int arpNum, const InstrumentSequenceRelease& release)
1113 {
1114 arpFM_.at(static_cast<size_t>(arpNum))->setRelease(release);
1115 }
1116
1117 InstrumentSequenceRelease InstrumentsManager::getArpeggioFMRelease(int arpNum) const
1118 {
1119 return arpFM_.at(static_cast<size_t>(arpNum))->getRelease();
1120 }
1121
1122 ArpeggioIter InstrumentsManager::getArpeggioFMIterator(int arpNum) const
1123 {
1124 return arpFM_.at(static_cast<size_t>(arpNum))->getIterator();
1125 }
1126
1127 std::multiset<int> InstrumentsManager::getArpeggioFMUsers(int arpNum) const
1128 {
1129 return arpFM_.at(static_cast<size_t>(arpNum))->getUserInstruments();
1130 }
1131
1132 std::vector<int> InstrumentsManager::getArpeggioFMEntriedIndices() const
1133 {
1134 return utils::findIndicesIf(arpFM_, IsUsedOrEdited<decltype(arpFM_)>());
1135 }
1136
1137 int InstrumentsManager::findFirstAssignableArpeggioFM() const
1138 {
1139 return findFirstAssignableProperty(arpFM_, regardingUnedited_);
1140 }
1141
1142 void InstrumentsManager::setInstrumentFMPitchEnabled(int instNum, FMOperatorType op, bool enabled)
1143 {
1144 auto fm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)));
1145 fm->setPitchEnabled(op, enabled);
1146 if (enabled)
1147 ptFM_.at(static_cast<size_t>(fm->getPitchNumber(op)))->registerUserInstrument(instNum);
1148 else
1149 ptFM_.at(static_cast<size_t>(fm->getPitchNumber(op)))->deregisterUserInstrument(instNum);
1150 }
1151
1152 bool InstrumentsManager::getInstrumentFMPitchEnabled(int instNum, FMOperatorType op) const
1153 {
1154 return std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)))->getPitchEnabled(op);
1155 }
1156
1157 void InstrumentsManager::setInstrumentFMPitch(int instNum, FMOperatorType op, int ptNum)
1158 {
1159 auto fm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)));
1160 if (fm->getPitchEnabled(op)) {
1161 ptFM_.at(static_cast<size_t>(fm->getPitchNumber(op)))->deregisterUserInstrument(instNum);
1162 ptFM_.at(static_cast<size_t>(ptNum))->registerUserInstrument(instNum);
1163 }
1164 fm->setPitchNumber(op, ptNum);
1165 }
1166
1167 int InstrumentsManager::getInstrumentFMPitch(int instNum, FMOperatorType op)
1168 {
1169 return std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)))->getPitchNumber(op);
1170 }
1171
1172 void InstrumentsManager::setPitchFMType(int ptNum, SequenceType type)
1173 {
1174 ptFM_.at(static_cast<size_t>(ptNum))->setType(type);
1175 }
1176
1177 SequenceType InstrumentsManager::getPitchFMType(int ptNum) const
1178 {
1179 return ptFM_.at(static_cast<size_t>(ptNum))->getType();
1180 }
1181
1182 void InstrumentsManager::addPitchFMSequenceData(int ptNum, int data)
1183 {
1184 ptFM_.at(static_cast<size_t>(ptNum))->addSequenceUnit(PitchUnit(data));
1185 }
1186
1187 void InstrumentsManager::removePitchFMSequenceData(int ptNum)
1188 {
1189 ptFM_.at(static_cast<size_t>(ptNum))->removeSequenceUnit();
1190 }
1191
1192 void InstrumentsManager::setPitchFMSequenceData(int ptNum, int cnt, int data)
1193 {
1194 ptFM_.at(static_cast<size_t>(ptNum))->setSequenceUnit(cnt, PitchUnit(data));
1195 }
1196
1197 std::vector<PitchUnit> InstrumentsManager::getPitchFMSequence(int ptNum)
1198 {
1199 return ptFM_.at(static_cast<size_t>(ptNum))->getSequence();
1200 }
1201
1202 void InstrumentsManager::addPitchFMLoop(int ptNum, const InstrumentSequenceLoop& loop)
1203 {
1204 ptFM_.at(static_cast<size_t>(ptNum))->addLoop(loop);
1205 }
1206
1207 void InstrumentsManager::removePitchFMLoop(int ptNum, int begin, int end)
1208 {
1209 ptFM_.at(static_cast<size_t>(ptNum))->removeLoop(begin, end);
1210 }
1211
1212 void InstrumentsManager::changePitchFMLoop(int ptNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
1213 {
1214 ptFM_.at(static_cast<size_t>(ptNum))->changeLoop(prevBegin, prevEnd, loop);
1215 }
1216
1217 void InstrumentsManager::clearPitchFMLoops(int ptNum)
1218 {
1219 ptFM_.at(static_cast<size_t>(ptNum))->clearLoops();
1220 }
1221
1222 InstrumentSequenceLoopRoot InstrumentsManager::getPitchFMLoopRoot(int ptNum) const
1223 {
1224 return ptFM_.at(static_cast<size_t>(ptNum))->getLoopRoot();
1225 }
1226
1227 void InstrumentsManager::setPitchFMRelease(int ptNum, const InstrumentSequenceRelease& release)
1228 {
1229 ptFM_.at(static_cast<size_t>(ptNum))->setRelease(release);
1230 }
1231
1232 InstrumentSequenceRelease InstrumentsManager::getPitchFMRelease(int ptNum) const
1233 {
1234 return ptFM_.at(static_cast<size_t>(ptNum))->getRelease();
1235 }
1236
1237 PitchIter InstrumentsManager::getPitchFMIterator(int ptNum) const
1238 {
1239 return ptFM_.at(static_cast<size_t>(ptNum))->getIterator();
1240 }
1241
1242 std::multiset<int> InstrumentsManager::getPitchFMUsers(int ptNum) const
1243 {
1244 return ptFM_.at(static_cast<size_t>(ptNum))->getUserInstruments();
1245 }
1246
1247 std::vector<int> InstrumentsManager::getPitchFMEntriedIndices() const
1248 {
1249 return utils::findIndicesIf(ptFM_, IsUsedOrEdited<decltype(ptFM_)>());
1250 }
1251
1252 int InstrumentsManager::findFirstAssignablePitchFM() const
1253 {
1254 return findFirstAssignableProperty(ptFM_, regardingUnedited_);
1255 }
1256
1257 void InstrumentsManager::setInstrumentFMPanEnabled(int instNum, bool enabled)
1258 {
1259 auto fm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)));
1260 fm->setPanEnabled(enabled);
1261 if (enabled)
1262 panFM_.at(static_cast<size_t>(fm->getPanNumber()))->registerUserInstrument(instNum);
1263 else
1264 panFM_.at(static_cast<size_t>(fm->getPanNumber()))->deregisterUserInstrument(instNum);
1265 }
1266
1267 bool InstrumentsManager::getInstrumentFMPanEnabled(int instNum) const
1268 {
1269 return std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)))->getPanEnabled();
1270 }
1271
1272 void InstrumentsManager::setInstrumentFMPan(int instNum, int panNum)
1273 {
1274 auto fm = std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)));
1275 if (fm->getPanEnabled()) {
1276 panFM_.at(static_cast<size_t>(fm->getPanNumber()))->deregisterUserInstrument(instNum);
1277 panFM_.at(static_cast<size_t>(panNum))->registerUserInstrument(instNum);
1278 }
1279 fm->setPanNumber(panNum);
1280 }
1281
1282 int InstrumentsManager::getInstrumentFMPan(int instNum)
1283 {
1284 return std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)))->getPanNumber();
1285 }
1286
1287 void InstrumentsManager::addPanFMSequenceData(int panNum, int data)
1288 {
1289 panFM_.at(static_cast<size_t>(panNum))->addSequenceUnit(PanUnit(data));
1290 }
1291
1292 void InstrumentsManager::removePanFMSequenceData(int panNum)
1293 {
1294 panFM_.at(static_cast<size_t>(panNum))->removeSequenceUnit();
1295 }
1296
1297 void InstrumentsManager::setPanFMSequenceData(int panNum, int cnt, int data)
1298 {
1299 panFM_.at(static_cast<size_t>(panNum))->setSequenceUnit(cnt, PanUnit(data));
1300 }
1301
1302 std::vector<PanUnit> InstrumentsManager::getPanFMSequence(int panNum)
1303 {
1304 return panFM_.at(static_cast<size_t>(panNum))->getSequence();
1305 }
1306
1307 void InstrumentsManager::addPanFMLoop(int panNum, const InstrumentSequenceLoop& loop)
1308 {
1309 panFM_.at(static_cast<size_t>(panNum))->addLoop(loop);
1310 }
1311
1312 void InstrumentsManager::removePanFMLoop(int panNum, int begin, int end)
1313 {
1314 panFM_.at(static_cast<size_t>(panNum))->removeLoop(begin, end);
1315 }
1316
1317 void InstrumentsManager::changePanFMLoop(int panNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
1318 {
1319 panFM_.at(static_cast<size_t>(panNum))->changeLoop(prevBegin, prevEnd, loop);
1320 }
1321
1322 void InstrumentsManager::clearPanFMLoops(int panNum)
1323 {
1324 panFM_.at(static_cast<size_t>(panNum))->clearLoops();
1325 }
1326
1327 InstrumentSequenceLoopRoot InstrumentsManager::getPanFMLoopRoot(int panNum) const
1328 {
1329 return panFM_.at(static_cast<size_t>(panNum))->getLoopRoot();
1330 }
1331
1332 void InstrumentsManager::setPanFMRelease(int panNum, const InstrumentSequenceRelease& release)
1333 {
1334 panFM_.at(static_cast<size_t>(panNum))->setRelease(release);
1335 }
1336
1337 InstrumentSequenceRelease InstrumentsManager::getPanFMRelease(int panNum) const
1338 {
1339 return panFM_.at(static_cast<size_t>(panNum))->getRelease();
1340 }
1341
1342 PanIter InstrumentsManager::getPanFMIterator(int panNum) const
1343 {
1344 return panFM_.at(static_cast<size_t>(panNum))->getIterator();
1345 }
1346
1347 std::multiset<int> InstrumentsManager::getPanFMUsers(int panNum) const
1348 {
1349 return panFM_.at(static_cast<size_t>(panNum))->getUserInstruments();
1350 }
1351
1352 std::vector<int> InstrumentsManager::getPanFMEntriedIndices() const
1353 {
1354 return utils::findIndicesIf(panFM_, IsUsedOrEdited<decltype(panFM_)>());
1355 }
1356
1357 int InstrumentsManager::findFirstAssignablePanFM() const
1358 {
1359 return findFirstAssignableProperty(panFM_, regardingUnedited_);
1360 }
1361
1362 void InstrumentsManager::setInstrumentFMEnvelopeResetEnabled(int instNum, FMOperatorType op, bool enabled)
1363 {
1364 std::dynamic_pointer_cast<InstrumentFM>(insts_.at(static_cast<size_t>(instNum)))->setEnvelopeResetEnabled(op, enabled);
1365 }
1366
1367 bool InstrumentsManager::equalPropertiesFM(std::shared_ptr<AbstractInstrument> a, std::shared_ptr<AbstractInstrument> b) const
1368 {
1369 auto aFm = std::dynamic_pointer_cast<InstrumentFM>(a);
1370 auto bFm = std::dynamic_pointer_cast<InstrumentFM>(b);
1371
1372 if (*envFM_[aFm->getEnvelopeNumber()] != *envFM_[bFm->getEnvelopeNumber()])
1373 return false;
1374 if (aFm->getLFOEnabled() != bFm->getLFOEnabled())
1375 return false;
1376 if (aFm->getLFOEnabled() && *lfoFM_[aFm->getLFONumber()] != *lfoFM_[bFm->getLFONumber()])
1377 return false;
1378 for (auto& pair : opSeqFM_) {
1379 if (aFm->getOperatorSequenceEnabled(pair.first) != bFm->getOperatorSequenceEnabled(pair.first))
1380 return false;
1381 if (aFm->getOperatorSequenceEnabled(pair.first)
1382 && *pair.second[aFm->getOperatorSequenceNumber(pair.first)] != *pair.second[bFm->getOperatorSequenceNumber(pair.first)])
1383 return false;
1384 }
1385 for (auto& type : FM_OP_TYPES) {
1386 if (aFm->getArpeggioEnabled(type) != bFm->getArpeggioEnabled(type))
1387 return false;
1388 if (aFm->getArpeggioEnabled(type)
1389 && *arpFM_[aFm->getArpeggioNumber(type)] != *arpFM_[bFm->getArpeggioNumber(type)])
1390 return false;
1391 if (aFm->getPitchEnabled(type) != bFm->getPitchEnabled(type))
1392 return false;
1393 if (aFm->getPitchEnabled(type)
1394 && *ptFM_[aFm->getPitchNumber(type)] != *ptFM_[bFm->getPitchNumber(type)])
1395 return false;
1396 if (aFm->getEnvelopeResetEnabled(type) != bFm->getEnvelopeResetEnabled(type))
1397 return false;
1398 }
1399 if (aFm->getPanEnabled()
1400 && *panFM_[aFm->getPanNumber()] != *panFM_[bFm->getPanNumber()])
1401 return false;
1402 return true;
1403 }
1404
1405 //----- SSG methods -----
1406 void InstrumentsManager::setInstrumentSSGWaveformEnabled(int instNum, bool enabled)
1407 {
1408 auto ssg = std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)));
1409 ssg->setWaveformEnabled(enabled);
1410 if (enabled)
1411 wfSSG_.at(static_cast<size_t>(ssg->getWaveformNumber()))->registerUserInstrument(instNum);
1412 else
1413 wfSSG_.at(static_cast<size_t>(ssg->getWaveformNumber()))->deregisterUserInstrument(instNum);
1414 }
1415
1416 bool InstrumentsManager::getInstrumentSSGWaveformEnabled(int instNum) const
1417 {
1418 return std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)))->getWaveformEnabled();
1419 }
1420
1421 void InstrumentsManager::setInstrumentSSGWaveform(int instNum, int wfNum)
1422 {
1423 auto ssg = std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)));
1424 if (ssg->getWaveformEnabled()) {
1425 wfSSG_.at(static_cast<size_t>(ssg->getWaveformNumber()))->deregisterUserInstrument(instNum);
1426 wfSSG_.at(static_cast<size_t>(wfNum))->registerUserInstrument(instNum);
1427 }
1428 ssg->setWaveformNumber(wfNum);
1429 }
1430
1431 int InstrumentsManager::getInstrumentSSGWaveform(int instNum)
1432 {
1433 return std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)))->getWaveformNumber();
1434 }
1435
1436 void InstrumentsManager::addWaveformSSGSequenceData(int wfNum, const SSGWaveformUnit& data)
1437 {
1438 wfSSG_.at(static_cast<size_t>(wfNum))->addSequenceUnit(data);
1439 }
1440
1441 void InstrumentsManager::removeWaveformSSGSequenceData(int wfNum)
1442 {
1443 wfSSG_.at(static_cast<size_t>(wfNum))->removeSequenceUnit();
1444 }
1445
1446 void InstrumentsManager::setWaveformSSGSequenceData(int wfNum, int cnt, const SSGWaveformUnit& data)
1447 {
1448 wfSSG_.at(static_cast<size_t>(wfNum))->setSequenceUnit(cnt, data);
1449 }
1450
1451 std::vector<SSGWaveformUnit> InstrumentsManager::getWaveformSSGSequence(int wfNum)
1452 {
1453 return wfSSG_.at(static_cast<size_t>(wfNum))->getSequence();
1454 }
1455
1456 void InstrumentsManager::addWaveformSSGLoop(int wfNum, const InstrumentSequenceLoop& loop)
1457 {
1458 wfSSG_.at(static_cast<size_t>(wfNum))->addLoop(loop);
1459 }
1460
1461 void InstrumentsManager::removeWaveformSSGLoop(int wfNum, int begin, int end)
1462 {
1463 wfSSG_.at(static_cast<size_t>(wfNum))->removeLoop(begin, end);
1464 }
1465
1466 void InstrumentsManager::changeWaveformSSGLoop(int wfNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
1467 {
1468 wfSSG_.at(static_cast<size_t>(wfNum))->changeLoop(prevBegin, prevEnd, loop);
1469 }
1470
1471 void InstrumentsManager::clearWaveformSSGLoops(int wfNum)
1472 {
1473 wfSSG_.at(static_cast<size_t>(wfNum))->clearLoops();
1474 }
1475
1476 InstrumentSequenceLoopRoot InstrumentsManager::getWaveformSSGLoopRoot(int wfNum) const
1477 {
1478 return wfSSG_.at(static_cast<size_t>(wfNum))->getLoopRoot();
1479 }
1480
1481 void InstrumentsManager::setWaveformSSGRelease(int wfNum, const InstrumentSequenceRelease& release)
1482 {
1483 wfSSG_.at(static_cast<size_t>(wfNum))->setRelease(release);
1484 }
1485
1486 InstrumentSequenceRelease InstrumentsManager::getWaveformSSGRelease(int wfNum) const
1487 {
1488 return wfSSG_.at(static_cast<size_t>(wfNum))->getRelease();
1489 }
1490
1491 SSGWaveformIter InstrumentsManager::getWaveformSSGIterator(int wfNum) const
1492 {
1493 return wfSSG_.at(static_cast<size_t>(wfNum))->getIterator();
1494 }
1495
1496 std::multiset<int> InstrumentsManager::getWaveformSSGUsers(int wfNum) const
1497 {
1498 return wfSSG_.at(static_cast<size_t>(wfNum))->getUserInstruments();
1499 }
1500
1501 std::vector<int> InstrumentsManager::getWaveformSSGEntriedIndices() const
1502 {
1503 return utils::findIndicesIf(wfSSG_, IsUsedOrEdited<decltype(wfSSG_)>());
1504 }
1505
1506 int InstrumentsManager::findFirstAssignableWaveformSSG() const
1507 {
1508 return findFirstAssignableProperty(wfSSG_, regardingUnedited_);
1509 }
1510
1511 void InstrumentsManager::setInstrumentSSGToneNoiseEnabled(int instNum, bool enabled)
1512 {
1513 auto ssg = std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)));
1514 ssg->setToneNoiseEnabled(enabled);
1515 if (enabled)
1516 tnSSG_.at(static_cast<size_t>(ssg->getToneNoiseNumber()))->registerUserInstrument(instNum);
1517 else
1518 tnSSG_.at(static_cast<size_t>(ssg->getToneNoiseNumber()))->deregisterUserInstrument(instNum);
1519 }
1520
1521 bool InstrumentsManager::getInstrumentSSGToneNoiseEnabled(int instNum) const
1522 {
1523 return std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)))->getToneNoiseEnabled();
1524 }
1525
1526 void InstrumentsManager::setInstrumentSSGToneNoise(int instNum, int tnNum)
1527 {
1528 auto ssg = std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)));
1529 if (ssg->getToneNoiseEnabled()) {
1530 tnSSG_.at(static_cast<size_t>(ssg->getToneNoiseNumber()))->deregisterUserInstrument(instNum);
1531 tnSSG_.at(static_cast<size_t>(tnNum))->registerUserInstrument(instNum);
1532 }
1533 ssg->setToneNoiseNumber(tnNum);
1534 }
1535
1536 int InstrumentsManager::getInstrumentSSGToneNoise(int instNum)
1537 {
1538 return std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)))->getToneNoiseNumber();
1539 }
1540
1541 void InstrumentsManager::addToneNoiseSSGSequenceData(int tnNum, int data)
1542 {
1543 tnSSG_.at(static_cast<size_t>(tnNum))->addSequenceUnit(SSGToneNoiseUnit(data));
1544 }
1545
1546 void InstrumentsManager::removeToneNoiseSSGSequenceData(int tnNum)
1547 {
1548 tnSSG_.at(static_cast<size_t>(tnNum))->removeSequenceUnit();
1549 }
1550
1551 void InstrumentsManager::setToneNoiseSSGSequenceData(int tnNum, int cnt, int data)
1552 {
1553 tnSSG_.at(static_cast<size_t>(tnNum))->setSequenceUnit(cnt, SSGToneNoiseUnit(data));
1554 }
1555
1556 std::vector<SSGToneNoiseUnit> InstrumentsManager::getToneNoiseSSGSequence(int tnNum)
1557 {
1558 return tnSSG_.at(static_cast<size_t>(tnNum))->getSequence();
1559 }
1560
1561 void InstrumentsManager::addToneNoiseSSGLoop(int tnNum, const InstrumentSequenceLoop& loop)
1562 {
1563 tnSSG_.at(static_cast<size_t>(tnNum))->addLoop(loop);
1564 }
1565
1566 void InstrumentsManager::removeToneNoiseSSGLoop(int tnNum, int begin, int end)
1567 {
1568 tnSSG_.at(static_cast<size_t>(tnNum))->removeLoop(begin, end);
1569 }
1570
1571 void InstrumentsManager::changeToneNoiseSSGLoop(int tnNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
1572 {
1573 tnSSG_.at(static_cast<size_t>(tnNum))->changeLoop(prevBegin, prevEnd, loop);
1574 }
1575
1576 void InstrumentsManager::clearToneNoiseSSGLoops(int tnNum)
1577 {
1578 tnSSG_.at(static_cast<size_t>(tnNum))->clearLoops();
1579 }
1580
1581 InstrumentSequenceLoopRoot InstrumentsManager::getToneNoiseSSGLoopRoot(int tnNum) const
1582 {
1583 return tnSSG_.at(static_cast<size_t>(tnNum))->getLoopRoot();
1584 }
1585
1586 void InstrumentsManager::setToneNoiseSSGRelease(int tnNum, const InstrumentSequenceRelease& release)
1587 {
1588 tnSSG_.at(static_cast<size_t>(tnNum))->setRelease(release);
1589 }
1590
1591 InstrumentSequenceRelease InstrumentsManager::getToneNoiseSSGRelease(int tnNum) const
1592 {
1593 return tnSSG_.at(static_cast<size_t>(tnNum))->getRelease();
1594 }
1595
1596 SSGToneNoiseIter InstrumentsManager::getToneNoiseSSGIterator(int tnNum) const
1597 {
1598 return tnSSG_.at(static_cast<size_t>(tnNum))->getIterator();
1599 }
1600
1601 std::multiset<int> InstrumentsManager::getToneNoiseSSGUsers(int tnNum) const
1602 {
1603 return tnSSG_.at(static_cast<size_t>(tnNum))->getUserInstruments();
1604 }
1605
1606 std::vector<int> InstrumentsManager::getToneNoiseSSGEntriedIndices() const
1607 {
1608 return utils::findIndicesIf(tnSSG_, IsUsedOrEdited<decltype(tnSSG_)>());
1609 }
1610
1611 int InstrumentsManager::findFirstAssignableToneNoiseSSG() const
1612 {
1613 return findFirstAssignableProperty(tnSSG_, regardingUnedited_);
1614 }
1615
1616 void InstrumentsManager::setInstrumentSSGEnvelopeEnabled(int instNum, bool enabled)
1617 {
1618 auto ssg = std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)));
1619 ssg->setEnvelopeEnabled(enabled);
1620 if (enabled)
1621 envSSG_.at(static_cast<size_t>(ssg->getEnvelopeNumber()))->registerUserInstrument(instNum);
1622 else
1623 envSSG_.at(static_cast<size_t>(ssg->getEnvelopeNumber()))->deregisterUserInstrument(instNum);
1624 }
1625
1626 bool InstrumentsManager::getInstrumentSSGEnvelopeEnabled(int instNum) const
1627 {
1628 return std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)))->getEnvelopeEnabled();
1629 }
1630
1631 void InstrumentsManager::setInstrumentSSGEnvelope(int instNum, int envNum)
1632 {
1633 auto ssg = std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)));
1634 if (ssg->getEnvelopeEnabled()) {
1635 envSSG_.at(static_cast<size_t>(ssg->getEnvelopeNumber()))->deregisterUserInstrument(instNum);
1636 envSSG_.at(static_cast<size_t>(envNum))->registerUserInstrument(instNum);
1637 }
1638 ssg->setEnvelopeNumber(envNum);
1639 }
1640
1641 int InstrumentsManager::getInstrumentSSGEnvelope(int instNum)
1642 {
1643 return std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)))->getEnvelopeNumber();
1644 }
1645
1646 void InstrumentsManager::addEnvelopeSSGSequenceData(int envNum, const SSGEnvelopeUnit& data)
1647 {
1648 envSSG_.at(static_cast<size_t>(envNum))->addSequenceUnit(data);
1649 }
1650
1651 void InstrumentsManager::removeEnvelopeSSGSequenceData(int envNum)
1652 {
1653 envSSG_.at(static_cast<size_t>(envNum))->removeSequenceUnit();
1654 }
1655
1656 void InstrumentsManager::setEnvelopeSSGSequenceData(int envNum, int cnt, const SSGEnvelopeUnit& data)
1657 {
1658 envSSG_.at(static_cast<size_t>(envNum))->setSequenceUnit(cnt, data);
1659 }
1660
1661 std::vector<SSGEnvelopeUnit> InstrumentsManager::getEnvelopeSSGSequence(int envNum)
1662 {
1663 return envSSG_.at(static_cast<size_t>(envNum))->getSequence();
1664 }
1665
1666 void InstrumentsManager::addEnvelopeSSGLoop(int envNum, const InstrumentSequenceLoop& loop)
1667 {
1668 envSSG_.at(static_cast<size_t>(envNum))->addLoop(loop);
1669 }
1670
1671 void InstrumentsManager::removeEnvelopeSSGLoop(int envNum, int begin, int end)
1672 {
1673 envSSG_.at(static_cast<size_t>(envNum))->removeLoop(begin, end);
1674 }
1675
1676 void InstrumentsManager::changeEnvelopeSSGLoop(int envNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
1677 {
1678 envSSG_.at(static_cast<size_t>(envNum))->changeLoop(prevBegin, prevEnd, loop);
1679 }
1680
1681 void InstrumentsManager::clearEnvelopeSSGLoops(int envNum)
1682 {
1683 envSSG_.at(static_cast<size_t>(envNum))->clearLoops();
1684 }
1685
1686 InstrumentSequenceLoopRoot InstrumentsManager::getEnvelopeSSGLoopRoot(int envNum) const
1687 {
1688 return envSSG_.at(static_cast<size_t>(envNum))->getLoopRoot();
1689 }
1690
1691 void InstrumentsManager::setEnvelopeSSGRelease(int envNum, const InstrumentSequenceRelease& release)
1692 {
1693 envSSG_.at(static_cast<size_t>(envNum))->setRelease(release);
1694 }
1695
1696 InstrumentSequenceRelease InstrumentsManager::getEnvelopeSSGRelease(int envNum) const
1697 {
1698 return envSSG_.at(static_cast<size_t>(envNum))->getRelease();
1699 }
1700
1701 SSGEnvelopeIter InstrumentsManager::getEnvelopeSSGIterator(int envNum) const
1702 {
1703 return envSSG_.at(static_cast<size_t>(envNum))->getIterator();
1704 }
1705
1706 std::multiset<int> InstrumentsManager::getEnvelopeSSGUsers(int envNum) const
1707 {
1708 return envSSG_.at(static_cast<size_t>(envNum))->getUserInstruments();
1709 }
1710
1711 std::vector<int> InstrumentsManager::getEnvelopeSSGEntriedIndices() const
1712 {
1713 return utils::findIndicesIf(envSSG_, IsUsedOrEdited<decltype(envSSG_)>());
1714 }
1715
1716 int InstrumentsManager::findFirstAssignableEnvelopeSSG() const
1717 {
1718 return findFirstAssignableProperty(envSSG_, regardingUnedited_);
1719 }
1720
1721 void InstrumentsManager::setInstrumentSSGArpeggioEnabled(int instNum, bool enabled)
1722 {
1723 auto ssg = std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)));
1724 ssg->setArpeggioEnabled(enabled);
1725 if (enabled)
1726 arpSSG_.at(static_cast<size_t>(ssg->getArpeggioNumber()))->registerUserInstrument(instNum);
1727 else
1728 arpSSG_.at(static_cast<size_t>(ssg->getArpeggioNumber()))->deregisterUserInstrument(instNum);
1729 }
1730
1731 bool InstrumentsManager::getInstrumentSSGArpeggioEnabled(int instNum) const
1732 {
1733 return std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)))->getArpeggioEnabled();
1734 }
1735
1736 void InstrumentsManager::setInstrumentSSGArpeggio(int instNum, int arpNum)
1737 {
1738 auto ssg = std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)));
1739 if (ssg->getArpeggioEnabled()) {
1740 arpSSG_.at(static_cast<size_t>(ssg->getArpeggioNumber()))->deregisterUserInstrument(instNum);
1741 arpSSG_.at(static_cast<size_t>(arpNum))->registerUserInstrument(instNum);
1742 }
1743 ssg->setArpeggioNumber(arpNum);
1744 }
1745
1746 int InstrumentsManager::getInstrumentSSGArpeggio(int instNum)
1747 {
1748 return std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)))->getArpeggioNumber();
1749 }
1750
1751 void InstrumentsManager::setArpeggioSSGType(int arpNum, SequenceType type)
1752 {
1753 arpSSG_.at(static_cast<size_t>(arpNum))->setType(type);
1754 }
1755
1756 SequenceType InstrumentsManager::getArpeggioSSGType(int arpNum) const
1757 {
1758 return arpSSG_.at(static_cast<size_t>(arpNum))->getType();
1759 }
1760
1761 void InstrumentsManager::addArpeggioSSGSequenceData(int arpNum, int data)
1762 {
1763 arpSSG_.at(static_cast<size_t>(arpNum))->addSequenceUnit(ArpeggioUnit(data));
1764 }
1765
1766 void InstrumentsManager::removeArpeggioSSGSequenceData(int arpNum)
1767 {
1768 arpSSG_.at(static_cast<size_t>(arpNum))->removeSequenceUnit();
1769 }
1770
1771 void InstrumentsManager::setArpeggioSSGSequenceData(int arpNum, int cnt, int data)
1772 {
1773 arpSSG_.at(static_cast<size_t>(arpNum))->setSequenceUnit(cnt, ArpeggioUnit(data));
1774 }
1775
1776 std::vector<ArpeggioUnit> InstrumentsManager::getArpeggioSSGSequence(int arpNum)
1777 {
1778 return arpSSG_.at(static_cast<size_t>(arpNum))->getSequence();
1779 }
1780
1781 void InstrumentsManager::addArpeggioSSGLoop(int arpNum, const InstrumentSequenceLoop& loop)
1782 {
1783 arpSSG_.at(static_cast<size_t>(arpNum))->addLoop(loop);
1784 }
1785
1786 void InstrumentsManager::removeArpeggioSSGLoop(int arpNum, int begin, int end)
1787 {
1788 arpSSG_.at(static_cast<size_t>(arpNum))->removeLoop(begin, end);
1789 }
1790
1791 void InstrumentsManager::changeArpeggioSSGLoop(int arpNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
1792 {
1793 arpSSG_.at(static_cast<size_t>(arpNum))->changeLoop(prevBegin, prevEnd, loop);
1794 }
1795
1796 void InstrumentsManager::clearArpeggioSSGLoops(int arpNum)
1797 {
1798 arpSSG_.at(static_cast<size_t>(arpNum))->clearLoops();
1799 }
1800
1801 InstrumentSequenceLoopRoot InstrumentsManager::getArpeggioSSGLoopRoot(int arpNum) const
1802 {
1803 return arpSSG_.at(static_cast<size_t>(arpNum))->getLoopRoot();
1804 }
1805
1806 void InstrumentsManager::setArpeggioSSGRelease(int arpNum, const InstrumentSequenceRelease& release)
1807 {
1808 arpSSG_.at(static_cast<size_t>(arpNum))->setRelease(release);
1809 }
1810
1811 InstrumentSequenceRelease InstrumentsManager::getArpeggioSSGRelease(int arpNum) const
1812 {
1813 return arpSSG_.at(static_cast<size_t>(arpNum))->getRelease();
1814 }
1815
1816 ArpeggioIter InstrumentsManager::getArpeggioSSGIterator(int arpNum) const
1817 {
1818 return arpSSG_.at(static_cast<size_t>(arpNum))->getIterator();
1819 }
1820
1821 std::multiset<int> InstrumentsManager::getArpeggioSSGUsers(int arpNum) const
1822 {
1823 return arpSSG_.at(static_cast<size_t>(arpNum))->getUserInstruments();
1824 }
1825
1826 std::vector<int> InstrumentsManager::getArpeggioSSGEntriedIndices() const
1827 {
1828 return utils::findIndicesIf(arpSSG_, IsUsedOrEdited<decltype(arpSSG_)>());
1829 }
1830
1831 int InstrumentsManager::findFirstAssignableArpeggioSSG() const
1832 {
1833 return findFirstAssignableProperty(arpSSG_, regardingUnedited_);
1834 }
1835
1836 void InstrumentsManager::setInstrumentSSGPitchEnabled(int instNum, bool enabled)
1837 {
1838 auto ssg = std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)));
1839 ssg->setPitchEnabled(enabled);
1840 if (enabled)
1841 ptSSG_.at(static_cast<size_t>(ssg->getPitchNumber()))->registerUserInstrument(instNum);
1842 else
1843 ptSSG_.at(static_cast<size_t>(ssg->getPitchNumber()))->deregisterUserInstrument(instNum);
1844 }
1845
1846 bool InstrumentsManager::getInstrumentSSGPitchEnabled(int instNum) const
1847 {
1848 return std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)))->getPitchEnabled();
1849 }
1850
1851 void InstrumentsManager::setInstrumentSSGPitch(int instNum, int ptNum)
1852 {
1853 auto ssg = std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)));
1854 if (ssg->getPitchEnabled()) {
1855 ptSSG_.at(static_cast<size_t>(ssg->getPitchNumber()))->deregisterUserInstrument(instNum);
1856 ptSSG_.at(static_cast<size_t>(ptNum))->registerUserInstrument(instNum);
1857 }
1858 ssg->setPitchNumber(ptNum);
1859 }
1860
1861 int InstrumentsManager::getInstrumentSSGPitch(int instNum)
1862 {
1863 return std::dynamic_pointer_cast<InstrumentSSG>(insts_.at(static_cast<size_t>(instNum)))->getPitchNumber();
1864 }
1865
1866 void InstrumentsManager::setPitchSSGType(int ptNum, SequenceType type)
1867 {
1868 ptSSG_.at(static_cast<size_t>(ptNum))->setType(type);
1869 }
1870
1871 SequenceType InstrumentsManager::getPitchSSGType(int ptNum) const
1872 {
1873 return ptSSG_.at(static_cast<size_t>(ptNum))->getType();
1874 }
1875
1876 void InstrumentsManager::addPitchSSGSequenceData(int ptNum, int data)
1877 {
1878 ptSSG_.at(static_cast<size_t>(ptNum))->addSequenceUnit(PitchUnit(data));
1879 }
1880
1881 void InstrumentsManager::removePitchSSGSequenceData(int ptNum)
1882 {
1883 ptSSG_.at(static_cast<size_t>(ptNum))->removeSequenceUnit();
1884 }
1885
1886 void InstrumentsManager::setPitchSSGSequenceData(int ptNum, int cnt, int data)
1887 {
1888 ptSSG_.at(static_cast<size_t>(ptNum))->setSequenceUnit(cnt, PitchUnit(data));
1889 }
1890
1891 std::vector<PitchUnit> InstrumentsManager::getPitchSSGSequence(int ptNum)
1892 {
1893 return ptSSG_.at(static_cast<size_t>(ptNum))->getSequence();
1894 }
1895
1896 void InstrumentsManager::addPitchSSGLoop(int ptNum, const InstrumentSequenceLoop& loop)
1897 {
1898 ptSSG_.at(static_cast<size_t>(ptNum))->addLoop(loop);
1899 }
1900
1901 void InstrumentsManager::removePitchSSGLoop(int ptNum, int begin, int end)
1902 {
1903 ptSSG_.at(static_cast<size_t>(ptNum))->removeLoop(begin, end);
1904 }
1905
1906 void InstrumentsManager::changePitchSSGLoop(int ptNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
1907 {
1908 ptSSG_.at(static_cast<size_t>(ptNum))->changeLoop(prevBegin, prevEnd, loop);
1909 }
1910
1911 void InstrumentsManager::clearPitchSSGLoops(int ptNum)
1912 {
1913 ptSSG_.at(static_cast<size_t>(ptNum))->clearLoops();
1914 }
1915
1916 InstrumentSequenceLoopRoot InstrumentsManager::getPitchSSGLoopRoot(int ptNum) const
1917 {
1918 return ptSSG_.at(static_cast<size_t>(ptNum))->getLoopRoot();
1919 }
1920
1921 void InstrumentsManager::setPitchSSGRelease(int ptNum, const InstrumentSequenceRelease& release)
1922 {
1923 ptSSG_.at(static_cast<size_t>(ptNum))->setRelease(release);
1924 }
1925
1926 InstrumentSequenceRelease InstrumentsManager::getPitchSSGRelease(int ptNum) const
1927 {
1928 return ptSSG_.at(static_cast<size_t>(ptNum))->getRelease();
1929 }
1930
1931 PitchIter InstrumentsManager::getPitchSSGIterator(int ptNum) const
1932 {
1933 return ptSSG_.at(static_cast<size_t>(ptNum))->getIterator();
1934 }
1935
1936 std::multiset<int> InstrumentsManager::getPitchSSGUsers(int ptNum) const
1937 {
1938 return ptSSG_.at(static_cast<size_t>(ptNum))->getUserInstruments();
1939 }
1940
1941 std::vector<int> InstrumentsManager::getPitchSSGEntriedIndices() const
1942 {
1943 return utils::findIndicesIf(ptSSG_, IsUsedOrEdited<decltype(ptSSG_)>());
1944 }
1945
1946 int InstrumentsManager::findFirstAssignablePitchSSG() const
1947 {
1948 return findFirstAssignableProperty(ptSSG_, regardingUnedited_);
1949 }
1950
1951 bool InstrumentsManager::equalPropertiesSSG(std::shared_ptr<AbstractInstrument> a, std::shared_ptr<AbstractInstrument> b) const
1952 {
1953 auto aSsg = std::dynamic_pointer_cast<InstrumentSSG>(a);
1954 auto bSsg = std::dynamic_pointer_cast<InstrumentSSG>(b);
1955
1956 if (aSsg->getWaveformEnabled() != bSsg->getWaveformEnabled())
1957 return false;
1958 if (aSsg->getWaveformEnabled()
1959 && *wfSSG_[aSsg->getWaveformNumber()] != *wfSSG_[bSsg->getWaveformNumber()])
1960 return false;
1961 if (aSsg->getToneNoiseEnabled() != bSsg->getToneNoiseEnabled())
1962 return false;
1963 if (aSsg->getToneNoiseEnabled()
1964 && *tnSSG_[aSsg->getToneNoiseNumber()] != *tnSSG_[bSsg->getToneNoiseNumber()])
1965 return false;
1966 if (aSsg->getEnvelopeEnabled() != bSsg->getEnvelopeEnabled())
1967 return false;
1968 if (aSsg->getEnvelopeEnabled()
1969 && *envSSG_[aSsg->getEnvelopeNumber()] != *envSSG_[bSsg->getEnvelopeNumber()])
1970 return false;
1971 if (aSsg->getArpeggioEnabled() != bSsg->getArpeggioEnabled())
1972 return false;
1973 if (aSsg->getArpeggioEnabled()
1974 && *arpSSG_[aSsg->getArpeggioNumber()] != *arpSSG_[bSsg->getArpeggioNumber()])
1975 return false;
1976 if (aSsg->getPitchEnabled() != bSsg->getPitchEnabled())
1977 return false;
1978 if (aSsg->getPitchEnabled()
1979 && *ptSSG_[aSsg->getPitchNumber()] != *ptSSG_[bSsg->getPitchNumber()])
1980 return false;
1981 return true;
1982 }
1983
1984 //----- ADPCM methods -----
1985 void InstrumentsManager::setInstrumentADPCMSample(int instNum, int sampNum)
1986 {
1987 auto adpcm = std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)));
1988 sampADPCM_.at(static_cast<size_t>(adpcm->getSampleNumber()))->deregisterUserInstrument(instNum);
1989 sampADPCM_.at(static_cast<size_t>(sampNum))->registerUserInstrument(instNum);
1990
1991 adpcm->setSampleNumber(sampNum);
1992 }
1993
1994 int InstrumentsManager::getInstrumentADPCMSample(int instNum)
1995 {
1996 return std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)))->getSampleNumber();
1997 }
1998
1999 void InstrumentsManager::setSampleADPCMRootKeyNumber(int sampNum, int n)
2000 {
2001 sampADPCM_.at(static_cast<size_t>(sampNum))->setRootKeyNumber(n);
2002 }
2003
2004 int InstrumentsManager::getSampleADPCMRootKeyNumber(int sampNum) const
2005 {
2006 return sampADPCM_.at(static_cast<size_t>(sampNum))->getRootKeyNumber();
2007 }
2008
2009 void InstrumentsManager::setSampleADPCMRootDeltaN(int sampNum, int dn)
2010 {
2011 sampADPCM_.at(static_cast<size_t>(sampNum))->setRootDeltaN(dn);
2012 }
2013
2014 int InstrumentsManager::getSampleADPCMRootDeltaN(int sampNum) const
2015 {
2016 return sampADPCM_.at(static_cast<size_t>(sampNum))->getRootDeltaN();
2017 }
2018
2019 void InstrumentsManager::setSampleADPCMRepeatEnabled(int sampNum, bool enabled)
2020 {
2021 sampADPCM_.at(static_cast<size_t>(sampNum))->setRepeatEnabled(enabled);
2022 }
2023
2024 bool InstrumentsManager::isSampleADPCMRepeatable(int sampNum) const
2025 {
2026 return sampADPCM_.at(static_cast<size_t>(sampNum))->isRepeatable();
2027 }
2028
2029 bool InstrumentsManager::setSampleADPCMRepeatrange(int sampNum, const SampleRepeatRange& range)
2030 {
2031 return sampADPCM_.at(static_cast<size_t>(sampNum))->setRepeatRange(range);
2032 }
2033
2034 SampleRepeatFlag InstrumentsManager::getSampleADPCMRepeatFlag(int sampNum) const
2035 {
2036 return sampADPCM_.at(static_cast<size_t>(sampNum))->getRepeatFlag();
2037 }
2038
2039 SampleRepeatRange InstrumentsManager::getSampleADPCMRepeatRange(int sampNum) const
2040 {
2041 return sampADPCM_.at(static_cast<size_t>(sampNum))->getRepeatRange();
2042 }
2043
2044 void InstrumentsManager::storeSampleADPCMRawSample(int sampNum, const std::vector<uint8_t>& sample)
2045 {
2046 sampADPCM_.at(static_cast<size_t>(sampNum))->storeSample(sample);
2047 }
2048
2049 void InstrumentsManager::storeSampleADPCMRawSample(int sampNum, std::vector<uint8_t>&& sample)
2050 {
2051 sampADPCM_.at(static_cast<size_t>(sampNum))->storeSample(sample);
2052 }
2053
2054 void InstrumentsManager::clearSampleADPCMRawSample(int sampNum)
2055 {
2056 sampADPCM_.at(static_cast<size_t>(sampNum))->clearSample();
2057 }
2058
2059 std::vector<uint8_t> InstrumentsManager::getSampleADPCMRawSample(int sampNum) const
2060 {
2061 return sampADPCM_.at(static_cast<size_t>(sampNum))->getSamples();
2062 }
2063
2064 void InstrumentsManager::setSampleADPCMStartAddress(int sampNum, size_t addr)
2065 {
2066 sampADPCM_.at(static_cast<size_t>(sampNum))->setStartAddress(addr);
2067 }
2068
2069 size_t InstrumentsManager::getSampleADPCMStartAddress(int sampNum) const
2070 {
2071 return sampADPCM_.at(static_cast<size_t>(sampNum))->getStartAddress();
2072 }
2073
2074 void InstrumentsManager::setSampleADPCMStopAddress(int sampNum, size_t addr)
2075 {
2076 sampADPCM_.at(static_cast<size_t>(sampNum))->setStopAddress(addr);
2077 }
2078
2079 size_t InstrumentsManager::getSampleADPCMStopAddress(int sampNum) const
2080 {
2081 return sampADPCM_.at(static_cast<size_t>(sampNum))->getStopAddress();
2082 }
2083
2084 std::multiset<int> InstrumentsManager::getSampleADPCMUsers(int sampNum) const
2085 {
2086 return sampADPCM_.at(static_cast<size_t>(sampNum))->getUserInstruments();
2087 }
2088
2089 std::vector<int> InstrumentsManager::getSampleADPCMEntriedIndices() const
2090 {
2091 return utils::findIndicesIf(sampADPCM_, IsEdited<decltype(sampADPCM_)>());
2092 }
2093
2094 std::vector<int> InstrumentsManager::getSampleADPCMValidIndices() const
2095 {
2096 return utils::findIndicesIf(sampADPCM_, IsUsedOrEdited<decltype(sampADPCM_)>());
2097 }
2098
2099 void InstrumentsManager::clearUnusedSamplesADPCM()
2100 {
2101 for (size_t i = 0; i < 128; ++i) {
2102 if (!sampADPCM_[i]->isUserInstrument())
2103 sampADPCM_[i] = std::make_shared<SampleADPCM>(i);
2104 }
2105 }
2106
2107 int InstrumentsManager::findFirstAssignableSampleADPCM(int startIndex) const
2108 {
2109 return findFirstAssignableProperty(sampADPCM_, regardingUnedited_, startIndex);
2110 }
2111
2112 void InstrumentsManager::setInstrumentADPCMEnvelopeEnabled(int instNum, bool enabled)
2113 {
2114 auto adpcm = std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)));
2115 adpcm->setEnvelopeEnabled(enabled);
2116 if (enabled)
2117 envADPCM_.at(static_cast<size_t>(adpcm->getEnvelopeNumber()))->registerUserInstrument(instNum);
2118 else
2119 envADPCM_.at(static_cast<size_t>(adpcm->getEnvelopeNumber()))->deregisterUserInstrument(instNum);
2120 }
2121
2122 bool InstrumentsManager::getInstrumentADPCMEnvelopeEnabled(int instNum) const
2123 {
2124 return std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)))->getEnvelopeEnabled();
2125 }
2126
2127 void InstrumentsManager::setInstrumentADPCMEnvelope(int instNum, int envNum)
2128 {
2129 auto adpcm = std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)));
2130 if (adpcm->getEnvelopeEnabled()) {
2131 envADPCM_.at(static_cast<size_t>(adpcm->getEnvelopeNumber()))->deregisterUserInstrument(instNum);
2132 envADPCM_.at(static_cast<size_t>(envNum))->registerUserInstrument(instNum);
2133 }
2134 adpcm->setEnvelopeNumber(envNum);
2135 }
2136
2137 int InstrumentsManager::getInstrumentADPCMEnvelope(int instNum)
2138 {
2139 return std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)))->getEnvelopeNumber();
2140 }
2141
2142 void InstrumentsManager::addEnvelopeADPCMSequenceData(int envNum, int data)
2143 {
2144 envADPCM_.at(static_cast<size_t>(envNum))->addSequenceUnit(ADPCMEnvelopeUnit(data));
2145 }
2146
2147 void InstrumentsManager::removeEnvelopeADPCMSequenceData(int envNum)
2148 {
2149 envADPCM_.at(static_cast<size_t>(envNum))->removeSequenceUnit();
2150 }
2151
2152 void InstrumentsManager::setEnvelopeADPCMSequenceData(int envNum, int cnt, int data)
2153 {
2154 envADPCM_.at(static_cast<size_t>(envNum))->setSequenceUnit(cnt, ADPCMEnvelopeUnit(data));
2155 }
2156
2157 std::vector<ADPCMEnvelopeUnit> InstrumentsManager::getEnvelopeADPCMSequence(int envNum)
2158 {
2159 return envADPCM_.at(static_cast<size_t>(envNum))->getSequence();
2160 }
2161
2162 void InstrumentsManager::addEnvelopeADPCMLoop(int envNum, const InstrumentSequenceLoop& loop)
2163 {
2164 envADPCM_.at(static_cast<size_t>(envNum))->addLoop(loop);
2165 }
2166
2167 void InstrumentsManager::removeEnvelopeADPCMLoop(int envNum, int begin, int end)
2168 {
2169 envADPCM_.at(static_cast<size_t>(envNum))->removeLoop(begin, end);
2170 }
2171
2172 void InstrumentsManager::changeEnvelopeADPCMLoop(int envNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
2173 {
2174 envADPCM_.at(static_cast<size_t>(envNum))->changeLoop(prevBegin, prevEnd, loop);
2175 }
2176
2177 void InstrumentsManager::clearEnvelopeADPCMLoops(int envNum)
2178 {
2179 envADPCM_.at(static_cast<size_t>(envNum))->clearLoops();
2180 }
2181
2182 InstrumentSequenceLoopRoot InstrumentsManager::getEnvelopeADPCMLoopRoot(int envNum) const
2183 {
2184 return envADPCM_.at(static_cast<size_t>(envNum))->getLoopRoot();
2185 }
2186
2187 void InstrumentsManager::setEnvelopeADPCMRelease(int envNum, const InstrumentSequenceRelease& release)
2188 {
2189 envADPCM_.at(static_cast<size_t>(envNum))->setRelease(release);
2190 }
2191
2192 InstrumentSequenceRelease InstrumentsManager::getEnvelopeADPCMRelease(int envNum) const
2193 {
2194 return envADPCM_.at(static_cast<size_t>(envNum))->getRelease();
2195 }
2196
2197 ADPCMEnvelopeIter InstrumentsManager::getEnvelopeADPCMIterator(int envNum) const
2198 {
2199 return envADPCM_.at(static_cast<size_t>(envNum))->getIterator();
2200 }
2201
2202 std::multiset<int> InstrumentsManager::getEnvelopeADPCMUsers(int envNum) const
2203 {
2204 return envADPCM_.at(static_cast<size_t>(envNum))->getUserInstruments();
2205 }
2206
2207 std::vector<int> InstrumentsManager::getEnvelopeADPCMEntriedIndices() const
2208 {
2209 return utils::findIndicesIf(envADPCM_, IsUsedOrEdited<decltype(envADPCM_)>());
2210 }
2211
2212 int InstrumentsManager::findFirstAssignableEnvelopeADPCM() const
2213 {
2214 return findFirstAssignableProperty(envADPCM_, regardingUnedited_);
2215 }
2216
2217 void InstrumentsManager::setInstrumentADPCMArpeggioEnabled(int instNum, bool enabled)
2218 {
2219 auto adpcm = std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)));
2220 adpcm->setArpeggioEnabled(enabled);
2221 if (enabled)
2222 arpADPCM_.at(static_cast<size_t>(adpcm->getArpeggioNumber()))->registerUserInstrument(instNum);
2223 else
2224 arpADPCM_.at(static_cast<size_t>(adpcm->getArpeggioNumber()))->deregisterUserInstrument(instNum);
2225 }
2226
2227 bool InstrumentsManager::getInstrumentADPCMArpeggioEnabled(int instNum) const
2228 {
2229 return std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)))->getArpeggioEnabled();
2230 }
2231
2232 void InstrumentsManager::setInstrumentADPCMArpeggio(int instNum, int arpNum)
2233 {
2234 auto adpcm = std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)));
2235 if (adpcm->getArpeggioEnabled()) {
2236 arpADPCM_.at(static_cast<size_t>(adpcm->getArpeggioNumber()))->deregisterUserInstrument(instNum);
2237 arpADPCM_.at(static_cast<size_t>(arpNum))->registerUserInstrument(instNum);
2238 }
2239 adpcm->setArpeggioNumber(arpNum);
2240 }
2241
2242 int InstrumentsManager::getInstrumentADPCMArpeggio(int instNum)
2243 {
2244 return std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)))->getArpeggioNumber();
2245 }
2246
2247 void InstrumentsManager::setArpeggioADPCMType(int arpNum, SequenceType type)
2248 {
2249 arpADPCM_.at(static_cast<size_t>(arpNum))->setType(type);
2250 }
2251
2252 SequenceType InstrumentsManager::getArpeggioADPCMType(int arpNum) const
2253 {
2254 return arpADPCM_.at(static_cast<size_t>(arpNum))->getType();
2255 }
2256
2257 void InstrumentsManager::addArpeggioADPCMSequenceData(int arpNum, int data)
2258 {
2259 arpADPCM_.at(static_cast<size_t>(arpNum))->addSequenceUnit(ArpeggioUnit(data));
2260 }
2261
2262 void InstrumentsManager::removeArpeggioADPCMSequenceData(int arpNum)
2263 {
2264 arpADPCM_.at(static_cast<size_t>(arpNum))->removeSequenceUnit();
2265 }
2266
2267 void InstrumentsManager::setArpeggioADPCMSequenceData(int arpNum, int cnt, int data)
2268 {
2269 arpADPCM_.at(static_cast<size_t>(arpNum))->setSequenceUnit(cnt, ArpeggioUnit(data));
2270 }
2271
2272 std::vector<ArpeggioUnit> InstrumentsManager::getArpeggioADPCMSequence(int arpNum)
2273 {
2274 return arpADPCM_.at(static_cast<size_t>(arpNum))->getSequence();
2275 }
2276
2277 void InstrumentsManager::addArpeggioADPCMLoop(int arpNum, const InstrumentSequenceLoop& loop)
2278 {
2279 arpADPCM_.at(static_cast<size_t>(arpNum))->addLoop(loop);
2280 }
2281
2282 void InstrumentsManager::removeArpeggioADPCMLoop(int arpNum, int begin, int end)
2283 {
2284 arpADPCM_.at(static_cast<size_t>(arpNum))->removeLoop(begin, end);
2285 }
2286
2287 void InstrumentsManager::changeArpeggioADPCMLoop(int arpNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
2288 {
2289 arpADPCM_.at(static_cast<size_t>(arpNum))->changeLoop(prevBegin, prevEnd, loop);
2290 }
2291
2292 void InstrumentsManager::clearArpeggioADPCMLoops(int arpNum)
2293 {
2294 arpADPCM_.at(static_cast<size_t>(arpNum))->clearLoops();
2295 }
2296
2297 InstrumentSequenceLoopRoot InstrumentsManager::getArpeggioADPCMLoopRoot(int arpNum) const
2298 {
2299 return arpADPCM_.at(static_cast<size_t>(arpNum))->getLoopRoot();
2300 }
2301
2302 void InstrumentsManager::setArpeggioADPCMRelease(int arpNum, const InstrumentSequenceRelease& release)
2303 {
2304 arpADPCM_.at(static_cast<size_t>(arpNum))->setRelease(release);
2305 }
2306
2307 InstrumentSequenceRelease InstrumentsManager::getArpeggioADPCMRelease(int arpNum) const
2308 {
2309 return arpADPCM_.at(static_cast<size_t>(arpNum))->getRelease();
2310 }
2311
2312 ArpeggioIter InstrumentsManager::getArpeggioADPCMIterator(int arpNum) const
2313 {
2314 return arpADPCM_.at(static_cast<size_t>(arpNum))->getIterator();
2315 }
2316
2317 std::multiset<int> InstrumentsManager::getArpeggioADPCMUsers(int arpNum) const
2318 {
2319 return arpADPCM_.at(static_cast<size_t>(arpNum))->getUserInstruments();
2320 }
2321
2322 std::vector<int> InstrumentsManager::getArpeggioADPCMEntriedIndices() const
2323 {
2324 return utils::findIndicesIf(arpADPCM_, IsUsedOrEdited<decltype(arpADPCM_)>());
2325 }
2326
2327 int InstrumentsManager::findFirstAssignableArpeggioADPCM() const
2328 {
2329 return findFirstAssignableProperty(arpADPCM_, regardingUnedited_);
2330 }
2331
2332 void InstrumentsManager::setInstrumentADPCMPitchEnabled(int instNum, bool enabled)
2333 {
2334 auto adpcm = std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)));
2335 adpcm->setPitchEnabled(enabled);
2336 if (enabled)
2337 ptADPCM_.at(static_cast<size_t>(adpcm->getPitchNumber()))->registerUserInstrument(instNum);
2338 else
2339 ptADPCM_.at(static_cast<size_t>(adpcm->getPitchNumber()))->deregisterUserInstrument(instNum);
2340 }
2341
2342 bool InstrumentsManager::getInstrumentADPCMPitchEnabled(int instNum) const
2343 {
2344 return std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)))->getPitchEnabled();
2345 }
2346
2347 void InstrumentsManager::setInstrumentADPCMPitch(int instNum, int ptNum)
2348 {
2349 auto adpcm = std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)));
2350 if (adpcm->getPitchEnabled()) {
2351 ptADPCM_.at(static_cast<size_t>(adpcm->getPitchNumber()))->deregisterUserInstrument(instNum);
2352 ptADPCM_.at(static_cast<size_t>(ptNum))->registerUserInstrument(instNum);
2353 }
2354 adpcm->setPitchNumber(ptNum);
2355 }
2356
2357 int InstrumentsManager::getInstrumentADPCMPitch(int instNum)
2358 {
2359 return std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)))->getPitchNumber();
2360 }
2361
2362 void InstrumentsManager::setPitchADPCMType(int ptNum, SequenceType type)
2363 {
2364 ptADPCM_.at(static_cast<size_t>(ptNum))->setType(type);
2365 }
2366
2367 SequenceType InstrumentsManager::getPitchADPCMType(int ptNum) const
2368 {
2369 return ptADPCM_.at(static_cast<size_t>(ptNum))->getType();
2370 }
2371
2372 void InstrumentsManager::addPitchADPCMSequenceData(int ptNum, int data)
2373 {
2374 ptADPCM_.at(static_cast<size_t>(ptNum))->addSequenceUnit(PitchUnit(data));
2375 }
2376
2377 void InstrumentsManager::removePitchADPCMSequenceData(int ptNum)
2378 {
2379 ptADPCM_.at(static_cast<size_t>(ptNum))->removeSequenceUnit();
2380 }
2381
2382 void InstrumentsManager::setPitchADPCMSequenceData(int ptNum, int cnt, int data)
2383 {
2384 ptADPCM_.at(static_cast<size_t>(ptNum))->setSequenceUnit(cnt, PitchUnit(data));
2385 }
2386
2387 std::vector<PitchUnit> InstrumentsManager::getPitchADPCMSequence(int ptNum)
2388 {
2389 return ptADPCM_.at(static_cast<size_t>(ptNum))->getSequence();
2390 }
2391
2392 void InstrumentsManager::addPitchADPCMLoop(int ptNum, const InstrumentSequenceLoop& loop)
2393 {
2394 ptADPCM_.at(static_cast<size_t>(ptNum))->addLoop(loop);
2395 }
2396
2397 void InstrumentsManager::removePitchADPCMLoop(int ptNum, int begin, int end)
2398 {
2399 ptADPCM_.at(static_cast<size_t>(ptNum))->removeLoop(begin, end);
2400 }
2401
2402 void InstrumentsManager::changePitchADPCMLoop(int ptNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
2403 {
2404 ptADPCM_.at(static_cast<size_t>(ptNum))->changeLoop(prevBegin, prevEnd, loop);
2405 }
2406
2407 void InstrumentsManager::clearPitchADPCMLoops(int ptNum)
2408 {
2409 ptADPCM_.at(static_cast<size_t>(ptNum))->clearLoops();
2410 }
2411
2412 InstrumentSequenceLoopRoot InstrumentsManager::getPitchADPCMLoopRoot(int ptNum) const
2413 {
2414 return ptADPCM_.at(static_cast<size_t>(ptNum))->getLoopRoot();
2415 }
2416
2417 void InstrumentsManager::setPitchADPCMRelease(int ptNum, const InstrumentSequenceRelease& release)
2418 {
2419 ptADPCM_.at(static_cast<size_t>(ptNum))->setRelease(release);
2420 }
2421
2422 InstrumentSequenceRelease InstrumentsManager::getPitchADPCMRelease(int ptNum) const
2423 {
2424 return ptADPCM_.at(static_cast<size_t>(ptNum))->getRelease();
2425 }
2426
2427 PitchIter InstrumentsManager::getPitchADPCMIterator(int ptNum) const
2428 {
2429 return ptADPCM_.at(static_cast<size_t>(ptNum))->getIterator();
2430 }
2431
2432 std::multiset<int> InstrumentsManager::getPitchADPCMUsers(int ptNum) const
2433 {
2434 return ptADPCM_.at(static_cast<size_t>(ptNum))->getUserInstruments();
2435 }
2436
2437 std::vector<int> InstrumentsManager::getPitchADPCMEntriedIndices() const
2438 {
2439 return utils::findIndicesIf(ptADPCM_, IsUsedOrEdited<decltype(ptADPCM_)>());
2440 }
2441
2442 int InstrumentsManager::findFirstAssignablePitchADPCM() const
2443 {
2444 return findFirstAssignableProperty(ptADPCM_, regardingUnedited_);
2445 }
2446
2447 void InstrumentsManager::setInstrumentADPCMPanEnabled(int instNum, bool enabled)
2448 {
2449 auto adpcm = std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)));
2450 adpcm->setPanEnabled(enabled);
2451 if (enabled)
2452 panADPCM_.at(static_cast<size_t>(adpcm->getPanNumber()))->registerUserInstrument(instNum);
2453 else
2454 panADPCM_.at(static_cast<size_t>(adpcm->getPanNumber()))->deregisterUserInstrument(instNum);
2455 }
2456
2457 bool InstrumentsManager::getInstrumentADPCMPanEnabled(int instNum) const
2458 {
2459 return std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)))->getPanEnabled();
2460 }
2461
2462 void InstrumentsManager::setInstrumentADPCMPan(int instNum, int panNum)
2463 {
2464 auto adpcm = std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)));
2465 if (adpcm->getPanEnabled()) {
2466 panADPCM_.at(static_cast<size_t>(adpcm->getPanNumber()))->deregisterUserInstrument(instNum);
2467 panADPCM_.at(static_cast<size_t>(panNum))->registerUserInstrument(instNum);
2468 }
2469 adpcm->setPanNumber(panNum);
2470 }
2471
2472 int InstrumentsManager::getInstrumentADPCMPan(int instNum)
2473 {
2474 return std::dynamic_pointer_cast<InstrumentADPCM>(insts_.at(static_cast<size_t>(instNum)))->getPanNumber();
2475 }
2476
2477 void InstrumentsManager::addPanADPCMSequenceData(int panNum, int data)
2478 {
2479 panADPCM_.at(static_cast<size_t>(panNum))->addSequenceUnit(PanUnit(data));
2480 }
2481
2482 void InstrumentsManager::removePanADPCMSequenceData(int panNum)
2483 {
2484 panADPCM_.at(static_cast<size_t>(panNum))->removeSequenceUnit();
2485 }
2486
2487 void InstrumentsManager::setPanADPCMSequenceData(int panNum, int cnt, int data)
2488 {
2489 panADPCM_.at(static_cast<size_t>(panNum))->setSequenceUnit(cnt, PanUnit(data));
2490 }
2491
2492 std::vector<PanUnit> InstrumentsManager::getPanADPCMSequence(int panNum)
2493 {
2494 return panADPCM_.at(static_cast<size_t>(panNum))->getSequence();
2495 }
2496
2497 void InstrumentsManager::addPanADPCMLoop(int panNum, const InstrumentSequenceLoop& loop)
2498 {
2499 panADPCM_.at(static_cast<size_t>(panNum))->addLoop(loop);
2500 }
2501
2502 void InstrumentsManager::removePanADPCMLoop(int panNum, int begin, int end)
2503 {
2504 panADPCM_.at(static_cast<size_t>(panNum))->removeLoop(begin, end);
2505 }
2506
2507 void InstrumentsManager::changePanADPCMLoop(int panNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop)
2508 {
2509 panADPCM_.at(static_cast<size_t>(panNum))->changeLoop(prevBegin, prevEnd, loop);
2510 }
2511
2512 void InstrumentsManager::clearPanADPCMLoops(int panNum)
2513 {
2514 panADPCM_.at(static_cast<size_t>(panNum))->clearLoops();
2515 }
2516
2517 InstrumentSequenceLoopRoot InstrumentsManager::getPanADPCMLoopRoot(int panNum) const
2518 {
2519 return panADPCM_.at(static_cast<size_t>(panNum))->getLoopRoot();
2520 }
2521
2522 void InstrumentsManager::setPanADPCMRelease(int panNum, const InstrumentSequenceRelease& release)
2523 {
2524 panADPCM_.at(static_cast<size_t>(panNum))->setRelease(release);
2525 }
2526
2527 InstrumentSequenceRelease InstrumentsManager::getPanADPCMRelease(int panNum) const
2528 {
2529 return panADPCM_.at(static_cast<size_t>(panNum))->getRelease();
2530 }
2531
2532 PanIter InstrumentsManager::getPanADPCMIterator(int panNum) const
2533 {
2534 return panADPCM_.at(static_cast<size_t>(panNum))->getIterator();
2535 }
2536
2537 std::multiset<int> InstrumentsManager::getPanADPCMUsers(int panNum) const
2538 {
2539 return panADPCM_.at(static_cast<size_t>(panNum))->getUserInstruments();
2540 }
2541
2542 std::vector<int> InstrumentsManager::getPanADPCMEntriedIndices() const
2543 {
2544 return utils::findIndicesIf(panADPCM_, IsUsedOrEdited<decltype(panADPCM_)>());
2545 }
2546
2547 int InstrumentsManager::findFirstAssignablePanADPCM() const
2548 {
2549 return findFirstAssignableProperty(panADPCM_, regardingUnedited_);
2550 }
2551
2552 bool InstrumentsManager::equalPropertiesADPCM(std::shared_ptr<AbstractInstrument> a, std::shared_ptr<AbstractInstrument> b) const
2553 {
2554 auto aAdpcm = std::dynamic_pointer_cast<InstrumentADPCM>(a);
2555 auto bAdpcm = std::dynamic_pointer_cast<InstrumentADPCM>(b);
2556
2557 if (*sampADPCM_[aAdpcm->getSampleNumber()] != *sampADPCM_[bAdpcm->getSampleNumber()])
2558 return false;
2559 if (aAdpcm->getEnvelopeEnabled() != bAdpcm->getEnvelopeEnabled())
2560 return false;
2561 if (aAdpcm->getEnvelopeEnabled()
2562 && *envADPCM_[aAdpcm->getEnvelopeNumber()] != *envADPCM_[bAdpcm->getEnvelopeNumber()])
2563 return false;
2564 if (aAdpcm->getArpeggioEnabled() != bAdpcm->getArpeggioEnabled())
2565 return false;
2566 if (aAdpcm->getArpeggioEnabled()
2567 && *arpADPCM_[aAdpcm->getArpeggioNumber()] != *arpADPCM_[bAdpcm->getArpeggioNumber()])
2568 return false;
2569 if (aAdpcm->getPitchEnabled() != bAdpcm->getPitchEnabled())
2570 return false;
2571 if (aAdpcm->getPitchEnabled()
2572 && *ptADPCM_[aAdpcm->getPitchNumber()] != *ptADPCM_[bAdpcm->getPitchNumber()])
2573 return false;
2574 if (aAdpcm->getPanEnabled()
2575 && *panADPCM_[aAdpcm->getPanNumber()] != *panADPCM_[bAdpcm->getPanNumber()])
2576 return false;
2577 return true;
2578 }
2579
2580 //----- Drumkit methods -----
2581 void InstrumentsManager::setInstrumentDrumkitSamplesEnabled(int instNum, int key, bool enabled)
2582 {
2583 auto kit = std::dynamic_pointer_cast<InstrumentDrumkit>(insts_.at(static_cast<size_t>(instNum)));
2584 if (enabled) {
2585 kit->setSampleEnabled(key, true);
2586 sampADPCM_.at(static_cast<size_t>(kit->getSampleNumber(key)))->registerUserInstrument(instNum);
2587 }
2588 else {
2589 sampADPCM_.at(static_cast<size_t>(kit->getSampleNumber(key)))->deregisterUserInstrument(instNum);
2590 kit->setSampleEnabled(key, false);
2591 }
2592 }
2593
2594 bool InstrumentsManager::getInstrumentDrumkitSamplesEnabled(int instNum, int key) const
2595 {
2596 return std::dynamic_pointer_cast<InstrumentDrumkit>(insts_.at(static_cast<size_t>(instNum)))->getSampleEnabled(key);
2597 }
2598
2599 void InstrumentsManager::setInstrumentDrumkitSamples(int instNum, int key, int sampNum)
2600 {
2601 auto kit = std::dynamic_pointer_cast<InstrumentDrumkit>(insts_.at(static_cast<size_t>(instNum)));
2602 sampADPCM_.at(static_cast<size_t>(kit->getSampleNumber(key)))->deregisterUserInstrument(instNum);
2603 sampADPCM_.at(static_cast<size_t>(sampNum))->registerUserInstrument(instNum);
2604
2605 kit->setSampleNumber(key, sampNum);
2606 }
2607
2608 int InstrumentsManager::getInstrumentDrumkitSamples(int instNum, int key)
2609 {
2610 return std::dynamic_pointer_cast<InstrumentDrumkit>(insts_.at(static_cast<size_t>(instNum)))->getSampleNumber(key);
2611 }
2612
2613 void InstrumentsManager::setInstrumentDrumkitPitch(int instNum, int key, int pitch)
2614 {
2615 std::dynamic_pointer_cast<InstrumentDrumkit>(insts_.at(static_cast<size_t>(instNum)))->setPitch(key, pitch);
2616 }
2617
2618 void InstrumentsManager::setInstrumentDrumkitPan(int instNum, int key, int pan)
2619 {
2620 std::dynamic_pointer_cast<InstrumentDrumkit>(insts_.at(static_cast<size_t>(instNum)))->setPan(key, pan);
2621 }
2622
2623 bool InstrumentsManager::equalPropertiesDrumkit(std::shared_ptr<AbstractInstrument> a, std::shared_ptr<AbstractInstrument> b) const
2624 {
2625 auto aKit = std::dynamic_pointer_cast<InstrumentDrumkit>(a);
2626 auto bKit = std::dynamic_pointer_cast<InstrumentDrumkit>(b);
2627
2628 std::vector<int> aKeys = aKit->getAssignedKeys();
2629 std::vector<int> bKeys = bKit->getAssignedKeys();
2630 if (aKeys.size() != bKeys.size()) return false;
2631 std::sort(aKeys.begin(), aKeys.end());
2632 std::sort(bKeys.begin(), bKeys.end());
2633 if (!std::includes(aKeys.cbegin(), aKeys.cend(), bKeys.cbegin(), bKeys.cend())) return false;
2634
2635 for (const int& key : aKeys) {
2636 if (*sampADPCM_[aKit->getSampleNumber(key)] != *sampADPCM_[bKit->getSampleNumber(key)])
2637 return false;
2638 if (aKit->getPitch(key) != bKit->getPitch(key))
2639 return false;
2640 if (aKit->getPan(key) != bKit->getPan(key))
2641 return false;
2642 }
2643
2644 return true;
2645 }