Debian Codegraph @

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