Debian Codegraph @

BambooTracker/io/bti_io.cpp

raw
1 /*
2 * Copyright (C) 2020-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 "bti_io.hpp"
27 #include <unordered_map>
28 #include <vector>
29 #include <algorithm>
30 #include <utility>
31 #include "enum_hash.hpp"
32 #include "version.hpp"
33 #include "file_io_error.hpp"
34 #include "note.hpp"
35 #include "io_utils.hpp"
36 #include "utils.hpp"
37
38 namespace io
39 {
40 namespace
41 {
42 size_t loadInstrumentPropertyOperatorSequenceForInstrument(
43 FMEnvelopeParameter param, size_t instMemCsr,
44 std::shared_ptr<InstrumentsManager>& instManLocked,
45 const BinaryContainer& ctr, InstrumentFM* inst, int idx, uint32_t version)
46 {
47 inst->setOperatorSequenceEnabled(param, true);
48 inst->setOperatorSequenceNumber(param, idx);
49 uint16_t ofs = ctr.readUint16(instMemCsr);
50 size_t csr = instMemCsr + 2;
51
52 uint16_t seqLen = ctr.readUint16(csr);
53 csr += 2;
54 for (uint16_t l = 0; l < seqLen; ++l) {
55 uint16_t data = ctr.readUint16(csr);
56 csr += 2;
57 if (version < Version::toBCD(1, 2, 1)) csr += 2;
58 if (l == 0)
59 instManLocked->setOperatorSequenceFMSequenceData(param, idx, 0, data);
60 else
61 instManLocked->addOperatorSequenceFMSequenceData(param, idx, data);
62 }
63
64 uint16_t loopCnt = ctr.readUint16(csr);
65 csr += 2;
66 for (uint16_t l = 0; l < loopCnt; ++l) {
67 int begin = ctr.readUint16(csr);
68 csr += 2;
69 int end = ctr.readUint16(csr);
70 csr += 2;
71 int times = ctr.readUint8(csr++);
72 instManLocked->addOperatorSequenceFMLoop(param, idx, InstrumentSequenceLoop(begin, end, times));
73 }
74
75 switch (ctr.readUint8(csr++)) {
76 case 0x00: // No release
77 instManLocked->setOperatorSequenceFMRelease(param, idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
78 break;
79 case 0x01: // Fixed
80 {
81 uint16_t pos = ctr.readUint16(csr);
82 csr += 2;
83 // Release point check (prevents a bug)
84 // https://github.com/BambooTracker/BambooTracker/issues/11
85 if (pos < seqLen) instManLocked->setOperatorSequenceFMRelease(param, idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
86 else instManLocked->setOperatorSequenceFMRelease(param, idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
87 break;
88 }
89 default:
90 throw FileCorruptionError(FileType::Inst, csr);
91 }
92
93 if (version >= Version::toBCD(1, 0, 1)) {
94 ++csr; // Skip sequence type
95 }
96
97 return ofs;
98 }
99 }
100
101 BtiIO::BtiIO() : AbstractInstrumentIO("bti", "BambooTracker instrument", true, true) {}
102
103 AbstractInstrument* BtiIO::load(const BinaryContainer& ctr, const std::string& fileName,
104 std::weak_ptr<InstrumentsManager> instMan, int instNum) const
105 {
106 (void)fileName;
107
108 std::shared_ptr<InstrumentsManager> instManLocked = instMan.lock();
109 size_t globCsr = 0;
110 if (ctr.readString(globCsr, 16) != "BambooTrackerIst")
111 throw FileCorruptionError(FileType::Inst, globCsr);
112 globCsr += 16;
113 /*size_t eofOfs = */ctr.readUint32(globCsr);
114 globCsr += 4;
115 size_t fileVersion = ctr.readUint32(globCsr);
116 if (fileVersion > Version::ofInstrumentFileInBCD())
117 throw FileVersionError(FileType::Inst);
118 globCsr += 4;
119
120
121 /***** Instrument section *****/
122 if (ctr.readString(globCsr, 8) != "INSTRMNT")
123 throw FileCorruptionError(FileType::Inst, globCsr);
124 else {
125 globCsr += 8;
126 size_t instOfs = ctr.readUint32(globCsr);
127 size_t instCsr = globCsr + 4;
128 size_t nameLen = ctr.readUint32(instCsr);
129 instCsr += 4;
130 std::string name = u8"";
131 if (nameLen > 0) {
132 name = ctr.readString(instCsr, nameLen);
133 instCsr += nameLen;
134 }
135 std::unordered_map<FMOperatorType, int> fmArpMap, fmPtMap;
136 std::unordered_map<int, std::vector<int>> kitSampFileMap, kitSampMap;
137 AbstractInstrument* inst = nullptr;
138 switch (ctr.readUint8(instCsr++)) {
139 case 0x00: // FM
140 {
141 inst = new InstrumentFM(instNum, name, instManLocked.get());
142 auto fm = dynamic_cast<InstrumentFM*>(inst);
143 uint8_t tmp = ctr.readUint8(instCsr++);
144 fm->setEnvelopeResetEnabled(FMOperatorType::All, (tmp & 0x01));
145 fm->setEnvelopeResetEnabled(FMOperatorType::Op1, (tmp & 0x02));
146 fm->setEnvelopeResetEnabled(FMOperatorType::Op2, (tmp & 0x04));
147 fm->setEnvelopeResetEnabled(FMOperatorType::Op3, (tmp & 0x08));
148 fm->setEnvelopeResetEnabled(FMOperatorType::Op4, (tmp & 0x10));
149 if (fileVersion >= Version::toBCD(1, 1, 0)) {
150 fmArpMap.emplace(FMOperatorType::All, ctr.readUint8(instCsr++));
151 for (auto& t : FM_OP_TYPES) {
152 tmp = ctr.readUint8(instCsr++);
153 if (!(tmp & 0x80)) fmArpMap.emplace(t, (tmp & 0x7f));
154 }
155 fmPtMap.emplace(FMOperatorType::All, ctr.readUint8(instCsr++));
156 for (auto& t : FM_OP_TYPES) {
157 tmp = ctr.readUint8(instCsr++);
158 if (!(tmp & 0x80)) fmPtMap.emplace(t, (tmp & 0x7f));
159 }
160 }
161 break;
162 }
163 case 0x01: // SSG
164 {
165 inst = new InstrumentSSG(instNum, name, instManLocked.get());
166 break;
167 }
168 case 0x02: // ADPCM
169 {
170 inst = new InstrumentADPCM(instNum, name, instManLocked.get());
171 break;
172 }
173 case 0x03: // Drumkit
174 {
175 inst = new InstrumentDrumkit(instNum, name, instManLocked.get());
176 auto kit = dynamic_cast<InstrumentDrumkit*>(inst);
177 uint8_t cnt = ctr.readUint8(instCsr++);
178 for (uint8_t i = 0; i < cnt; ++i) {
179 int key = ctr.readUint8(instCsr++);
180 int samp = ctr.readUint8(instCsr++);
181 if (kitSampFileMap.count(samp)) kitSampFileMap[samp].push_back(key);
182 else kitSampFileMap[samp] = { key };
183 kit->setSampleEnabled(key, true);
184 kit->setPitch(key, ctr.readInt8(instCsr++));
185 if (fileVersion >= Version::toBCD(1, 5, 0)) {
186 kit->setPan(key, ctr.readUint8(instCsr++));
187 }
188 }
189 break;
190 }
191 default:
192 throw FileCorruptionError(FileType::Inst, instCsr);
193 }
194 globCsr += instOfs;
195
196
197 /***** Instrument property section *****/
198 if (ctr.readString(globCsr, 8) != "INSTPROP")
199 throw FileCorruptionError(FileType::Inst, globCsr);
200 else {
201 globCsr += 8;
202 size_t instPropOfs = ctr.readUint32(globCsr);
203 size_t instPropCsr = globCsr + 4;
204 size_t instPropCsrTmp = instPropCsr;
205 globCsr += instPropOfs;
206 int kitSampCnt = 0;
207 int adpcmSampIdx = 0;
208 std::vector<int> nums;
209 // Check memory range
210 while (instPropCsr < globCsr) {
211 switch (ctr.readUint8(instPropCsr++)) {
212 case 0x00: // FM envelope
213 {
214 nums.push_back(instManLocked->findFirstAssignableEnvelopeFM());
215 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
216 instPropCsr += ctr.readUint8(instPropCsr);
217 break;
218 }
219 case 0x01: // FM LFO
220 {
221 nums.push_back(instManLocked->findFirstAssignableLFOFM());
222 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
223 instPropCsr += ctr.readUint8(instPropCsr);
224 break;
225 }
226 case 0x02: // FM AL
227 {
228 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::AL));
229 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
230 instPropCsr += ctr.readUint16(instPropCsr);
231 break;
232 }
233 case 0x03: // FM FB
234 {
235 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::FB));
236 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
237 instPropCsr += ctr.readUint16(instPropCsr);
238 break;
239 }
240 case 0x04: // FM AR1
241 {
242 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::AR1));
243 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
244 instPropCsr += ctr.readUint16(instPropCsr);
245 break;
246 }
247 case 0x05: // FM DR1
248 {
249 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::DR1));
250 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
251 instPropCsr += ctr.readUint16(instPropCsr);
252 break;
253 }
254 case 0x06: // FM SR1
255 {
256 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::SR1));
257 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
258 instPropCsr += ctr.readUint16(instPropCsr);
259 break;
260 }
261 case 0x07: // FM RR1
262 {
263 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::RR1));
264 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
265 instPropCsr += ctr.readUint16(instPropCsr);
266 break;
267 }
268 case 0x08: // FM SL1
269 {
270 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::SL1));
271 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
272 instPropCsr += ctr.readUint16(instPropCsr);
273 break;
274 }
275 case 0x09: // FM TL1
276 {
277 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::TL1));
278 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
279 instPropCsr += ctr.readUint16(instPropCsr);
280 break;
281 }
282 case 0x0a: // FM KS1
283 {
284 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::KS1));
285 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
286 instPropCsr += ctr.readUint16(instPropCsr);
287 break;
288 }
289 case 0x0b: // FM ML1
290 {
291 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::ML1));
292 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
293 instPropCsr += ctr.readUint16(instPropCsr);
294 break;
295 }
296 case 0x0c: // FM DT1
297 {
298 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::DT1));
299 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
300 instPropCsr += ctr.readUint16(instPropCsr);
301 break;
302 }
303 case 0x0d: // FM AR2
304 {
305 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::AR2));
306 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
307 instPropCsr += ctr.readUint16(instPropCsr);
308 break;
309 }
310 case 0x0e: // FM DR2
311 {
312 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::DR2));
313 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
314 instPropCsr += ctr.readUint16(instPropCsr);
315 break;
316 }
317 case 0x0f: // FM SR2
318 {
319 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::SR2));
320 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
321 instPropCsr += ctr.readUint16(instPropCsr);
322 break;
323 }
324 case 0x10: // FM RR2
325 {
326 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::RR2));
327 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
328 instPropCsr += ctr.readUint16(instPropCsr);
329 break;
330 }
331 case 0x11: // FM SL2
332 {
333 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::SL2));
334 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
335 instPropCsr += ctr.readUint16(instPropCsr);
336 break;
337 }
338 case 0x12: // FM TL2
339 {
340 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::TL2));
341 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
342 instPropCsr += ctr.readUint16(instPropCsr);
343 break;
344 }
345 case 0x13: // FM KS2
346 {
347 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::KS2));
348 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
349 instPropCsr += ctr.readUint16(instPropCsr);
350 break;
351 }
352 case 0x14: // FM ML2
353 {
354 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::ML2));
355 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
356 instPropCsr += ctr.readUint16(instPropCsr);
357 break;
358 }
359 case 0x15: // FM DT2
360 {
361 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::DT2));
362 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
363 instPropCsr += ctr.readUint16(instPropCsr);
364 break;
365 }
366 case 0x16: // FM AR3
367 {
368 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::AR3));
369 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
370 instPropCsr += ctr.readUint16(instPropCsr);
371 break;
372 }
373 case 0x17: // FM DR3
374 {
375 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::DR3));
376 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
377 instPropCsr += ctr.readUint16(instPropCsr);
378 break;
379 }
380 case 0x18: // FM SR3
381 {
382 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::SR3));
383 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
384 instPropCsr += ctr.readUint16(instPropCsr);
385 break;
386 }
387 case 0x19: // FM RR3
388 {
389 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::RR3));
390 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
391 instPropCsr += ctr.readUint16(instPropCsr);
392 break;
393 }
394 case 0x1a: // FM SL3
395 {
396 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::SL3));
397 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
398 instPropCsr += ctr.readUint16(instPropCsr);
399 break;
400 }
401 case 0x1b: // FM TL3
402 {
403 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::TL3));
404 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
405 instPropCsr += ctr.readUint16(instPropCsr);
406 break;
407 }
408 case 0x1c: // FM KS3
409 {
410 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::KS3));
411 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
412 instPropCsr += ctr.readUint16(instPropCsr);
413 break;
414 }
415 case 0x1d: // FM ML3
416 {
417 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::ML3));
418 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
419 instPropCsr += ctr.readUint16(instPropCsr);
420 break;
421 }
422 case 0x1e: // FM DT3
423 {
424 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::DT3));
425 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
426 instPropCsr += ctr.readUint16(instPropCsr);
427 break;
428 }
429 case 0x1f: // FM AR4
430 {
431 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::AR4));
432 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
433 instPropCsr += ctr.readUint16(instPropCsr);
434 break;
435 }
436 case 0x20: // FM DR4
437 {
438 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::DR4));
439 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
440 instPropCsr += ctr.readUint16(instPropCsr);
441 break;
442 }
443 case 0x21: // FM SR4
444 {
445 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::SR4));
446 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
447 instPropCsr += ctr.readUint16(instPropCsr);
448 break;
449 }
450 case 0x22: // FM RR4
451 {
452 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::RR4));
453 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
454 instPropCsr += ctr.readUint16(instPropCsr);
455 break;
456 }
457 case 0x23: // FM SL4
458 {
459 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::SL4));
460 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
461 instPropCsr += ctr.readUint16(instPropCsr);
462 break;
463 }
464 case 0x24: // FM TL4
465 {
466 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::TL4));
467 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
468 instPropCsr += ctr.readUint16(instPropCsr);
469 break;
470 }
471 case 0x25: // FM KS4
472 {
473 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::KS4));
474 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
475 instPropCsr += ctr.readUint16(instPropCsr);
476 break;
477 }
478 case 0x26: // FM ML4
479 {
480 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::ML4));
481 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
482 instPropCsr += ctr.readUint16(instPropCsr);
483 break;
484 }
485 case 0x27: // FM DT4
486 {
487 nums.push_back(instManLocked->findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter::DT4));
488 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
489 instPropCsr += ctr.readUint16(instPropCsr);
490 break;
491 }
492 case 0x28: // FM arpeggio
493 {
494 nums.push_back(instManLocked->findFirstAssignableArpeggioFM());
495 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
496 instPropCsr += ctr.readUint16(instPropCsr);
497 break;
498 }
499 case 0x29: // FM pitch
500 {
501 nums.push_back(instManLocked->findFirstAssignablePitchFM());
502 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
503 instPropCsr += ctr.readUint16(instPropCsr);
504 break;
505 }
506 case 0x2a: // FM pan
507 {
508 nums.push_back(instManLocked->findFirstAssignablePanFM());
509 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
510 instPropCsr += ctr.readUint16(instPropCsr);
511 break;
512 }
513 case 0x30: // SSG waveform
514 {
515 nums.push_back(instManLocked->findFirstAssignableWaveformSSG());
516 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
517 instPropCsr += ctr.readUint16(instPropCsr);
518 break;
519 }
520 case 0x31: // SSG tone/noise
521 {
522 nums.push_back(instManLocked->findFirstAssignableToneNoiseSSG());
523 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
524 instPropCsr += ctr.readUint16(instPropCsr);
525 break;
526 }
527 case 0x32: // SSG envelope
528 {
529 nums.push_back(instManLocked->findFirstAssignableEnvelopeSSG());
530 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
531 instPropCsr += ctr.readUint16(instPropCsr);
532 break;
533 }
534 case 0x33: // SSG arpeggio
535 {
536 nums.push_back(instManLocked->findFirstAssignableArpeggioSSG());
537 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
538 instPropCsr += ctr.readUint16(instPropCsr);
539 break;
540 }
541 case 0x34: // SSG pitch
542 {
543 nums.push_back(instManLocked->findFirstAssignablePitchSSG());
544 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
545 instPropCsr += ctr.readUint16(instPropCsr);
546 break;
547 }
548 case 0x40: // ADPCM sample
549 {
550 adpcmSampIdx = instManLocked->findFirstAssignableSampleADPCM(adpcmSampIdx);
551 if (adpcmSampIdx == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
552 nums.push_back(adpcmSampIdx);
553 if (inst->getType() == InstrumentType::Drumkit) {
554 kitSampMap[adpcmSampIdx] = kitSampFileMap.at(kitSampCnt++);
555 }
556 instPropCsr += ctr.readUint32(instPropCsr);
557 ++adpcmSampIdx; // Increment for search appropriate kit sample
558 break;
559 }
560 case 0x41: // ADPCM envelope
561 {
562 nums.push_back(instManLocked->findFirstAssignableEnvelopeADPCM());
563 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
564 instPropCsr += ctr.readUint16(instPropCsr);
565 break;
566 }
567 case 0x42: // ADPCM arpeggio
568 {
569 nums.push_back(instManLocked->findFirstAssignableArpeggioADPCM());
570 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
571 instPropCsr += ctr.readUint16(instPropCsr);
572 break;
573 }
574 case 0x43: // ADPCM pitch
575 {
576 nums.push_back(instManLocked->findFirstAssignablePitchADPCM());
577 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
578 instPropCsr += ctr.readUint16(instPropCsr);
579 break;
580 }
581 case 0x44: // ADPCM pan
582 {
583 nums.push_back(instManLocked->findFirstAssignablePanADPCM());
584 if (nums.back() == -1) throw FileCorruptionError(FileType::Inst, instPropCsr);
585 instPropCsr += ctr.readUint16(instPropCsr);
586 break;
587 }
588 default:
589 throw FileCorruptionError(FileType::Inst, instPropCsr);
590 }
591 }
592 // Read data
593 instPropCsr = instPropCsrTmp;
594 auto numIt = nums.begin();
595 while (instPropCsr < globCsr) {
596 switch (ctr.readUint8(instPropCsr++)) {
597 case 0x00: // FM envelope
598 {
599 int idx = *numIt++;
600 dynamic_cast<InstrumentFM*>(inst)->setEnvelopeNumber(idx);
601 uint8_t ofs = ctr.readUint8(instPropCsr);
602 size_t csr = instPropCsr + 1;
603 uint8_t tmp = ctr.readUint8(csr++);
604 instManLocked->setEnvelopeFMParameter(idx, FMEnvelopeParameter::AL, tmp >> 4);
605 instManLocked->setEnvelopeFMParameter(idx, FMEnvelopeParameter::FB, tmp & 0x0f);
606 for (int op = 0; op < 4; ++op) {
607 auto& params = FM_OP_PARAMS[op];
608 tmp = ctr.readUint8(csr++);
609 instManLocked->setEnvelopeFMOperatorEnabled(idx, op, (0x20 & tmp) ? true : false);
610 instManLocked->setEnvelopeFMParameter(idx, params.at(FMOperatorParameter::AR), tmp & 0x1f);
611 tmp = ctr.readUint8(csr++);
612 instManLocked->setEnvelopeFMParameter(idx, params.at(FMOperatorParameter::KS), tmp >> 5);
613 instManLocked->setEnvelopeFMParameter(idx, params.at(FMOperatorParameter::DR), tmp & 0x1f);
614 tmp = ctr.readUint8(csr++);
615 instManLocked->setEnvelopeFMParameter(idx, params.at(FMOperatorParameter::DT), tmp >> 5);
616 instManLocked->setEnvelopeFMParameter(idx, params.at(FMOperatorParameter::SR), tmp & 0x1f);
617 tmp = ctr.readUint8(csr++);
618 instManLocked->setEnvelopeFMParameter(idx, params.at(FMOperatorParameter::SL), tmp >> 4);
619 instManLocked->setEnvelopeFMParameter(idx, params.at(FMOperatorParameter::RR), tmp & 0x0f);
620 tmp = ctr.readUint8(csr++);
621 instManLocked->setEnvelopeFMParameter(idx, params.at(FMOperatorParameter::TL), tmp);
622 tmp = ctr.readUint8(csr++);
623 instManLocked->setEnvelopeFMParameter(idx, params.at(FMOperatorParameter::ML), tmp & 0x0f);
624 instManLocked->setEnvelopeFMParameter(idx, params.at(FMOperatorParameter::SSGEG),
625 (tmp & 0x80) ? -1 : ((tmp >> 4) & 0x07));
626 }
627 instPropCsr += ofs;
628 break;
629 }
630 case 0x01: // FM LFO
631 {
632 int idx = *numIt++;
633 auto fm = dynamic_cast<InstrumentFM*>(inst);
634 fm->setLFOEnabled(true);
635 fm->setLFONumber(idx);
636 uint8_t ofs = ctr.readUint8(instPropCsr);
637 size_t csr = instPropCsr + 1;
638 uint8_t tmp = ctr.readUint8(csr++);
639 instManLocked->setLFOFMParameter(idx, FMLFOParameter::FREQ, tmp >> 4);
640 instManLocked->setLFOFMParameter(idx, FMLFOParameter::PMS, tmp & 0x0f);
641 tmp = ctr.readUint8(csr++);
642 instManLocked->setLFOFMParameter(idx, FMLFOParameter::AMS, tmp & 0x0f);
643 instManLocked->setLFOFMParameter(idx, FMLFOParameter::AM1, (tmp & 0x10) ? true : false);
644 instManLocked->setLFOFMParameter(idx, FMLFOParameter::AM2, (tmp & 0x20) ? true : false);
645 instManLocked->setLFOFMParameter(idx, FMLFOParameter::AM3, (tmp & 0x40) ? true : false);
646 instManLocked->setLFOFMParameter(idx, FMLFOParameter::AM4, (tmp & 0x80) ? true : false);
647 tmp = ctr.readUint8(csr++);
648 instManLocked->setLFOFMParameter(idx, FMLFOParameter::Count, tmp);
649 instPropCsr += ofs;
650 break;
651 }
652 case 0x02: // FM AL
653 {
654 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
655 FMEnvelopeParameter::AL, instPropCsr, instManLocked, ctr,
656 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
657 break;
658 }
659 case 0x03: // FM FB
660 {
661 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
662 FMEnvelopeParameter::FB, instPropCsr, instManLocked, ctr,
663 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
664 break;
665 }
666 case 0x04: // FM AR1
667 {
668 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
669 FMEnvelopeParameter::AR1, instPropCsr, instManLocked, ctr,
670 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
671 break;
672 }
673 case 0x05: // FM DR1
674 {
675 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
676 FMEnvelopeParameter::DR1, instPropCsr, instManLocked, ctr,
677 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
678 break;
679 }
680 case 0x06: // FM SR1
681 {
682 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
683 FMEnvelopeParameter::SR1, instPropCsr, instManLocked, ctr,
684 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
685 break;
686 }
687 case 0x07: // FM RR1
688 {
689 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
690 FMEnvelopeParameter::RR1, instPropCsr, instManLocked, ctr,
691 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
692 break;
693 }
694 case 0x08: // FM SL1
695 {
696 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
697 FMEnvelopeParameter::SL1, instPropCsr, instManLocked, ctr,
698 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
699 break;
700 }
701 case 0x09: // FM TL1
702 {
703 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
704 FMEnvelopeParameter::TL1, instPropCsr, instManLocked, ctr,
705 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
706 break;
707 }
708 case 0x0a: // FM KS1
709 {
710 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
711 FMEnvelopeParameter::KS1, instPropCsr, instManLocked, ctr,
712 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
713 break;
714 }
715 case 0x0b: // FM ML1
716 {
717 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
718 FMEnvelopeParameter::ML1, instPropCsr, instManLocked, ctr,
719 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
720 break;
721 }
722 case 0x0c: // FM DT1
723 {
724 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
725 FMEnvelopeParameter::DT1, instPropCsr, instManLocked, ctr,
726 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
727 break;
728 }
729 case 0x0d: // FM AR2
730 {
731 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
732 FMEnvelopeParameter::AR2, instPropCsr, instManLocked, ctr,
733 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
734 break;
735 }
736 case 0x0e: // FM DR2
737 {
738 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
739 FMEnvelopeParameter::DR2, instPropCsr, instManLocked, ctr,
740 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
741 break;
742 }
743 case 0x0f: // FM SR2
744 {
745 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
746 FMEnvelopeParameter::SR2, instPropCsr, instManLocked, ctr,
747 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
748 break;
749 }
750 case 0x10: // FM RR2
751 {
752 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
753 FMEnvelopeParameter::RR2, instPropCsr, instManLocked, ctr,
754 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
755 break;
756 }
757 case 0x11: // FM SL2
758 {
759 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
760 FMEnvelopeParameter::SL2, instPropCsr, instManLocked, ctr,
761 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
762 break;
763 }
764 case 0x12: // FM TL2
765 {
766 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
767 FMEnvelopeParameter::TL2, instPropCsr, instManLocked, ctr,
768 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
769 break;
770 }
771 case 0x13: // FM KS2
772 {
773 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
774 FMEnvelopeParameter::KS2, instPropCsr, instManLocked, ctr,
775 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
776 break;
777 }
778 case 0x14: // FM ML2
779 {
780 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
781 FMEnvelopeParameter::ML2, instPropCsr, instManLocked, ctr,
782 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
783 break;
784 }
785 case 0x15: // FM DT2
786 {
787 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
788 FMEnvelopeParameter::DT2, instPropCsr, instManLocked, ctr,
789 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
790 break;
791 }
792 case 0x16: // FM AR3
793 {
794 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
795 FMEnvelopeParameter::AR3, instPropCsr, instManLocked, ctr,
796 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
797 break;
798 }
799 case 0x17: // FM DR3
800 {
801 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
802 FMEnvelopeParameter::DR3, instPropCsr, instManLocked, ctr,
803 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
804 break;
805 }
806 case 0x18: // FM SR3
807 {
808 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
809 FMEnvelopeParameter::SR3, instPropCsr, instManLocked, ctr,
810 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
811 break;
812 }
813 case 0x19: // FM RR3
814 {
815 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
816 FMEnvelopeParameter::RR3, instPropCsr, instManLocked, ctr,
817 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
818 break;
819 }
820 case 0x1a: // FM SL3
821 {
822 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
823 FMEnvelopeParameter::SL3, instPropCsr, instManLocked, ctr,
824 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
825 break;
826 }
827 case 0x1b: // FM TL3
828 {
829 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
830 FMEnvelopeParameter::TL3, instPropCsr, instManLocked, ctr,
831 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
832 break;
833 }
834 case 0x1c: // FM KS3
835 {
836 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
837 FMEnvelopeParameter::KS3, instPropCsr, instManLocked, ctr,
838 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
839 break;
840 }
841 case 0x1d: // FM ML3
842 {
843 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
844 FMEnvelopeParameter::ML3, instPropCsr, instManLocked, ctr,
845 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
846 break;
847 }
848 case 0x1e: // FM DT3
849 {
850 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
851 FMEnvelopeParameter::DT3, instPropCsr, instManLocked, ctr,
852 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
853 break;
854 }
855 case 0x1f: // FM AR4
856 {
857 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
858 FMEnvelopeParameter::AR4, instPropCsr, instManLocked, ctr,
859 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
860 break;
861 }
862 case 0x20: // FM DR4
863 {
864 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
865 FMEnvelopeParameter::DR4, instPropCsr, instManLocked, ctr,
866 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
867 break;
868 }
869 case 0x21: // FM SR4
870 {
871 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
872 FMEnvelopeParameter::SR4, instPropCsr, instManLocked, ctr,
873 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
874 break;
875 }
876 case 0x22: // FM RR4
877 {
878 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
879 FMEnvelopeParameter::RR4, instPropCsr, instManLocked, ctr,
880 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
881 break;
882 }
883 case 0x23: // FM SL4
884 {
885 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
886 FMEnvelopeParameter::SL4, instPropCsr, instManLocked, ctr,
887 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
888 break;
889 }
890 case 0x24: // FM TL4
891 {
892 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
893 FMEnvelopeParameter::TL4, instPropCsr, instManLocked, ctr,
894 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
895 break;
896 }
897 case 0x25: // FM KS4
898 {
899 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
900 FMEnvelopeParameter::KS4, instPropCsr, instManLocked, ctr,
901 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
902 break;
903 }
904 case 0x26: // FM ML4
905 {
906 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
907 FMEnvelopeParameter::ML4, instPropCsr, instManLocked, ctr,
908 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
909 break;
910 }
911 case 0x27: // FM DT4
912 {
913 instPropCsr += loadInstrumentPropertyOperatorSequenceForInstrument(
914 FMEnvelopeParameter::DT4, instPropCsr, instManLocked, ctr,
915 dynamic_cast<InstrumentFM*>(inst), *numIt++, fileVersion);
916 break;
917 }
918 case 0x28: // FM arpeggio
919 {
920 int idx = *numIt++;
921 auto fm = dynamic_cast<InstrumentFM*>(inst);
922 if (fileVersion >= Version::toBCD(1, 1, 0)) {
923 std::vector<FMOperatorType> del;
924 for (auto& pair : fmArpMap) {
925 if (pair.second-- == 0) {
926 fm->setArpeggioEnabled(pair.first, true);
927 fm->setArpeggioNumber(pair.first, idx);
928 del.push_back(pair.first);
929 }
930 }
931 for (auto t : del) fmArpMap.erase(t);
932 }
933 else {
934 fm->setArpeggioEnabled(FMOperatorType::All, true);
935 fm->setArpeggioNumber(FMOperatorType::All, idx);
936 }
937 uint16_t ofs = ctr.readUint16(instPropCsr);
938 size_t csr = instPropCsr + 2;
939
940 uint16_t seqLen = ctr.readUint16(csr);
941 csr += 2;
942 for (uint16_t l = 0; l < seqLen; ++l) {
943 uint16_t data = ctr.readUint16(csr);
944 csr += 2;
945 if (fileVersion < Version::toBCD(1, 2, 0)) csr += 2;
946 if (l == 0)
947 instManLocked->setArpeggioFMSequenceData(idx, 0, data);
948 else
949 instManLocked->addArpeggioFMSequenceData(idx, data);
950 }
951
952 uint16_t loopCnt = ctr.readUint16(csr);
953 csr += 2;
954 for (uint16_t l = 0; l < loopCnt; ++l) {
955 int begin = ctr.readUint16(csr);
956 csr += 2;
957 int end = ctr.readUint16(csr);
958 csr += 2;
959 int times = ctr.readUint8(csr++);
960 instManLocked->addArpeggioFMLoop(idx, InstrumentSequenceLoop(begin, end, times));
961 }
962
963 switch (ctr.readUint8(csr++)) {
964 case 0x00: // No release
965 instManLocked->setArpeggioFMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
966 break;
967 case 0x01: // Fixed
968 {
969 uint16_t pos = ctr.readUint16(csr);
970 csr += 2;
971 // Release point check (prevents a bug)
972 // https://github.com/BambooTracker/BambooTracker/issues/11
973 if (pos < seqLen) instManLocked->setArpeggioFMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
974 else instManLocked->setArpeggioFMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
975 break;
976 }
977 default:
978 throw FileCorruptionError(FileType::Inst, csr);
979 }
980
981 if (fileVersion >= Version::toBCD(1, 0, 1)) {
982 switch (ctr.readUint8(csr++)) {
983 case 0x00: // Absolute
984 instManLocked->setArpeggioFMType(idx, SequenceType::AbsoluteSequence);
985 break;
986 case 0x01: // Fixed
987 instManLocked->setArpeggioFMType(idx, SequenceType::FixedSequence);
988 if (fileVersion < Version::toBCD(1, 5, 1)) {
989 // Add infinity loop to the last data, to keep compatibility
990 auto loopRt = instManLocked->getArpeggioFMLoopRoot(idx).getAllLoops();
991 if (std::none_of(loopRt.begin(), loopRt.end(), [](InstrumentSequenceLoop& loop) { return loop.isInfinite(); })) {
992 auto seq = instManLocked->getArpeggioFMSequence(idx);
993 if (!seq.empty()) {
994 size_t pos = seq.size();
995 instManLocked->addArpeggioFMSequenceData(idx, seq.back().data);
996 instManLocked->addArpeggioFMLoop(idx, InstrumentSequenceLoop(pos, pos, InstrumentSequenceLoop::INFINITE_LOOP));
997 }
998 }
999 }
1000 break;
1001 case 0x02: // Relative
1002 instManLocked->setArpeggioFMType(idx, SequenceType::RelativeSequence);
1003 break;
1004 default:
1005 if (fileVersion < Version::toBCD(1, 2, 3)) {
1006 // Recover deep clone bug
1007 // https://github.com/BambooTracker/BambooTracker/issues/170
1008 instManLocked->setArpeggioFMType(idx, SequenceType::AbsoluteSequence);
1009 break;
1010 }
1011 else {
1012 throw FileCorruptionError(FileType::Inst, csr);
1013 }
1014 }
1015 }
1016
1017 instPropCsr += ofs;
1018 break;
1019 }
1020 case 0x29: // FM pitch
1021 {
1022 int idx = *numIt++;
1023 auto fm = dynamic_cast<InstrumentFM*>(inst);
1024 if (fileVersion >= Version::toBCD(1, 1, 0)) {
1025 std::vector<FMOperatorType> del;
1026 for (auto& pair : fmPtMap) {
1027 if (pair.second-- == 0) {
1028 fm->setPitchEnabled(pair.first, true);
1029 fm->setPitchNumber(pair.first, idx);
1030 del.push_back(pair.first);
1031 }
1032 }
1033 for (auto t : del) fmPtMap.erase(t);
1034 }
1035 else {
1036 fm->setPitchEnabled(FMOperatorType::All, true);
1037 fm->setPitchNumber(FMOperatorType::All, idx);
1038 }
1039 uint16_t ofs = ctr.readUint16(instPropCsr);
1040 size_t csr = instPropCsr + 2;
1041
1042 uint16_t seqLen = ctr.readUint16(csr);
1043 csr += 2;
1044 for (uint16_t l = 0; l < seqLen; ++l) {
1045 uint16_t data = ctr.readUint16(csr);
1046 csr += 2;
1047 if (fileVersion < Version::toBCD(1, 2, 0)) csr += 2;
1048 if (l == 0)
1049 instManLocked->setPitchFMSequenceData(idx, 0, data);
1050 else
1051 instManLocked->addPitchFMSequenceData(idx, data);
1052 }
1053
1054 uint16_t loopCnt = ctr.readUint16(csr);
1055 csr += 2;
1056 for (uint16_t l = 0; l < loopCnt; ++l) {
1057 int begin = ctr.readUint16(csr);
1058 csr += 2;
1059 int end = ctr.readUint16(csr);
1060 csr += 2;
1061 int times = ctr.readUint8(csr++);
1062 instManLocked->addPitchFMLoop(idx, InstrumentSequenceLoop(begin, end, times));
1063 }
1064
1065 switch (ctr.readUint8(csr++)) {
1066 case 0x00: // No release
1067 instManLocked->setPitchFMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1068 break;
1069 case 0x01: // Fixed
1070 {
1071 uint16_t pos = ctr.readUint16(csr);
1072 csr += 2;
1073 // Release point check (prevents a bug)
1074 // https://github.com/BambooTracker/BambooTracker/issues/11
1075 if (pos < seqLen) instManLocked->setPitchFMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
1076 else instManLocked->setPitchFMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1077 break;
1078 }
1079 default:
1080 throw FileCorruptionError(FileType::Inst, csr);
1081 }
1082
1083 if (fileVersion >= Version::toBCD(1, 0, 1)) {
1084 switch (ctr.readUint8(csr++)) {
1085 case 0x00: // Absolute
1086 instManLocked->setPitchFMType(idx, SequenceType::AbsoluteSequence);
1087 break;
1088 case 0x02: // Relative
1089 instManLocked->setPitchFMType(idx, SequenceType::RelativeSequence);
1090 break;
1091 default:
1092 if (fileVersion < Version::toBCD(1, 2, 3)) {
1093 // Recover deep clone bug
1094 // https://github.com/BambooTracker/BambooTracker/issues/170
1095 instManLocked->setPitchFMType(idx, SequenceType::AbsoluteSequence);
1096 break;
1097 }
1098 else {
1099 throw FileCorruptionError(FileType::Inst, csr);
1100 }
1101 }
1102 }
1103
1104 instPropCsr += ofs;
1105 break;
1106 }
1107 case 0x2a: // FM pan
1108 {
1109 int idx = *numIt++;
1110 auto fm = dynamic_cast<InstrumentFM*>(inst);
1111 fm->setPanEnabled(true);
1112 fm->setPanNumber(idx);
1113 uint16_t ofs = ctr.readUint16(instPropCsr);
1114 size_t csr = instPropCsr + 2;
1115
1116 uint16_t seqLen = ctr.readUint16(csr);
1117 csr += 2;
1118 for (uint16_t l = 0; l < seqLen; ++l) {
1119 uint16_t data = ctr.readUint16(csr);
1120 csr += 2;
1121 if (l == 0)
1122 instManLocked->setPanFMSequenceData(idx, 0, data);
1123 else
1124 instManLocked->addPanFMSequenceData(idx, data);
1125 }
1126
1127 uint16_t loopCnt = ctr.readUint16(csr);
1128 csr += 2;
1129 for (uint16_t l = 0; l < loopCnt; ++l) {
1130 int begin = ctr.readUint16(csr);
1131 csr += 2;
1132 int end = ctr.readUint16(csr);
1133 csr += 2;
1134 int times = ctr.readUint8(csr++);
1135 instManLocked->addPanFMLoop(idx, InstrumentSequenceLoop(begin, end, times));
1136 }
1137
1138 switch (ctr.readUint8(csr++)) {
1139 case 0x00: // No release
1140 instManLocked->setPanFMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1141 break;
1142 case 0x01: // Fixed
1143 {
1144 uint16_t pos = ctr.readUint16(csr);
1145 csr += 2;
1146 // Release point check (prevents a bug)
1147 // https://github.com/BambooTracker/BambooTracker/issues/11
1148 if (pos < seqLen) instManLocked->setPanFMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
1149 else instManLocked->setPanFMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1150 break;
1151 }
1152 default:
1153 throw FileCorruptionError(FileType::Inst, csr);
1154 }
1155
1156 instPropCsr += ofs;
1157 break;
1158 }
1159 case 0x30: // SSG waveform
1160 {
1161 int idx = *numIt++;
1162 auto ssg = dynamic_cast<InstrumentSSG*>(inst);
1163 ssg->setWaveformEnabled(true);
1164 ssg->setWaveformNumber(idx);
1165 uint16_t ofs = ctr.readUint16(instPropCsr);
1166 size_t csr = instPropCsr + 2;
1167
1168 uint16_t seqLen = ctr.readUint16(csr);
1169 csr += 2;
1170 for (uint16_t l = 0; l < seqLen; ++l) {
1171 uint16_t data = ctr.readUint16(csr);
1172 csr += 2;
1173 if (fileVersion < Version::toBCD(1, 2, 0)) {
1174 if (data == 3) data = SSGWaveformType::SQM_TRIANGLE;
1175 else if (data == 4) data = SSGWaveformType::SQM_SAW;
1176 }
1177 int32_t subdata;
1178 if (fileVersion >= Version::toBCD(1, 2, 0)) {
1179 subdata = ctr.readInt32(csr);
1180 csr += 4;
1181 }
1182 else {
1183 subdata = ctr.readUint16(csr);
1184 csr += 2;
1185 if (subdata != -1)
1186 subdata = note_utils::calculateSSGSquareTP(subdata, 0);
1187 }
1188 SSGWaveformUnit unit;
1189 switch (data) {
1190 case SSGWaveformType::SQM_TRIANGLE:
1191 case SSGWaveformType::SQM_SAW:
1192 case SSGWaveformType::SQM_INVSAW:
1193 unit = SSGWaveformUnit::makeUnitWithDecode(data, subdata);
1194 break;
1195 default:
1196 unit = SSGWaveformUnit::makeOnlyDataUnit(data);
1197 break;
1198 }
1199 if (l == 0)
1200 instManLocked->setWaveformSSGSequenceData(idx, 0, unit);
1201 else
1202 instManLocked->addWaveformSSGSequenceData(idx, unit);
1203 }
1204
1205 uint16_t loopCnt = ctr.readUint16(csr);
1206 csr += 2;
1207 for (uint16_t l = 0; l < loopCnt; ++l) {
1208 int begin = ctr.readUint16(csr);
1209 csr += 2;
1210 int end = ctr.readUint16(csr);
1211 csr += 2;
1212 int times = ctr.readUint8(csr++);
1213 instManLocked->addWaveformSSGLoop(idx, InstrumentSequenceLoop(begin, end, times));
1214 }
1215
1216 switch (ctr.readUint8(csr++)) {
1217 case 0x00: // No release
1218 instManLocked->setWaveformSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1219 break;
1220 case 0x01: // Fixed
1221 {
1222 uint16_t pos = ctr.readUint16(csr);
1223 csr += 2;
1224 // Release point check (prevents a bug)
1225 // https://github.com/BambooTracker/BambooTracker/issues/11
1226 if (pos < seqLen) instManLocked->setWaveformSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
1227 else instManLocked->setWaveformSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1228 break;
1229 }
1230 default:
1231 throw FileCorruptionError(FileType::Inst, csr);
1232 }
1233
1234 if (fileVersion >= Version::toBCD(1, 0, 1)) {
1235 ++csr; // Skip sequence type
1236 }
1237
1238 instPropCsr += ofs;
1239 break;
1240 }
1241 case 0x31: // SSG tone/noise
1242 {
1243 int idx = *numIt++;
1244 auto ssg = dynamic_cast<InstrumentSSG*>(inst);
1245 ssg->setToneNoiseEnabled(true);
1246 ssg->setToneNoiseNumber(idx);
1247 uint16_t ofs = ctr.readUint16(instPropCsr);
1248 size_t csr = instPropCsr + 2;
1249
1250 uint16_t seqLen = ctr.readUint16(csr);
1251 csr += 2;
1252 for (uint16_t l = 0; l < seqLen; ++l) {
1253 uint16_t data = ctr.readUint16(csr);
1254 csr += 2;
1255 if (fileVersion < Version::toBCD(1, 2, 2)) {
1256 if (data > 0) {
1257 uint16_t tmp = data - 1;
1258 data = tmp / 32 * 32 + (31 - tmp % 32) + 1;
1259 }
1260 }
1261 if (fileVersion < Version::toBCD(1, 2, 0)) csr += 2;
1262 if (l == 0)
1263 instManLocked->setToneNoiseSSGSequenceData(idx, 0, data);
1264 else
1265 instManLocked->addToneNoiseSSGSequenceData(idx, data);
1266 }
1267
1268 uint16_t loopCnt = ctr.readUint16(csr);
1269 csr += 2;
1270 for (uint16_t l = 0; l < loopCnt; ++l) {
1271 int begin = ctr.readUint16(csr);
1272 csr += 2;
1273 int end = ctr.readUint16(csr);
1274 csr += 2;
1275 int times = ctr.readUint8(csr++);
1276 instManLocked->addToneNoiseSSGLoop(idx, InstrumentSequenceLoop(begin, end, times));
1277 }
1278
1279 switch (ctr.readUint8(csr++)) {
1280 case 0x00: // No release
1281 instManLocked->setToneNoiseSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1282 break;
1283 case 0x01: // Fixed
1284 {
1285 uint16_t pos = ctr.readUint16(csr);
1286 csr += 2;
1287 // Release point check (prevents a bug)
1288 // https://github.com/BambooTracker/BambooTracker/issues/11
1289 if (pos < seqLen) instManLocked->setToneNoiseSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
1290 else instManLocked->setToneNoiseSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1291 break;
1292 }
1293 default:
1294 throw FileCorruptionError(FileType::Inst, csr);
1295 }
1296
1297 if (fileVersion >= Version::toBCD(1, 0, 1)) {
1298 ++csr; // Skip sequence type
1299 }
1300
1301 instPropCsr += ofs;
1302 break;
1303 }
1304 case 0x32: // SSG envelope
1305 {
1306 int idx = *numIt++;
1307 auto ssg = dynamic_cast<InstrumentSSG*>(inst);
1308 ssg->setEnvelopeEnabled(true);
1309 ssg->setEnvelopeNumber(idx);
1310 uint16_t ofs = ctr.readUint16(instPropCsr);
1311 size_t csr = instPropCsr + 2;
1312
1313 uint16_t seqLen = ctr.readUint16(csr);
1314 csr += 2;
1315 for (uint16_t l = 0; l < seqLen; ++l) {
1316 uint16_t data = ctr.readUint16(csr);
1317 csr += 2;
1318 int32_t subdata;
1319 if (fileVersion >= Version::toBCD(1, 2, 0)) {
1320 subdata = ctr.readInt32(csr);
1321 csr += 4;
1322 }
1323 else {
1324 subdata = ctr.readUint16(csr);
1325 csr += 2;
1326 }
1327 SSGEnvelopeUnit unit = (data < 16) ? SSGEnvelopeUnit::makeOnlyDataUnit(data)
1328 : SSGEnvelopeUnit::makeUnitWithDecode(data, subdata);
1329 if (l == 0)
1330 instManLocked->setEnvelopeSSGSequenceData(idx, 0, unit);
1331 else
1332 instManLocked->addEnvelopeSSGSequenceData(idx, unit);
1333 }
1334
1335 uint16_t loopCnt = ctr.readUint16(csr);
1336 csr += 2;
1337 for (uint16_t l = 0; l < loopCnt; ++l) {
1338 int begin = ctr.readUint16(csr);
1339 csr += 2;
1340 int end = ctr.readUint16(csr);
1341 csr += 2;
1342 int times = ctr.readUint8(csr++);
1343 instManLocked->addEnvelopeSSGLoop(idx, InstrumentSequenceLoop(begin, end, times));
1344 }
1345
1346 switch (ctr.readUint8(csr++)) {
1347 case 0x00: // No release
1348 instManLocked->setEnvelopeSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1349 break;
1350 // Release point check (prevents a bug)
1351 // https://github.com/BambooTracker/BambooTracker/issues/11
1352 case 0x01: // Fixed
1353 {
1354 uint16_t pos = ctr.readUint16(csr);
1355 csr += 2;
1356 if (pos < seqLen) instManLocked->setEnvelopeSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
1357 else instManLocked->setEnvelopeSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1358 break;
1359 }
1360 case 0x02: // Absolute
1361 {
1362 uint16_t pos = ctr.readUint16(csr);
1363 csr += 2;
1364 if (pos < seqLen) instManLocked->setEnvelopeSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::AbsoluteRelease, pos));
1365 else instManLocked->setEnvelopeSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1366 break;
1367 }
1368 case 0x03: // Relative
1369 {
1370 uint16_t pos = ctr.readUint16(csr);
1371 csr += 2;
1372 if (pos < seqLen) instManLocked->setEnvelopeSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::RelativeRelease, pos));
1373 else instManLocked->setEnvelopeSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1374 break;
1375 }
1376 default:
1377 throw FileCorruptionError(FileType::Inst, csr);
1378 }
1379
1380 if (fileVersion >= Version::toBCD(1, 0, 1)) {
1381 ++csr; // Skip sequence type
1382 }
1383
1384 instPropCsr += ofs;
1385 break;
1386 }
1387 case 0x33: // SSG arpeggio
1388 {
1389 int idx = *numIt++;
1390 auto ssg = dynamic_cast<InstrumentSSG*>(inst);
1391 ssg->setArpeggioEnabled(true);
1392 ssg->setArpeggioNumber(idx);
1393 uint16_t ofs = ctr.readUint16(instPropCsr);
1394 size_t csr = instPropCsr + 2;
1395
1396 uint16_t seqLen = ctr.readUint16(csr);
1397 csr += 2;
1398 for (uint16_t l = 0; l < seqLen; ++l) {
1399 uint16_t data = ctr.readUint16(csr);
1400 csr += 2;
1401 if (fileVersion < Version::toBCD(1, 2, 0)) csr += 2;
1402 if (l == 0)
1403 instManLocked->setArpeggioSSGSequenceData(idx, 0, data);
1404 else
1405 instManLocked->addArpeggioSSGSequenceData(idx, data);
1406 }
1407
1408 uint16_t loopCnt = ctr.readUint16(csr);
1409 csr += 2;
1410 for (uint16_t l = 0; l < loopCnt; ++l) {
1411 int begin = ctr.readUint16(csr);
1412 csr += 2;
1413 int end = ctr.readUint16(csr);
1414 csr += 2;
1415 int times = ctr.readUint8(csr++);
1416 instManLocked->addArpeggioSSGLoop(idx, InstrumentSequenceLoop(begin, end, times));
1417 }
1418
1419 switch (ctr.readUint8(csr++)) {
1420 case 0x00: // No release
1421 instManLocked->setArpeggioSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1422 break;
1423 case 0x01: // Fixed
1424 {
1425 uint16_t pos = ctr.readUint16(csr);
1426 csr += 2;
1427 // Release point check (prevents a bug)
1428 // https://github.com/BambooTracker/BambooTracker/issues/11
1429 if (pos < seqLen) instManLocked->setArpeggioSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
1430 else instManLocked->setArpeggioSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1431 break;
1432 }
1433 default:
1434 throw FileCorruptionError(FileType::Inst, csr);
1435 }
1436
1437 if (fileVersion >= Version::toBCD(1, 0, 1)) {
1438 switch (ctr.readUint8(csr++)) {
1439 case 0x00: // Absolute
1440 instManLocked->setArpeggioSSGType(idx, SequenceType::AbsoluteSequence);
1441 break;
1442 case 0x01: // Fixed
1443 instManLocked->setArpeggioSSGType(idx, SequenceType::FixedSequence);
1444 if (fileVersion < Version::toBCD(1, 5, 1)) {
1445 // Add infinity loop to the last data, to keep compatibility
1446 auto loopRt = instManLocked->getArpeggioSSGLoopRoot(idx).getAllLoops();
1447 if (std::none_of(loopRt.begin(), loopRt.end(), [](InstrumentSequenceLoop& loop) { return loop.isInfinite(); })) {
1448 auto seq = instManLocked->getArpeggioSSGSequence(idx);
1449 if (!seq.empty()) {
1450 size_t pos = seq.size();
1451 instManLocked->addArpeggioSSGSequenceData(idx, seq.back().data);
1452 instManLocked->addArpeggioSSGLoop(idx, InstrumentSequenceLoop(pos, pos, InstrumentSequenceLoop::INFINITE_LOOP));
1453 }
1454 }
1455 }
1456 break;
1457 case 0x02: // Relative
1458 instManLocked->setArpeggioSSGType(idx, SequenceType::RelativeSequence);
1459 break;
1460 default:
1461 if (fileVersion < Version::toBCD(1, 2, 3)) {
1462 // Recover deep clone bug
1463 // https://github.com/BambooTracker/BambooTracker/issues/170
1464 instManLocked->setArpeggioSSGType(idx, SequenceType::AbsoluteSequence);
1465 break;
1466 }
1467 else {
1468 throw FileCorruptionError(FileType::Inst, csr);
1469 }
1470 }
1471 }
1472
1473 instPropCsr += ofs;
1474 break;
1475 }
1476 case 0x34: // SSG pitch
1477 {
1478 int idx = *numIt++;
1479 auto ssg = dynamic_cast<InstrumentSSG*>(inst);
1480 ssg->setPitchEnabled(true);
1481 ssg->setPitchNumber(idx);
1482 uint16_t ofs = ctr.readUint16(instPropCsr);
1483 size_t csr = instPropCsr + 2;
1484
1485 uint16_t seqLen = ctr.readUint16(csr);
1486 csr += 2;
1487 for (uint16_t l = 0; l < seqLen; ++l) {
1488 uint16_t data = ctr.readUint16(csr);
1489 csr += 2;
1490 if (fileVersion < Version::toBCD(1, 2, 0)) csr += 2;
1491 if (l == 0)
1492 instManLocked->setPitchSSGSequenceData(idx, 0, data);
1493 else
1494 instManLocked->addPitchSSGSequenceData(idx, data);
1495 }
1496
1497 uint16_t loopCnt = ctr.readUint16(csr);
1498 csr += 2;
1499 for (uint16_t l = 0; l < loopCnt; ++l) {
1500 int begin = ctr.readUint16(csr);
1501 csr += 2;
1502 int end = ctr.readUint16(csr);
1503 csr += 2;
1504 int times = ctr.readUint8(csr++);
1505 instManLocked->addPitchSSGLoop(idx, InstrumentSequenceLoop(begin, end, times));
1506 }
1507
1508 switch (ctr.readUint8(csr++)) {
1509 case 0x00: // No release
1510 instManLocked->setPitchSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1511 break;
1512 case 0x01: // Fixed
1513 {
1514 uint16_t pos = ctr.readUint16(csr);
1515 csr += 2;
1516 // Release point check (prevents a bug)
1517 // https://github.com/BambooTracker/BambooTracker/issues/11
1518 if (pos < seqLen) instManLocked->setPitchSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
1519 else instManLocked->setPitchSSGRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1520 break;
1521 }
1522 default:
1523 throw FileCorruptionError(FileType::Inst, csr);
1524 }
1525
1526 if (fileVersion >= Version::toBCD(1, 0, 1)) {
1527 switch (ctr.readUint8(csr++)) {
1528 case 0x00: // Absolute
1529 instManLocked->setPitchSSGType(idx, SequenceType::AbsoluteSequence);
1530 break;
1531 case 0x02: // Relative
1532 instManLocked->setPitchSSGType(idx, SequenceType::RelativeSequence);
1533 break;
1534 default:
1535 if (fileVersion < Version::toBCD(1, 2, 3)) {
1536 // Recover deep clone bug
1537 // https://github.com/BambooTracker/BambooTracker/issues/170
1538 instManLocked->setPitchSSGType(idx, SequenceType::AbsoluteSequence);
1539 break;
1540 }
1541 else {
1542 throw FileCorruptionError(FileType::Inst, csr);
1543 }
1544 }
1545 }
1546
1547 instPropCsr += ofs;
1548 break;
1549 }
1550 case 0x40: // ADPCM sample
1551 {
1552 int idx = *numIt++;
1553 if (inst->getType() == InstrumentType::ADPCM) {
1554 auto adpcm = dynamic_cast<InstrumentADPCM*>(inst);
1555 adpcm->setSampleNumber(idx);
1556 }
1557 else if (inst->getType() == InstrumentType::Drumkit) {
1558 auto kit = dynamic_cast<InstrumentDrumkit*>(inst);
1559 for (const int& key : kitSampMap.at(idx))
1560 kit->setSampleNumber(key, idx);
1561 }
1562 uint32_t ofs = ctr.readUint32(instPropCsr);
1563 size_t csr = instPropCsr + 4;
1564
1565 instManLocked->setSampleADPCMRootKeyNumber(idx, ctr.readUint8(csr++));
1566 instManLocked->setSampleADPCMRootDeltaN(idx, ctr.readUint16(csr));
1567 csr += 2;
1568 instManLocked->setSampleADPCMRepeatEnabled(idx, (ctr.readUint8(csr++) & 0x01) != 0);
1569 uint32_t len = ctr.readUint32(csr);
1570 csr += 4;
1571 std::vector<uint8_t> samples = ctr.getSubcontainer(csr, len).toVector();
1572 csr += len;
1573 instManLocked->storeSampleADPCMRawSample(idx, samples);
1574 if (fileVersion >= Version::toBCD(1, 5, 1)) {
1575 uint16_t repeatBegin = ctr.readUint16(csr);
1576 csr += 2;
1577 uint16_t repeatEnd = ctr.readUint16(csr);
1578 csr += 2;
1579 instManLocked->setSampleADPCMRepeatrange(idx, SampleRepeatRange(repeatBegin, repeatEnd));
1580 }
1581 else {
1582 instManLocked->setSampleADPCMRepeatrange(idx, SampleRepeatRange(0, (samples.size() - 1) >> 5));
1583 }
1584
1585 instPropCsr += ofs;
1586 break;
1587 }
1588 case 0x41: // ADPCM envelope
1589 {
1590 int idx = *numIt++;
1591 auto adpcm = dynamic_cast<InstrumentADPCM*>(inst);
1592 adpcm->setEnvelopeEnabled(true);
1593 adpcm->setEnvelopeNumber(idx);
1594 uint16_t ofs = ctr.readUint16(instPropCsr);
1595 size_t csr = instPropCsr + 2;
1596
1597 uint16_t seqLen = ctr.readUint16(csr);
1598 csr += 2;
1599 for (uint16_t l = 0; l < seqLen; ++l) {
1600 uint16_t data = ctr.readUint16(csr);
1601 csr += 2;
1602 if (l == 0)
1603 instManLocked->setEnvelopeADPCMSequenceData(idx, 0, data);
1604 else
1605 instManLocked->addEnvelopeADPCMSequenceData(idx, data);
1606 if (fileVersion < Version::toBCD(1, 5, 0)) csr += 4;
1607 }
1608
1609 uint16_t loopCnt = ctr.readUint16(csr);
1610 csr += 2;
1611 for (uint16_t l = 0; l < loopCnt; ++l) {
1612 int begin = ctr.readUint16(csr);
1613 csr += 2;
1614 int end = ctr.readUint16(csr);
1615 csr += 2;
1616 int times = ctr.readUint8(csr++);
1617 instManLocked->addEnvelopeADPCMLoop(idx, InstrumentSequenceLoop(begin, end, times));
1618 }
1619
1620 switch (ctr.readUint8(csr++)) {
1621 case 0x00: // No release
1622 instManLocked->setEnvelopeADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1623 break;
1624 // Release point check (prevents a bug)
1625 // https://github.com/BambooTracker/BambooTracker/issues/11
1626 case 0x01: // Fixed
1627 {
1628 uint16_t pos = ctr.readUint16(csr);
1629 csr += 2;
1630 if (pos < seqLen) instManLocked->setEnvelopeADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
1631 else instManLocked->setEnvelopeADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1632 break;
1633 }
1634 case 0x02: // Absolute
1635 {
1636 uint16_t pos = ctr.readUint16(csr);
1637 csr += 2;
1638 if (pos < seqLen) instManLocked->setEnvelopeADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::AbsoluteRelease, pos));
1639 else instManLocked->setEnvelopeADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1640 break;
1641 }
1642 case 0x03: // Relative
1643 {
1644 uint16_t pos = ctr.readUint16(csr);
1645 csr += 2;
1646 if (pos < seqLen) instManLocked->setEnvelopeADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::RelativeRelease, pos));
1647 else instManLocked->setEnvelopeADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1648 break;
1649 }
1650 default:
1651 throw FileCorruptionError(FileType::Inst, csr);
1652 }
1653
1654 ++csr; // Skip sequence type
1655
1656 instPropCsr += ofs;
1657 break;
1658 }
1659 case 0x42: // ADPCM arpeggio
1660 {
1661 int idx = *numIt++;
1662 auto adpcm = dynamic_cast<InstrumentADPCM*>(inst);
1663 adpcm->setArpeggioEnabled(true);
1664 adpcm->setArpeggioNumber(idx);
1665 uint16_t ofs = ctr.readUint16(instPropCsr);
1666 size_t csr = instPropCsr + 2;
1667
1668 uint16_t seqLen = ctr.readUint16(csr);
1669 csr += 2;
1670 for (uint16_t l = 0; l < seqLen; ++l) {
1671 uint16_t data = ctr.readUint16(csr);
1672 csr += 2;
1673 if (fileVersion < Version::toBCD(1, 2, 0)) csr += 2;
1674 if (l == 0)
1675 instManLocked->setArpeggioADPCMSequenceData(idx, 0, data);
1676 else
1677 instManLocked->addArpeggioADPCMSequenceData(idx, data);
1678 }
1679
1680 uint16_t loopCnt = ctr.readUint16(csr);
1681 csr += 2;
1682 for (uint16_t l = 0; l < loopCnt; ++l) {
1683 int begin = ctr.readUint16(csr);
1684 csr += 2;
1685 int end = ctr.readUint16(csr);
1686 csr += 2;
1687 int times = ctr.readUint8(csr++);
1688 instManLocked->addArpeggioADPCMLoop(idx, InstrumentSequenceLoop(begin, end, times));
1689 }
1690
1691 switch (ctr.readUint8(csr++)) {
1692 case 0x00: // No release
1693 instManLocked->setArpeggioADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1694 break;
1695 case 0x01: // Fixed
1696 {
1697 uint16_t pos = ctr.readUint16(csr);
1698 csr += 2;
1699 // Release point check (prevents a bug)
1700 // https://github.com/BambooTracker/BambooTracker/issues/11
1701 if (pos < seqLen) instManLocked->setArpeggioADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
1702 else instManLocked->setArpeggioADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1703 break;
1704 }
1705 default:
1706 throw FileCorruptionError(FileType::Inst, csr);
1707 }
1708
1709 switch (ctr.readUint8(csr++)) {
1710 case 0x00: // Absolute
1711 instManLocked->setArpeggioADPCMType(idx, SequenceType::AbsoluteSequence);
1712 break;
1713 case 0x01: // Fixed
1714 instManLocked->setArpeggioADPCMType(idx, SequenceType::FixedSequence);
1715 if (fileVersion < Version::toBCD(1, 5, 1)) {
1716 // Add infinity loop to the last data, to keep compatibility
1717 auto loopRt = instManLocked->getArpeggioADPCMLoopRoot(idx).getAllLoops();
1718 if (std::none_of(loopRt.begin(), loopRt.end(), [](InstrumentSequenceLoop& loop) { return loop.isInfinite(); })) {
1719 auto seq = instManLocked->getArpeggioADPCMSequence(idx);
1720 if (!seq.empty()) {
1721 size_t pos = seq.size();
1722 instManLocked->addArpeggioADPCMSequenceData(idx, seq.back().data);
1723 instManLocked->addArpeggioADPCMLoop(idx, InstrumentSequenceLoop(pos, pos, InstrumentSequenceLoop::INFINITE_LOOP));
1724 }
1725 }
1726 }
1727 break;
1728 case 0x02: // Relative
1729 instManLocked->setArpeggioADPCMType(idx, SequenceType::RelativeSequence);
1730 break;
1731 default:
1732 throw FileCorruptionError(FileType::Inst, csr);
1733 }
1734
1735 instPropCsr += ofs;
1736 break;
1737 }
1738 case 0x43: // ADPCM pitch
1739 {
1740 int idx = *numIt++;
1741 auto adpcm = dynamic_cast<InstrumentADPCM*>(inst);
1742 adpcm->setPitchEnabled(true);
1743 adpcm->setPitchNumber(idx);
1744 uint16_t ofs = ctr.readUint16(instPropCsr);
1745 size_t csr = instPropCsr + 2;
1746
1747 uint16_t seqLen = ctr.readUint16(csr);
1748 csr += 2;
1749 for (uint16_t l = 0; l < seqLen; ++l) {
1750 uint16_t data = ctr.readUint16(csr);
1751 csr += 2;
1752 if (fileVersion < Version::toBCD(1, 2, 0)) csr += 2;
1753 if (l == 0)
1754 instManLocked->setPitchADPCMSequenceData(idx, 0, data);
1755 else
1756 instManLocked->addPitchADPCMSequenceData(idx, data);
1757 }
1758
1759 uint16_t loopCnt = ctr.readUint16(csr);
1760 csr += 2;
1761 for (uint16_t l = 0; l < loopCnt; ++l) {
1762 int begin = ctr.readUint16(csr);
1763 csr += 2;
1764 int end = ctr.readUint16(csr);
1765 csr += 2;
1766 int times = ctr.readUint8(csr++);
1767 instManLocked->addPitchADPCMLoop(idx, InstrumentSequenceLoop(begin, end, times));
1768 }
1769
1770 switch (ctr.readUint8(csr++)) {
1771 case 0x00: // No release
1772 instManLocked->setPitchADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1773 break;
1774 case 0x01: // Fixed
1775 {
1776 uint16_t pos = ctr.readUint16(csr);
1777 csr += 2;
1778 // Release point check (prevents a bug)
1779 // https://github.com/BambooTracker/BambooTracker/issues/11
1780 if (pos < seqLen) instManLocked->setPitchADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
1781 else instManLocked->setPitchADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1782 break;
1783 }
1784 default:
1785 throw FileCorruptionError(FileType::Inst, csr);
1786 }
1787
1788 switch (ctr.readUint8(csr++)) {
1789 case 0x00: // Absolute
1790 instManLocked->setPitchADPCMType(idx, SequenceType::AbsoluteSequence);
1791 break;
1792 case 0x02: // Relative
1793 instManLocked->setPitchADPCMType(idx, SequenceType::RelativeSequence);
1794 break;
1795 default:
1796 throw FileCorruptionError(FileType::Inst, csr);
1797 }
1798
1799 instPropCsr += ofs;
1800 break;
1801 }
1802 case 0x44: // ADPCM pan
1803 {
1804 int idx = *numIt++;
1805 auto adpcm = dynamic_cast<InstrumentADPCM*>(inst);
1806 adpcm->setPanEnabled(true);
1807 adpcm->setPanNumber(idx);
1808 uint16_t ofs = ctr.readUint16(instPropCsr);
1809 size_t csr = instPropCsr + 2;
1810
1811 uint16_t seqLen = ctr.readUint16(csr);
1812 csr += 2;
1813 for (uint16_t l = 0; l < seqLen; ++l) {
1814 uint16_t data = ctr.readUint16(csr);
1815 csr += 2;
1816 if (l == 0)
1817 instManLocked->setPanADPCMSequenceData(idx, 0, data);
1818 else
1819 instManLocked->addPanADPCMSequenceData(idx, data);
1820 }
1821
1822 uint16_t loopCnt = ctr.readUint16(csr);
1823 csr += 2;
1824 for (uint16_t l = 0; l < loopCnt; ++l) {
1825 int begin = ctr.readUint16(csr);
1826 csr += 2;
1827 int end = ctr.readUint16(csr);
1828 csr += 2;
1829 int times = ctr.readUint8(csr++);
1830 instManLocked->addPanADPCMLoop(idx, InstrumentSequenceLoop(begin, end, times));
1831 }
1832
1833 switch (ctr.readUint8(csr++)) {
1834 case 0x00: // No release
1835 instManLocked->setPanADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1836 break;
1837 case 0x01: // Fixed
1838 {
1839 uint16_t pos = ctr.readUint16(csr);
1840 csr += 2;
1841 // Release point check (prevents a bug)
1842 // https://github.com/BambooTracker/BambooTracker/issues/11
1843 if (pos < seqLen) instManLocked->setPanADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::FixedRelease, pos));
1844 else instManLocked->setPanADPCMRelease(idx, InstrumentSequenceRelease(InstrumentSequenceRelease::NoRelease));
1845 break;
1846 }
1847 default:
1848 throw FileCorruptionError(FileType::Inst, csr);
1849 }
1850
1851 instPropCsr += ofs;
1852 break;
1853 }
1854 default:
1855 throw FileCorruptionError(FileType::Inst, instPropCsr);
1856 }
1857 }
1858 }
1859
1860
1861 return inst;
1862 }
1863 }
1864
1865 void BtiIO::save(BinaryContainer& ctr,
1866 const std::weak_ptr<InstrumentsManager> instMan, int instNum) const
1867 {
1868 const std::shared_ptr<InstrumentsManager> instManLocked = instMan.lock();
1869
1870 ctr.appendString("BambooTrackerIst");
1871 size_t eofOfs = ctr.size();
1872 ctr.appendUint32(0); // Dummy EOF offset
1873 uint32_t fileVersion = Version::ofInstrumentFileInBCD();
1874 ctr.appendUint32(fileVersion);
1875
1876
1877 /***** Instrument section *****/
1878 ctr.appendString("INSTRMNT");
1879 size_t instOfs = ctr.size();
1880 ctr.appendUint32(0); // Dummy instrument section offset
1881
1882 std::vector<int> fmArpNums, fmPtNums;
1883 std::shared_ptr<AbstractInstrument> inst = instManLocked->getInstrumentSharedPtr(instNum);
1884 if (inst) {
1885 std::string name = inst->getName();
1886 ctr.appendUint32(name.length());
1887 if (!name.empty()) ctr.appendString(name);
1888 switch (inst->getType()) {
1889 case InstrumentType::FM:
1890 {
1891 ctr.appendUint8(0x00);
1892 auto instFM = std::dynamic_pointer_cast<InstrumentFM>(inst);
1893 uint8_t tmp = static_cast<uint8_t>(instFM->getEnvelopeResetEnabled(FMOperatorType::All))
1894 | static_cast<uint8_t>(instFM->getEnvelopeResetEnabled(FMOperatorType::Op1) << 1)
1895 | static_cast<uint8_t>(instFM->getEnvelopeResetEnabled(FMOperatorType::Op2) << 2)
1896 | static_cast<uint8_t>(instFM->getEnvelopeResetEnabled(FMOperatorType::Op3) << 3)
1897 | static_cast<uint8_t>(instFM->getEnvelopeResetEnabled(FMOperatorType::Op4) << 4);
1898 ctr.appendUint8(tmp);
1899 if (instFM->getArpeggioEnabled(FMOperatorType::All))
1900 fmArpNums.push_back(instFM->getArpeggioNumber(FMOperatorType::All));
1901 for (auto& t : FM_OP_TYPES) {
1902 if (instFM->getArpeggioEnabled(t)) {
1903 int n = instFM->getArpeggioNumber(t);
1904 if (utils::find(fmArpNums, n) == fmArpNums.end())
1905 fmArpNums.push_back(n);
1906 }
1907 }
1908 if (instFM->getArpeggioEnabled(FMOperatorType::All)) {
1909 int n = instFM->getArpeggioNumber(FMOperatorType::All);
1910 for (size_t i = 0; i < fmArpNums.size(); ++i) {
1911 if (n == fmArpNums[i]) {
1912 ctr.appendUint8(static_cast<uint8_t>(i));
1913 break;
1914 }
1915 }
1916 }
1917 else {
1918 ctr.appendUint8(0x80);
1919 }
1920 for (auto& t : FM_OP_TYPES) {
1921 if (instFM->getArpeggioEnabled(t)) {
1922 int n = instFM->getArpeggioNumber(t);
1923 for (size_t i = 0; i < fmArpNums.size(); ++i) {
1924 if (n == fmArpNums[i]) {
1925 ctr.appendUint8(static_cast<uint8_t>(i));
1926 break;
1927 }
1928 }
1929 }
1930 else {
1931 ctr.appendUint8(0x80);
1932 }
1933 }
1934 if (instFM->getPitchEnabled(FMOperatorType::All))
1935 fmPtNums.push_back(instFM->getPitchNumber(FMOperatorType::All));
1936 for (auto& t : FM_OP_TYPES) {
1937 if (instFM->getPitchEnabled(t)) {
1938 int n = instFM->getPitchNumber(t);
1939 if (utils::find(fmPtNums, n) == fmPtNums.end())
1940 fmPtNums.push_back(n);
1941 }
1942 }
1943 if (instFM->getPitchEnabled(FMOperatorType::All)) {
1944 int n = instFM->getPitchNumber(FMOperatorType::All);
1945 for (size_t i = 0; i < fmPtNums.size(); ++i) {
1946 if (n == fmPtNums[i]) {
1947 ctr.appendUint8(static_cast<uint8_t>(i));
1948 break;
1949 }
1950 }
1951 }
1952 else {
1953 ctr.appendUint8(0x80);
1954 }
1955 for (auto& t : FM_OP_TYPES) {
1956 if (instFM->getPitchEnabled(t)) {
1957 int n = instFM->getPitchNumber(t);
1958 for (size_t i = 0; i < fmPtNums.size(); ++i) {
1959 if (n == fmPtNums[i]) {
1960 ctr.appendUint8(static_cast<uint8_t>(i));
1961 break;
1962 }
1963 }
1964 }
1965 else {
1966 ctr.appendUint8(0x80);
1967 }
1968 }
1969 break;
1970 }
1971 case InstrumentType::SSG:
1972 {
1973 ctr.appendUint8(0x01);
1974 break;
1975 }
1976 case InstrumentType::ADPCM:
1977 {
1978 ctr.appendUint8(0x02);
1979 break;
1980 }
1981 case InstrumentType::Drumkit:
1982 {
1983 ctr.appendUint8(0x03);
1984 auto kit = std::dynamic_pointer_cast<InstrumentDrumkit>(inst);
1985 std::vector<int> keys = kit->getAssignedKeys();
1986 ctr.appendUint8(static_cast<uint8_t>(keys.size()));
1987 int sampCnt = 0;
1988 std::unordered_map<int, int> sampMap;
1989 for (const int& key : keys) {
1990 ctr.appendUint8(static_cast<uint8_t>(key));
1991 int samp = kit->getSampleNumber(key);
1992 if (!sampMap.count(samp)) sampMap[samp] = sampCnt++;
1993 ctr.appendUint8(static_cast<uint8_t>(sampMap[samp]));
1994 ctr.appendInt8(static_cast<int8_t>(kit->getPitch(key)));
1995 ctr.appendUint8(static_cast<uint8_t>(kit->getPan(key)));
1996 }
1997 break;
1998 }
1999 }
2000 }
2001 ctr.writeUint32(instOfs, ctr.size() - instOfs);
2002
2003
2004 /***** Instrument property section *****/
2005 ctr.appendString("INSTPROP");
2006 size_t instPropOfs = ctr.size();
2007 ctr.appendUint32(0); // Dummy instrument property section offset
2008
2009 switch (inst->getType()) {
2010 case InstrumentType::FM:
2011 {
2012 auto instFM = std::dynamic_pointer_cast<InstrumentFM>(inst);
2013
2014 // FM envelope
2015 int envNum = instFM->getEnvelopeNumber();
2016 {
2017 ctr.appendUint8(0x00);
2018 size_t ofs = ctr.size();
2019 ctr.appendUint8(0); // Dummy offset
2020 uint8_t tmp = static_cast<uint8_t>(instManLocked->getEnvelopeFMParameter(envNum, FMEnvelopeParameter::AL) << 4)
2021 | static_cast<uint8_t>(instManLocked->getEnvelopeFMParameter(envNum, FMEnvelopeParameter::FB));
2022 ctr.appendUint8(tmp);
2023 for (int op = 0; op < 4; ++op) {
2024 auto& params = FM_OP_PARAMS[op];
2025 tmp = instManLocked->getEnvelopeFMOperatorEnabled(envNum, op);
2026 tmp = static_cast<uint8_t>(tmp << 5)
2027 | static_cast<uint8_t>(instManLocked->getEnvelopeFMParameter(envNum, params.at(FMOperatorParameter::AR)));
2028 ctr.appendUint8(tmp);
2029 tmp = static_cast<uint8_t>(instManLocked->getEnvelopeFMParameter(envNum, params.at(FMOperatorParameter::KS)) << 5)
2030 | static_cast<uint8_t>(instManLocked->getEnvelopeFMParameter(envNum, params.at(FMOperatorParameter::DR)));
2031 ctr.appendUint8(tmp);
2032 tmp = static_cast<uint8_t>(instManLocked->getEnvelopeFMParameter(envNum, params.at(FMOperatorParameter::DT)) << 5)
2033 | static_cast<uint8_t>(instManLocked->getEnvelopeFMParameter(envNum, params.at(FMOperatorParameter::SR)));
2034 ctr.appendUint8(tmp);
2035 tmp = static_cast<uint8_t>(instManLocked->getEnvelopeFMParameter(envNum, params.at(FMOperatorParameter::SL)) << 4)
2036 | static_cast<uint8_t>(instManLocked->getEnvelopeFMParameter(envNum, params.at(FMOperatorParameter::RR)));
2037 ctr.appendUint8(tmp);
2038 tmp = static_cast<uint8_t>(instManLocked->getEnvelopeFMParameter(envNum, params.at(FMOperatorParameter::TL)));
2039 ctr.appendUint8(tmp);
2040 int tmp2 = instManLocked->getEnvelopeFMParameter(envNum, params.at(FMOperatorParameter::SSGEG));
2041 tmp = ((tmp2 == -1) ? 0x80 : static_cast<uint8_t>(tmp2 << 4))
2042 | static_cast<uint8_t>(instManLocked->getEnvelopeFMParameter(envNum, params.at(FMOperatorParameter::ML)));
2043 ctr.appendUint8(tmp);
2044 }
2045 ctr.writeUint8(ofs, static_cast<uint8_t>(ctr.size() - ofs));
2046 }
2047
2048 // FM LFO
2049 if (instFM->getLFOEnabled()) {
2050 int lfoNum = instFM->getLFONumber();
2051 ctr.appendUint8(0x01);
2052 size_t ofs = ctr.size();
2053 ctr.appendUint8(0); // Dummy offset
2054 uint8_t tmp = static_cast<uint8_t>(instManLocked->getLFOFMparameter(lfoNum, FMLFOParameter::FREQ) << 4)
2055 | static_cast<uint8_t>(instManLocked->getLFOFMparameter(lfoNum, FMLFOParameter::PMS));
2056 ctr.appendUint8(tmp);
2057 tmp = static_cast<uint8_t>(instManLocked->getLFOFMparameter(lfoNum, FMLFOParameter::AM4) << 7)
2058 | static_cast<uint8_t>(instManLocked->getLFOFMparameter(lfoNum, FMLFOParameter::AM3) << 6)
2059 | static_cast<uint8_t>(instManLocked->getLFOFMparameter(lfoNum, FMLFOParameter::AM2) << 5)
2060 | static_cast<uint8_t>(instManLocked->getLFOFMparameter(lfoNum, FMLFOParameter::AM1) << 4)
2061 | static_cast<uint8_t>(instManLocked->getLFOFMparameter(lfoNum, FMLFOParameter::AMS));
2062 ctr.appendUint8(tmp);
2063 tmp = static_cast<uint8_t>(instManLocked->getLFOFMparameter(lfoNum, FMLFOParameter::Count));
2064 ctr.appendUint8(tmp);
2065 ctr.writeUint8(ofs, static_cast<uint8_t>(ctr.size() - ofs));
2066 }
2067
2068 // FM envelope parameter
2069 for (size_t i = 0; i < 38; ++i) {
2070 if (instFM->getOperatorSequenceEnabled(FM_OPSEQ_PARAMS[i])) {
2071 int seqNum = instFM->getOperatorSequenceNumber(FM_OPSEQ_PARAMS[i]);
2072 ctr.appendUint8(0x02 + static_cast<uint8_t>(i));
2073 size_t ofs = ctr.size();
2074 ctr.appendUint16(0); // Dummy offset
2075 auto seq = instManLocked->getOperatorSequenceFMSequence(FM_OPSEQ_PARAMS[i], seqNum);
2076 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2077 for (auto& unit : seq) {
2078 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2079 }
2080 auto loops = instManLocked->getOperatorSequenceFMLoopRoot(FM_OPSEQ_PARAMS[i], seqNum).getAllLoops();
2081 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2082 for (auto& loop : loops) {
2083 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2084 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2085 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2086 }
2087 auto release = instManLocked->getOperatorSequenceFMRelease(FM_OPSEQ_PARAMS[i], seqNum);
2088 switch (release.getType()) {
2089 case InstrumentSequenceRelease::NoRelease:
2090 ctr.appendUint8(0x00);
2091 break;
2092 case InstrumentSequenceRelease::FixedRelease:
2093 ctr.appendUint8(0x01);
2094 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2095 break;
2096 case InstrumentSequenceRelease::AbsoluteRelease:
2097 ctr.appendUint8(0x02);
2098 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2099 break;
2100 case InstrumentSequenceRelease::RelativeRelease:
2101 ctr.appendUint8(0x03);
2102 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2103 break;
2104 }
2105 ctr.appendUint8(0); // Skip sequence type
2106 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2107 }
2108 }
2109
2110 // FM arpeggio
2111 for (int& arpNum : fmArpNums) {
2112 ctr.appendUint8(0x28);
2113 size_t ofs = ctr.size();
2114 ctr.appendUint16(0); // Dummy offset
2115 auto seq = instManLocked->getArpeggioFMSequence(arpNum);
2116 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2117 for (auto& unit : seq) {
2118 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2119 }
2120 auto loops = instManLocked->getArpeggioFMLoopRoot(arpNum).getAllLoops();
2121 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2122 for (auto& loop : loops) {
2123 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2124 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2125 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2126 }
2127 auto release = instManLocked->getArpeggioFMRelease(arpNum);
2128 switch (release.getType()) {
2129 case InstrumentSequenceRelease::NoRelease:
2130 ctr.appendUint8(0x00);
2131 break;
2132 case InstrumentSequenceRelease::FixedRelease:
2133 ctr.appendUint8(0x01);
2134 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2135 break;
2136 case InstrumentSequenceRelease::AbsoluteRelease:
2137 ctr.appendUint8(0x02);
2138 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2139 break;
2140 case InstrumentSequenceRelease::RelativeRelease:
2141 ctr.appendUint8(0x03);
2142 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2143 break;
2144 }
2145 switch (instManLocked->getArpeggioFMType(arpNum)) {
2146 case SequenceType::AbsoluteSequence: ctr.appendUint8(0x00); break;
2147 case SequenceType::FixedSequence: ctr.appendUint8(0x01); break;
2148 case SequenceType::RelativeSequence: ctr.appendUint8(0x02); break;
2149 default: break;
2150 }
2151 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2152 }
2153
2154 // FM pitch
2155 for (int& ptNum : fmPtNums) {
2156 ctr.appendUint8(0x29);
2157 size_t ofs = ctr.size();
2158 ctr.appendUint16(0); // Dummy offset
2159 auto seq = instManLocked->getPitchFMSequence(ptNum);
2160 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2161 for (auto& unit : seq) {
2162 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2163 }
2164 auto loops = instManLocked->getPitchFMLoopRoot(ptNum).getAllLoops();
2165 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2166 for (auto& loop : loops) {
2167 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2168 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2169 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2170 }
2171 auto release = instManLocked->getPitchFMRelease(ptNum);
2172 switch (release.getType()) {
2173 case InstrumentSequenceRelease::NoRelease:
2174 ctr.appendUint8(0x00);
2175 break;
2176 case InstrumentSequenceRelease::FixedRelease:
2177 ctr.appendUint8(0x01);
2178 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2179 break;
2180 case InstrumentSequenceRelease::AbsoluteRelease:
2181 ctr.appendUint8(0x02);
2182 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2183 break;
2184 case InstrumentSequenceRelease::RelativeRelease:
2185 ctr.appendUint8(0x03);
2186 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2187 break;
2188 }
2189 switch (instManLocked->getPitchFMType(ptNum)) {
2190 case SequenceType::AbsoluteSequence: ctr.appendUint8(0x00); break;
2191 case SequenceType::RelativeSequence: ctr.appendUint8(0x02); break;
2192 default: break;
2193 }
2194 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2195 }
2196
2197 // FM pan
2198 if (instFM->getPanEnabled()) {
2199 int panNum = instFM->getPanNumber();
2200 ctr.appendUint8(0x2a);
2201 size_t ofs = ctr.size();
2202 ctr.appendUint16(0); // Dummy offset
2203 auto seq = instManLocked->getPanFMSequence(panNum);
2204 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2205 for (auto& unit : seq) {
2206 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2207 }
2208 auto loops = instManLocked->getPanFMLoopRoot(panNum).getAllLoops();
2209 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2210 for (auto& loop : loops) {
2211 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2212 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2213 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2214 }
2215 auto release = instManLocked->getPanFMRelease(panNum);
2216 switch (release.getType()) {
2217 case InstrumentSequenceRelease::NoRelease:
2218 ctr.appendUint8(0x00);
2219 break;
2220 case InstrumentSequenceRelease::FixedRelease:
2221 ctr.appendUint8(0x01);
2222 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2223 break;
2224 case InstrumentSequenceRelease::AbsoluteRelease:
2225 ctr.appendUint8(0x02);
2226 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2227 break;
2228 case InstrumentSequenceRelease::RelativeRelease:
2229 ctr.appendUint8(0x03);
2230 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2231 break;
2232 }
2233 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2234 }
2235 break;
2236 }
2237 case InstrumentType::SSG:
2238 {
2239 auto instSSG = std::dynamic_pointer_cast<InstrumentSSG>(inst);
2240
2241 // SSG waveform
2242 if (instSSG->getWaveformEnabled()) {
2243 int wfNum = instSSG->getWaveformNumber();
2244 ctr.appendUint8(0x30);
2245 size_t ofs = ctr.size();
2246 ctr.appendUint16(0); // Dummy offset
2247 auto seq = instManLocked->getWaveformSSGSequence(wfNum);
2248 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2249 for (auto& unit : seq) {
2250 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2251 ctr.appendInt32(static_cast<int32_t>(unit.subdata));
2252 }
2253 auto loops = instManLocked->getWaveformSSGLoopRoot(wfNum).getAllLoops();
2254 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2255 for (auto& loop : loops) {
2256 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2257 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2258 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2259 }
2260 auto release = instManLocked->getWaveformSSGRelease(wfNum);
2261 switch (release.getType()) {
2262 case InstrumentSequenceRelease::NoRelease:
2263 ctr.appendUint8(0x00);
2264 break;
2265 case InstrumentSequenceRelease::FixedRelease:
2266 ctr.appendUint8(0x01);
2267 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2268 break;
2269 case InstrumentSequenceRelease::AbsoluteRelease:
2270 ctr.appendUint8(0x02);
2271 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2272 break;
2273 case InstrumentSequenceRelease::RelativeRelease:
2274 ctr.appendUint8(0x03);
2275 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2276 break;
2277 }
2278 ctr.appendUint8(0); // Skip sequence type
2279 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2280 }
2281
2282 // SSG tone/noise
2283 if (instSSG->getToneNoiseEnabled()) {
2284 int tnNum = instSSG->getToneNoiseNumber();
2285 ctr.appendUint8(0x31);
2286 size_t ofs = ctr.size();
2287 ctr.appendUint16(0); // Dummy offset
2288 auto seq = instManLocked->getToneNoiseSSGSequence(tnNum);
2289 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2290 for (auto& unit : seq) {
2291 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2292 }
2293 auto loops = instManLocked->getToneNoiseSSGLoopRoot(tnNum).getAllLoops();
2294 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2295 for (auto& loop : loops) {
2296 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2297 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2298 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2299 }
2300 auto release = instManLocked->getToneNoiseSSGRelease(tnNum);
2301 switch (release.getType()) {
2302 case InstrumentSequenceRelease::NoRelease:
2303 ctr.appendUint8(0x00);
2304 break;
2305 case InstrumentSequenceRelease::FixedRelease:
2306 ctr.appendUint8(0x01);
2307 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2308 break;
2309 case InstrumentSequenceRelease::AbsoluteRelease:
2310 ctr.appendUint8(0x02);
2311 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2312 break;
2313 case InstrumentSequenceRelease::RelativeRelease:
2314 ctr.appendUint8(0x03);
2315 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2316 break;
2317 }
2318 ctr.appendUint8(0); // Skip sequence type
2319 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2320 }
2321
2322 // SSG envelope
2323 if (instSSG->getEnvelopeEnabled()) {
2324 int envNum = instSSG->getEnvelopeNumber();
2325 ctr.appendUint8(0x32);
2326 size_t ofs = ctr.size();
2327 ctr.appendUint16(0); // Dummy offset
2328 auto seq = instManLocked->getEnvelopeSSGSequence(envNum);
2329 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2330 for (auto& unit : seq) {
2331 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2332 ctr.appendInt32(static_cast<int32_t>(unit.subdata));
2333 }
2334 auto loops = instManLocked->getEnvelopeSSGLoopRoot(envNum).getAllLoops();
2335 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2336 for (auto& loop : loops) {
2337 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2338 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2339 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2340 }
2341 auto release = instManLocked->getEnvelopeSSGRelease(envNum);
2342 switch (release.getType()) {
2343 case InstrumentSequenceRelease::NoRelease:
2344 ctr.appendUint8(0x00);
2345 break;
2346 case InstrumentSequenceRelease::FixedRelease:
2347 ctr.appendUint8(0x01);
2348 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2349 break;
2350 case InstrumentSequenceRelease::AbsoluteRelease:
2351 ctr.appendUint8(0x02);
2352 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2353 break;
2354 case InstrumentSequenceRelease::RelativeRelease:
2355 ctr.appendUint8(0x03);
2356 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2357 break;
2358 }
2359 ctr.appendUint8(0); // Skip sequence type
2360 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2361 }
2362
2363 // SSG arpeggio
2364 if (instSSG->getArpeggioEnabled()) {
2365 int arpNum = instSSG->getArpeggioNumber();
2366 ctr.appendUint8(0x33);
2367 size_t ofs = ctr.size();
2368 ctr.appendUint16(0); // Dummy offset
2369 auto seq = instManLocked->getArpeggioSSGSequence(arpNum);
2370 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2371 for (auto& unit : seq) {
2372 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2373 }
2374 auto loops = instManLocked->getArpeggioSSGLoopRoot(arpNum).getAllLoops();
2375 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2376 for (auto& loop : loops) {
2377 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2378 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2379 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2380 }
2381 auto release = instManLocked->getArpeggioSSGRelease(arpNum);
2382 switch (release.getType()) {
2383 case InstrumentSequenceRelease::NoRelease:
2384 ctr.appendUint8(0x00);
2385 break;
2386 case InstrumentSequenceRelease::FixedRelease:
2387 ctr.appendUint8(0x01);
2388 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2389 break;
2390 case InstrumentSequenceRelease::AbsoluteRelease:
2391 ctr.appendUint8(0x02);
2392 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2393 break;
2394 case InstrumentSequenceRelease::RelativeRelease:
2395 ctr.appendUint8(0x03);
2396 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2397 break;
2398 }
2399 switch (instManLocked->getArpeggioSSGType(arpNum)) {
2400 case SequenceType::AbsoluteSequence: ctr.appendUint8(0x00); break;
2401 case SequenceType::FixedSequence: ctr.appendUint8(0x01); break;
2402 case SequenceType::RelativeSequence: ctr.appendUint8(0x02); break;
2403 default: break;
2404 }
2405 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2406 }
2407
2408 // SSG pitch
2409 if (instSSG->getPitchEnabled()) {
2410 int ptNum = instSSG->getPitchNumber();
2411 ctr.appendUint8(0x34);
2412 size_t ofs = ctr.size();
2413 ctr.appendUint16(0); // Dummy offset
2414 auto seq = instManLocked->getPitchSSGSequence(ptNum);
2415 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2416 for (auto& unit : seq) {
2417 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2418 }
2419 auto loops = instManLocked->getPitchSSGLoopRoot(ptNum).getAllLoops();
2420 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2421 for (auto& loop : loops) {
2422 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2423 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2424 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2425 }
2426 auto release = instManLocked->getPitchSSGRelease(ptNum);
2427 switch (release.getType()) {
2428 case InstrumentSequenceRelease::NoRelease:
2429 ctr.appendUint8(0x00);
2430 break;
2431 case InstrumentSequenceRelease::FixedRelease:
2432 ctr.appendUint8(0x01);
2433 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2434 break;
2435 case InstrumentSequenceRelease::AbsoluteRelease:
2436 ctr.appendUint8(0x02);
2437 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2438 break;
2439 case InstrumentSequenceRelease::RelativeRelease:
2440 ctr.appendUint8(0x03);
2441 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2442 break;
2443 }
2444 switch (instManLocked->getPitchSSGType(ptNum)) {
2445 case SequenceType::AbsoluteSequence: ctr.appendUint8(0x00); break;
2446 case SequenceType::RelativeSequence: ctr.appendUint8(0x02); break;
2447 default: break;
2448 }
2449 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2450 }
2451 break;
2452 }
2453 case InstrumentType::ADPCM:
2454 {
2455 auto instADPCM = std::dynamic_pointer_cast<InstrumentADPCM>(inst);
2456
2457 // ADPCM sample
2458 int sampNum = instADPCM->getSampleNumber();
2459 {
2460 ctr.appendUint8(0x40);
2461 size_t ofs = ctr.size();
2462 ctr.appendUint32(0); // Dummy offset
2463 ctr.appendUint8(static_cast<uint8_t>(instManLocked->getSampleADPCMRootKeyNumber(sampNum)));
2464 ctr.appendUint16(static_cast<uint16_t>(instManLocked->getSampleADPCMRootDeltaN(sampNum)));
2465 ctr.appendUint8(static_cast<uint8_t>(instManLocked->isSampleADPCMRepeatable(sampNum)));
2466 std::vector<uint8_t> samples = instManLocked->getSampleADPCMRawSample(sampNum);
2467 ctr.appendUint32(samples.size());
2468 ctr.appendVector(std::move(samples));
2469 SampleRepeatRange range = instMan.lock()->getSampleADPCMRepeatRange(sampNum);
2470 ctr.appendUint16(range.first());
2471 ctr.appendUint16(range.last());
2472 ctr.writeUint32(ofs, ctr.size() - ofs);
2473 }
2474
2475 // ADPCM envelope
2476 if (instADPCM->getEnvelopeEnabled()) {
2477 int envNum = instADPCM->getEnvelopeNumber();
2478 ctr.appendUint8(0x41);
2479 size_t ofs = ctr.size();
2480 ctr.appendUint16(0); // Dummy offset
2481 auto seq = instManLocked->getEnvelopeADPCMSequence(envNum);
2482 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2483 for (auto& unit : seq) {
2484 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2485 }
2486 auto loops = instManLocked->getEnvelopeADPCMLoopRoot(envNum).getAllLoops();
2487 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2488 for (auto& loop : loops) {
2489 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2490 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2491 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2492 }
2493 auto release = instManLocked->getEnvelopeADPCMRelease(envNum);
2494 switch (release.getType()) {
2495 case InstrumentSequenceRelease::NoRelease:
2496 ctr.appendUint8(0x00);
2497 break;
2498 case InstrumentSequenceRelease::FixedRelease:
2499 ctr.appendUint8(0x01);
2500 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2501 break;
2502 case InstrumentSequenceRelease::AbsoluteRelease:
2503 ctr.appendUint8(0x02);
2504 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2505 break;
2506 case InstrumentSequenceRelease::RelativeRelease:
2507 ctr.appendUint8(0x03);
2508 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2509 break;
2510 }
2511 ctr.appendUint8(0); // Skip sequence type
2512 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2513 }
2514
2515 // ADPCM arpeggio
2516 if (instADPCM->getArpeggioEnabled()) {
2517 int arpNum = instADPCM->getArpeggioNumber();
2518 ctr.appendUint8(0x42);
2519 size_t ofs = ctr.size();
2520 ctr.appendUint16(0); // Dummy offset
2521 auto seq = instManLocked->getArpeggioADPCMSequence(arpNum);
2522 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2523 for (auto& unit : seq) {
2524 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2525 }
2526 auto loops = instManLocked->getArpeggioADPCMLoopRoot(arpNum).getAllLoops();
2527 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2528 for (auto& loop : loops) {
2529 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2530 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2531 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2532 }
2533 auto release = instManLocked->getArpeggioADPCMRelease(arpNum);
2534 switch (release.getType()) {
2535 case InstrumentSequenceRelease::NoRelease:
2536 ctr.appendUint8(0x00);
2537 break;
2538 case InstrumentSequenceRelease::FixedRelease:
2539 ctr.appendUint8(0x01);
2540 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2541 break;
2542 case InstrumentSequenceRelease::AbsoluteRelease:
2543 ctr.appendUint8(0x02);
2544 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2545 break;
2546 case InstrumentSequenceRelease::RelativeRelease:
2547 ctr.appendUint8(0x03);
2548 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2549 break;
2550 }
2551 switch (instManLocked->getArpeggioADPCMType(arpNum)) {
2552 case SequenceType::AbsoluteSequence: ctr.appendUint8(0x00); break;
2553 case SequenceType::FixedSequence: ctr.appendUint8(0x01); break;
2554 case SequenceType::RelativeSequence: ctr.appendUint8(0x02); break;
2555 default: break;
2556 }
2557 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2558 }
2559
2560 // ADPCM pitch
2561 if (instADPCM->getPitchEnabled()) {
2562 int ptNum = instADPCM->getPitchNumber();
2563 ctr.appendUint8(0x43);
2564 size_t ofs = ctr.size();
2565 ctr.appendUint16(0); // Dummy offset
2566 auto seq = instManLocked->getPitchADPCMSequence(ptNum);
2567 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2568 for (auto& unit : seq) {
2569 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2570 }
2571 auto loops = instManLocked->getPitchADPCMLoopRoot(ptNum).getAllLoops();
2572 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2573 for (auto& loop : loops) {
2574 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2575 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2576 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2577 }
2578 auto release = instManLocked->getPitchADPCMRelease(ptNum);
2579 switch (release.getType()) {
2580 case InstrumentSequenceRelease::NoRelease:
2581 ctr.appendUint8(0x00);
2582 break;
2583 case InstrumentSequenceRelease::FixedRelease:
2584 ctr.appendUint8(0x01);
2585 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2586 break;
2587 case InstrumentSequenceRelease::AbsoluteRelease:
2588 ctr.appendUint8(0x02);
2589 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2590 break;
2591 case InstrumentSequenceRelease::RelativeRelease:
2592 ctr.appendUint8(0x03);
2593 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2594 break;
2595 }
2596 switch (instManLocked->getPitchADPCMType(ptNum)) {
2597 case SequenceType::AbsoluteSequence: ctr.appendUint8(0x00); break;
2598 case SequenceType::RelativeSequence: ctr.appendUint8(0x02); break;
2599 default: break;
2600 }
2601 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2602 }
2603
2604 // ADPCM pan
2605 if (instADPCM->getPanEnabled()) {
2606 int panNum = instADPCM->getPanNumber();
2607 ctr.appendUint8(0x44);
2608 size_t ofs = ctr.size();
2609 ctr.appendUint16(0); // Dummy offset
2610 auto seq = instManLocked->getPanADPCMSequence(panNum);
2611 ctr.appendUint16(static_cast<uint16_t>(seq.size()));
2612 for (auto& unit : seq) {
2613 ctr.appendUint16(static_cast<uint16_t>(unit.data));
2614 }
2615 auto loops = instManLocked->getPanADPCMLoopRoot(panNum).getAllLoops();
2616 ctr.appendUint16(static_cast<uint16_t>(loops.size()));
2617 for (auto& loop : loops) {
2618 ctr.appendUint16(static_cast<uint16_t>(loop.getBeginPos()));
2619 ctr.appendUint16(static_cast<uint16_t>(loop.getEndPos()));
2620 ctr.appendUint8(static_cast<uint8_t>(loop.getTimes()));
2621 }
2622 auto release = instManLocked->getPanADPCMRelease(panNum);
2623 switch (release.getType()) {
2624 case InstrumentSequenceRelease::NoRelease:
2625 ctr.appendUint8(0x00);
2626 break;
2627 case InstrumentSequenceRelease::FixedRelease:
2628 ctr.appendUint8(0x01);
2629 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2630 break;
2631 case InstrumentSequenceRelease::AbsoluteRelease:
2632 ctr.appendUint8(0x02);
2633 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2634 break;
2635 case InstrumentSequenceRelease::RelativeRelease:
2636 ctr.appendUint8(0x03);
2637 ctr.appendUint16(static_cast<uint16_t>(release.getBeginPos()));
2638 break;
2639 }
2640 ctr.writeUint16(ofs, static_cast<uint16_t>(ctr.size() - ofs));
2641 }
2642 break;
2643 }
2644 case InstrumentType::Drumkit:
2645 {
2646 auto kit = std::dynamic_pointer_cast<InstrumentDrumkit>(inst);
2647
2648 // ADPCM sample
2649 {
2650 std::vector<int> sampList;
2651 for (const int& key : kit->getAssignedKeys()) {
2652 int samp = kit->getSampleNumber(key);
2653 if (std::none_of(sampList.begin(), sampList.end(), [samp](const int& v) { return v == samp; })) {
2654 sampList.push_back(samp);
2655
2656 ctr.appendUint8(0x40);
2657 size_t ofs = ctr.size();
2658 ctr.appendUint32(0); // Dummy offset
2659 ctr.appendUint8(static_cast<uint8_t>(instManLocked->getSampleADPCMRootKeyNumber(samp)));
2660 ctr.appendUint16(static_cast<uint16_t>(instManLocked->getSampleADPCMRootDeltaN(samp)));
2661 ctr.appendUint8(static_cast<uint8_t>(instManLocked->isSampleADPCMRepeatable(samp)));
2662 std::vector<uint8_t> samples = instManLocked->getSampleADPCMRawSample(samp);
2663 ctr.appendUint32(samples.size());
2664 ctr.appendVector(std::move(samples));
2665 SampleRepeatRange range = instMan.lock()->getSampleADPCMRepeatRange(samp);
2666 ctr.appendUint16(range.first());
2667 ctr.appendUint16(range.last());
2668 ctr.writeUint32(ofs, ctr.size() - ofs);
2669 }
2670 }
2671 }
2672 break;
2673 }
2674 }
2675
2676 ctr.writeUint32(instPropOfs, ctr.size() - instPropOfs);
2677
2678 ctr.writeUint32(eofOfs, ctr.size() - eofOfs);
2679 }
2680 }