AxioDL
/
amuse
mirror of https://github.com/AxioDL/amuse.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
amuse/lib/SongConverter.cpp

1436 lines
48 KiB
C++
Raw Blame History

#include "amuse/SongConverter.hpp"
#include <algorithm>
#include <array>
#include <cstdlib>
#include <map>
#include "amuse/Common.hpp"
#include "amuse/SongState.hpp"
namespace amuse {
constexpr uint8_t clamp7(uint8_t val) { return std::max(0, std::min(127, int(val))); }
enum class Status {
NoteOff = 0x80,
NoteOn = 0x90,
NotePressure = 0xA0,
ControlChange = 0xB0,
ProgramChange = 0xC0,
ChannelPressure = 0xD0,
PitchBend = 0xE0,
SysEx = 0xF0,
TimecodeQuarterFrame = 0xF1,
SongPositionPointer = 0xF2,
SongSelect = 0xF3,
TuneRequest = 0xF6,
SysExTerm = 0xF7,
TimingClock = 0xF8,
Start = 0xFA,
Continue = 0xFB,
Stop = 0xFC,
ActiveSensing = 0xFE,
Reset = 0xFF,
};
/* Event tags */
struct NoteEvent {};
struct CtrlEvent {};
struct ProgEvent {};
struct PitchEvent {};
/* Intermediate event */
struct Event {
enum class Type : uint8_t { Note, Control, Program, Pitch } m_type;
bool endEvent = false;
uint8_t channel;
uint8_t noteOrCtrl;
uint8_t velOrVal;
uint8_t program;
int length;
int pitchBend;
Event(NoteEvent, uint8_t chan, uint8_t note, uint8_t vel, int len)
: m_type(Type::Note), channel(chan), noteOrCtrl(note), velOrVal(vel), length(len) {}
Event(CtrlEvent, uint8_t chan, uint8_t note, uint8_t vel, int len)
: m_type(Type::Control), channel(chan), noteOrCtrl(note), velOrVal(vel), length(len) {}
Event(ProgEvent, uint8_t chan, uint8_t prog) : m_type(Type::Program), channel(chan), program(prog) {}
Event(PitchEvent, uint8_t chan, int pBend) : m_type(Type::Pitch), channel(chan), pitchBend(pBend) {}
};
class MIDIDecoder {
int m_tick = 0;
std::vector<std::multimap<int, Event>> m_results[16];
std::multimap<int, int> m_tempos;
std::array<std::multimap<int, Event>::iterator, 128> m_notes[16];
int m_minLoopStart[16];
int m_minLoopEnd[16];
bool isEmptyIterator(int chan, std::multimap<int, Event>::iterator it) const {
for (const auto& res : m_results[chan])
if (res.end() == it)
return true;
return false;
}
void _addRegionChange(int chan) {
auto& results = m_results[chan];
results.reserve(2);
results.emplace_back();
if (results.size() == 1)
for (size_t i = 0; i < 128; ++i)
m_notes[chan][i] = results.back().end();
}
uint8_t m_status = 0;
bool _readContinuedValue(std::vector<uint8_t>::const_iterator& it, std::vector<uint8_t>::const_iterator end,
uint32_t& valOut) {
uint8_t a = *it++;
valOut = a & 0x7f;
if (a & 0x80) {
if (it == end)
return false;
valOut <<= 7;
a = *it++;
valOut |= a & 0x7f;
if (a & 0x80) {
if (it == end)
return false;
valOut <<= 7;
a = *it++;
valOut |= a & 0x7f;
}
}
return true;
}
public:
MIDIDecoder() {
std::fill(std::begin(m_minLoopStart), std::end(m_minLoopStart), INT_MAX);
std::fill(std::begin(m_minLoopEnd), std::end(m_minLoopEnd), INT_MAX);
}
std::vector<uint8_t>::const_iterator receiveBytes(std::vector<uint8_t>::const_iterator begin,
std::vector<uint8_t>::const_iterator end,
int loopStart[16] = nullptr, int loopEnd[16] = nullptr) {
std::vector<uint8_t>::const_iterator it = begin;
while (it != end) {
uint32_t deltaTime;
_readContinuedValue(it, end, deltaTime);
m_tick += deltaTime;
uint8_t a = *it++;
uint8_t b;
if (a & 0x80)
m_status = a;
else
it--;
if (m_status == 0xff) {
/* Meta events */
if (it == end)
break;
a = *it++;
uint32_t length;
_readContinuedValue(it, end, length);
switch (a) {
case 0x51: {
uint32_t tempo = 0;
memcpy(&reinterpret_cast<uint8_t*>(&tempo)[1], &*it, 3);
m_tempos.emplace(m_tick, 60000000 / SBig(tempo));
[[fallthrough]];
}
default:
it += length;
}
} else {
uint8_t chan = m_status & 0xf;
auto& results = m_results[chan];
if (loopEnd && loopEnd[chan] != INT_MAX && m_tick >= loopEnd[chan])
break;
/* Split region at loop start point */
if (loopStart && loopStart[chan] != INT_MAX && m_tick >= loopStart[chan]) {
_addRegionChange(chan);
loopStart[chan] = INT_MAX;
} else if (results.empty()) {
_addRegionChange(chan);
}
std::multimap<int, Event>& res = results.back();
switch (Status(m_status & 0xf0)) {
case Status::NoteOff: {
if (it == end)
break;
a = *it++;
if (it == end)
break;
b = *it++;
uint8_t notenum = clamp7(a);
std::multimap<int, Event>::iterator note = m_notes[chan][notenum];
if (!isEmptyIterator(chan, note)) {
note->second.length = m_tick - note->first;
m_notes[chan][notenum] = res.end();
}
break;
}
case Status::NoteOn: {
if (it == end)
break;
a = *it++;
if (it == end)
break;
b = *it++;
uint8_t notenum = clamp7(a);
uint8_t vel = clamp7(b);
std::multimap<int, Event>::iterator note = m_notes[chan][notenum];
if (!isEmptyIterator(chan, note))
note->second.length = m_tick - note->first;
if (vel != 0)
m_notes[chan][notenum] = res.emplace(m_tick, Event{NoteEvent{}, chan, notenum, vel, 0});
else
m_notes[chan][notenum] = res.end();
break;
}
case Status::NotePressure: {
if (it == end)
break;
a = *it++;
if (it == end)
break;
b = *it++;
break;
}
case Status::ControlChange: {
if (it == end)
break;
a = *it++;
if (it == end)
break;
b = *it++;
if (a == 0x66)
m_minLoopStart[chan] = std::min(m_tick, m_minLoopStart[chan]);
else if (a == 0x67)
m_minLoopEnd[chan] = std::min(m_tick, m_minLoopEnd[chan]);
else
res.emplace(m_tick, Event{CtrlEvent{}, chan, clamp7(a), clamp7(b), 0});
break;
}
case Status::ProgramChange: {
if (it == end)
break;
a = *it++;
res.emplace(m_tick, Event{ProgEvent{}, chan, a});
break;
}
case Status::ChannelPressure: {
if (it == end)
break;
a = *it++;
break;
}
case Status::PitchBend: {
if (it == end)
break;
a = *it++;
if (it == end)
break;
b = *it++;
res.emplace(m_tick, Event{PitchEvent{}, chan, clamp7(b) * 128 + clamp7(a)});
break;
}
case Status::SysEx: {
switch (Status(m_status & 0xff)) {
case Status::SysEx: {
uint32_t len;
if (!_readContinuedValue(it, end, len) || end - it < len)
break;
break;
}
case Status::TimecodeQuarterFrame: {
if (it == end)
break;
a = *it++;
break;
}
case Status::SongPositionPointer: {
if (it == end)
break;
a = *it++;
if (it == end)
break;
b = *it++;
break;
}
case Status::SongSelect: {
if (it == end)
break;
a = *it++;
break;
}
case Status::TuneRequest:
case Status::Start:
case Status::Continue:
case Status::Stop:
case Status::Reset:
case Status::SysExTerm:
case Status::TimingClock:
case Status::ActiveSensing:
default:
break;
}
break;
}
default:
break;
}
}
}
return it;
}
std::vector<std::multimap<int, Event>>& getResults(int chan) { return m_results[chan]; }
std::multimap<int, int>& getTempos() { return m_tempos; }
int getMinLoopStart(int chan) const { return m_minLoopStart[chan]; }
int getMinLoopEnd(int chan) const { return m_minLoopEnd[chan]; }
};
class MIDIEncoder {
friend class SongConverter;
std::vector<uint8_t> m_result;
uint8_t m_status = 0;
void _sendMessage(const uint8_t* data, size_t len) {
if (data[0] == m_status) {
for (size_t i = 1; i < len; ++i)
m_result.push_back(data[i]);
} else {
if (data[0] & 0x80)
m_status = data[0];
for (size_t i = 0; i < len; ++i)
m_result.push_back(data[i]);
}
}
void _sendContinuedValue(uint32_t val) {
uint8_t send[3] = {};
uint8_t* ptr = nullptr;
if (val >= 0x4000) {
ptr = &send[0];
send[0] = 0x80 | ((val / 0x4000) & 0x7f);
send[1] = 0x80;
val &= 0x3fff;
}
if (val >= 0x80) {
if (!ptr)
ptr = &send[1];
send[1] = 0x80 | ((val / 0x80) & 0x7f);
}
if (!ptr)
ptr = &send[2];
send[2] = val & 0x7f;
size_t len = 3 - (ptr - send);
for (size_t i = 0; i < len; ++i)
m_result.push_back(ptr[i]);
}
public:
void noteOff(uint8_t chan, uint8_t key, uint8_t velocity) {
uint8_t cmd[3] = {uint8_t(int(Status::NoteOff) | (chan & 0xf)), uint8_t(key & 0x7f), uint8_t(velocity & 0x7f)};
_sendMessage(cmd, 3);
}
void noteOn(uint8_t chan, uint8_t key, uint8_t velocity) {
uint8_t cmd[3] = {uint8_t(int(Status::NoteOn) | (chan & 0xf)), uint8_t(key & 0x7f), uint8_t(velocity & 0x7f)};
_sendMessage(cmd, 3);
}
void notePressure(uint8_t chan, uint8_t key, uint8_t pressure) {
uint8_t cmd[3] = {uint8_t(int(Status::NotePressure) | (chan & 0xf)), uint8_t(key & 0x7f), uint8_t(pressure & 0x7f)};
_sendMessage(cmd, 3);
}
void controlChange(uint8_t chan, uint8_t control, uint8_t value) {
uint8_t cmd[3] = {uint8_t(int(Status::ControlChange) | (chan & 0xf)), uint8_t(control & 0x7f),
uint8_t(value & 0x7f)};
_sendMessage(cmd, 3);
}
void programChange(uint8_t chan, uint8_t program) {
uint8_t cmd[2] = {uint8_t(int(Status::ProgramChange) | (chan & 0xf)), uint8_t(program & 0x7f)};
_sendMessage(cmd, 2);
}
void channelPressure(uint8_t chan, uint8_t pressure) {
uint8_t cmd[2] = {uint8_t(int(Status::ChannelPressure) | (chan & 0xf)), uint8_t(pressure & 0x7f)};
_sendMessage(cmd, 2);
}
void pitchBend(uint8_t chan, int16_t pitch) {
uint8_t cmd[3] = {uint8_t(int(Status::PitchBend) | (chan & 0xf)), uint8_t((pitch % 128) & 0x7f),
uint8_t((pitch / 128) & 0x7f)};
_sendMessage(cmd, 3);
}
void allSoundOff(uint8_t chan) {
uint8_t cmd[3] = {uint8_t(int(Status::ControlChange) | (chan & 0xf)), 120, 0};
_sendMessage(cmd, 3);
}
void resetAllControllers(uint8_t chan) {
uint8_t cmd[3] = {uint8_t(int(Status::ControlChange) | (chan & 0xf)), 121, 0};
_sendMessage(cmd, 3);
}
void localControl(uint8_t chan, bool on) {
uint8_t cmd[3] = {uint8_t(int(Status::ControlChange) | (chan & 0xf)), 122, uint8_t(on ? 127 : 0)};
_sendMessage(cmd, 3);
}
void allNotesOff(uint8_t chan) {
uint8_t cmd[3] = {uint8_t(int(Status::ControlChange) | (chan & 0xf)), 123, 0};
_sendMessage(cmd, 3);
}
void omniMode(uint8_t chan, bool on) {
uint8_t cmd[3] = {uint8_t(int(Status::ControlChange) | (chan & 0xf)), uint8_t(on ? 125 : 124), 0};
_sendMessage(cmd, 3);
}
void polyMode(uint8_t chan, bool on) {
uint8_t cmd[3] = {uint8_t(int(Status::ControlChange) | (chan & 0xf)), uint8_t(on ? 127 : 126), 0};
_sendMessage(cmd, 3);
}
void sysex(const void* data, size_t len) {
uint8_t cmd = uint8_t(Status::SysEx);
_sendMessage(&cmd, 1);
_sendContinuedValue(len);
for (size_t i = 0; i < len; ++i)
m_result.push_back(reinterpret_cast<const uint8_t*>(data)[i]);
cmd = uint8_t(Status::SysExTerm);
_sendMessage(&cmd, 1);
}
void timeCodeQuarterFrame(uint8_t message, uint8_t value) {
uint8_t cmd[2] = {uint8_t(int(Status::TimecodeQuarterFrame)), uint8_t((message & 0x7 << 4) | (value & 0xf))};
_sendMessage(cmd, 2);
}
void songPositionPointer(uint16_t pointer) {
uint8_t cmd[3] = {uint8_t(int(Status::SongPositionPointer)), uint8_t((pointer % 128) & 0x7f),
uint8_t((pointer / 128) & 0x7f)};
_sendMessage(cmd, 3);
}
void songSelect(uint8_t song) {
uint8_t cmd[2] = {uint8_t(int(Status::TimecodeQuarterFrame)), uint8_t(song & 0x7f)};
_sendMessage(cmd, 2);
}
void tuneRequest() {
uint8_t cmd = uint8_t(Status::TuneRequest);
_sendMessage(&cmd, 1);
}
void startSeq() {
uint8_t cmd = uint8_t(Status::Start);
_sendMessage(&cmd, 1);
}
void continueSeq() {
uint8_t cmd = uint8_t(Status::Continue);
_sendMessage(&cmd, 1);
}
void stopSeq() {
uint8_t cmd = uint8_t(Status::Stop);
_sendMessage(&cmd, 1);
}
void reset() {
uint8_t cmd = uint8_t(Status::Reset);
_sendMessage(&cmd, 1);
}
const std::vector<uint8_t>& getResult() const { return m_result; }
std::vector<uint8_t>& getResult() { return m_result; }
};
static uint16_t DecodeUnsignedValue(const unsigned char*& data) {
uint16_t ret;
if (data[0] & 0x80) {
ret = data[1] | ((data[0] & 0x7f) << 8);
data += 2;
} else {
ret = data[0];
data += 1;
}
return ret;
}
static void EncodeUnsignedValue(std::vector<uint8_t>& vecOut, uint16_t val) {
if (val >= 128) {
vecOut.push_back(0x80 | ((val >> 8) & 0x7f));
vecOut.push_back(val & 0xff);
} else {
vecOut.push_back(val & 0x7f);
}
}
static int16_t DecodeSignedValue(const unsigned char*& data) {
int16_t ret;
if (data[0] & 0x80) {
ret = data[1] | ((data[0] & 0x7f) << 8);
ret |= ((ret << 1) & 0x8000);
data += 2;
} else {
ret = int8_t(data[0] | ((data[0] << 1) & 0x80));
data += 1;
}
return ret;
}
static void EncodeSignedValue(std::vector<uint8_t>& vecOut, int16_t val) {
if (val >= 64 || val < -64) {
vecOut.push_back(0x80 | ((val >> 8) & 0x7f));
vecOut.push_back(val & 0xff);
} else {
vecOut.push_back(val & 0x7f);
}
}
static std::pair<uint32_t, int32_t> DecodeDelta(const unsigned char*& data) {
std::pair<uint32_t, int32_t> ret = {};
do {
if (data[0] == 0x80 && data[1] == 0x00)
break;
ret.first += DecodeUnsignedValue(data);
ret.second = DecodeSignedValue(data);
} while (ret.second == 0);
return ret;
}
static void EncodeDelta(std::vector<uint8_t>& vecOut, uint32_t deltaTime, int32_t val) {
while (deltaTime > 32767) {
EncodeUnsignedValue(vecOut, 32767);
EncodeSignedValue(vecOut, 0);
deltaTime -= 32767;
}
EncodeUnsignedValue(vecOut, deltaTime);
EncodeSignedValue(vecOut, val);
}
static uint32_t DecodeTime(const unsigned char*& data) {
uint32_t ret = 0;
while (true) {
uint16_t thisPart = SBig(*reinterpret_cast<const uint16_t*>(data));
uint16_t nextPart = *reinterpret_cast<const uint16_t*>(data + 2);
if (nextPart == 0) {
// Automatically consume no-op command as continued time
ret += thisPart;
data += 4;
continue;
}
ret += thisPart;
data += 2;
break;
}
return ret;
}
static void EncodeTime(std::vector<uint8_t>& vecOut, uint32_t val) {
while (val >= 65535) {
// Automatically emit no-op command as continued time
vecOut.push_back(0xff);
vecOut.push_back(0xff);
vecOut.push_back(0);
vecOut.push_back(0);
val -= 65535;
}
uint16_t lastPart = SBig(uint16_t(val));
vecOut.push_back(reinterpret_cast<const uint8_t*>(&lastPart)[0]);
vecOut.push_back(reinterpret_cast<const uint8_t*>(&lastPart)[1]);
}
std::vector<uint8_t> SongConverter::SongToMIDI(const unsigned char* data, int& versionOut, bool& isBig) {
std::vector<uint8_t> ret = {'M', 'T', 'h', 'd'};
uint32_t six32 = SBig(uint32_t(6));
for (int i = 0; i < 4; ++i)
ret.push_back(reinterpret_cast<uint8_t*>(&six32)[i]);
ret.push_back(0);
ret.push_back(1);
SongState song;
if (!song.initialize(data, false))
return {};
versionOut = song.m_sngVersion;
isBig = song.m_bigEndian;
size_t trkCount = 1;
for (SongState::Track& trk : song.m_tracks)
if (trk)
++trkCount;
uint16_t trkCount16 = SBig(uint16_t(trkCount));
ret.push_back(reinterpret_cast<uint8_t*>(&trkCount16)[0]);
ret.push_back(reinterpret_cast<uint8_t*>(&trkCount16)[1]);
uint16_t tickDiv16 = SBig(uint16_t(384));
ret.push_back(reinterpret_cast<uint8_t*>(&tickDiv16)[0]);
ret.push_back(reinterpret_cast<uint8_t*>(&tickDiv16)[1]);
/* Write tempo track */
{
MIDIEncoder encoder;
/* Initial tempo */
encoder._sendContinuedValue(0);
encoder.getResult().push_back(0xff);
encoder.getResult().push_back(0x51);
encoder.getResult().push_back(3);
const uint32_t initialTempo24 = SBig(60000000 / (song.m_header.m_initialTempo & 0x7fffffff));
for (size_t i = 1; i < 4; ++i) {
encoder.getResult().push_back(reinterpret_cast<const uint8_t*>(&initialTempo24)[i]);
}
/* Write out tempo changes */
int lastTick = 0;
const SongState::TempoChange* tempoPtr = nullptr;
if (song.m_header.m_tempoTableOff)
tempoPtr = reinterpret_cast<const SongState::TempoChange*>(song.m_songData + song.m_header.m_tempoTableOff);
while (tempoPtr && tempoPtr->m_tick != 0xffffffff) {
SongState::TempoChange change = *tempoPtr;
if (song.m_bigEndian)
change.swapBig();
encoder._sendContinuedValue(change.m_tick - lastTick);
lastTick = change.m_tick;
encoder.getResult().push_back(0xff);
encoder.getResult().push_back(0x51);
encoder.getResult().push_back(3);
const uint32_t tempo24 = SBig(60000000 / (change.m_tempo & 0x7fffffff));
for (size_t i = 1; i < 4; ++i) {
encoder.getResult().push_back(reinterpret_cast<const uint8_t*>(&tempo24)[i]);
}
++tempoPtr;
}
encoder.getResult().push_back(0);
encoder.getResult().push_back(0xff);
encoder.getResult().push_back(0x2f);
encoder.getResult().push_back(0);
ret.push_back('M');
ret.push_back('T');
ret.push_back('r');
ret.push_back('k');
uint32_t trkSz = SBig(uint32_t(encoder.getResult().size()));
for (int i = 0; i < 4; ++i)
ret.push_back(reinterpret_cast<uint8_t*>(&trkSz)[i]);
ret.insert(ret.cend(), encoder.getResult().begin(), encoder.getResult().end());
}
bool loopsAdded = false;
/* Iterate each SNG track into type-1 MIDI track */
for (SongState::Track& trk : song.m_tracks) {
if (trk) {
MIDIEncoder encoder;
std::multimap<int, Event> allEvents;
/* Iterate all regions */
while (trk.m_nextRegion->indexValid(song.m_bigEndian)) {
std::multimap<int, Event> events;
trk.advanceRegion();
uint32_t regStart = song.m_bigEndian ? SBig(trk.m_curRegion->m_startTick) : trk.m_curRegion->m_startTick;
/* Initial program change */
if (trk.m_curRegion->m_progNum != 0xff)
events.emplace(regStart, Event{ProgEvent{}, trk.m_midiChan, trk.m_curRegion->m_progNum});
/* Update continuous pitch data */
if (trk.m_pitchWheelData) {
while (true) {
/* Update pitch */
trk.m_pitchVal += trk.m_nextPitchDelta;
events.emplace(regStart + trk.m_nextPitchTick,
Event{PitchEvent{}, trk.m_midiChan, clamp(0, trk.m_pitchVal + 0x2000, 0x4000)});
if (trk.m_pitchWheelData[0] != 0x80 || trk.m_pitchWheelData[1] != 0x00) {
auto delta = DecodeDelta(trk.m_pitchWheelData);
trk.m_nextPitchTick += delta.first;
trk.m_nextPitchDelta = delta.second;
} else {
break;
}
}
}
/* Update continuous modulation data */
if (trk.m_modWheelData) {
while (true) {
/* Update modulation */
trk.m_modVal += trk.m_nextModDelta;
events.emplace(regStart + trk.m_nextModTick,
Event{CtrlEvent{}, trk.m_midiChan, 1, uint8_t(clamp(0, trk.m_modVal / 128, 127)), 0});
if (trk.m_modWheelData[0] != 0x80 || trk.m_modWheelData[1] != 0x00) {
auto delta = DecodeDelta(trk.m_modWheelData);
trk.m_nextModTick += delta.first;
trk.m_nextModDelta = delta.second;
} else {
break;
}
}
}
/* Loop through as many commands as we can for this time period */
if (song.m_sngVersion == 1) {
/* Revision */
while (true) {
/* Load next command */
if (*reinterpret_cast<const uint16_t*>(trk.m_data) == 0xffff) {
/* End of channel */
trk.m_data = nullptr;
break;
} else if (trk.m_data[0] & 0x80 && trk.m_data[1] & 0x80) {
/* Control change */
uint8_t val = trk.m_data[0] & 0x7f;
uint8_t ctrl = trk.m_data[1] & 0x7f;
events.emplace(regStart + trk.m_eventWaitCountdown, Event{CtrlEvent{}, trk.m_midiChan, ctrl, val, 0});
trk.m_data += 2;
} else if (trk.m_data[0] & 0x80) {
/* Program change */
uint8_t prog = trk.m_data[0] & 0x7f;
events.emplace(regStart + trk.m_eventWaitCountdown, Event{ProgEvent{}, trk.m_midiChan, prog});
trk.m_data += 2;
} else {
/* Note */
uint8_t note = trk.m_data[0] & 0x7f;
uint8_t vel = trk.m_data[1] & 0x7f;
uint16_t length = (song.m_bigEndian ? SBig(*reinterpret_cast<const uint16_t*>(trk.m_data + 2))
: *reinterpret_cast<const uint16_t*>(trk.m_data + 2));
events.emplace(regStart + trk.m_eventWaitCountdown,
Event{NoteEvent{}, trk.m_midiChan, note, vel, length});
trk.m_data += 4;
}
/* Set next delta-time */
trk.m_eventWaitCountdown += int32_t(DecodeTime(trk.m_data));
}
} else {
/* Legacy */
while (true) {
/* Load next command */
if (*reinterpret_cast<const uint16_t*>(&trk.m_data[2]) == 0xffff) {
/* End of channel */
trk.m_data = nullptr;
break;
} else {
if ((trk.m_data[2] & 0x80) != 0x80) {
/* Note */
uint16_t length = (song.m_bigEndian ? SBig(*reinterpret_cast<const uint16_t*>(trk.m_data))
: *reinterpret_cast<const uint16_t*>(trk.m_data));
uint8_t note = trk.m_data[2] & 0x7f;
uint8_t vel = trk.m_data[3] & 0x7f;
events.emplace(regStart + trk.m_eventWaitCountdown,
Event{NoteEvent{}, trk.m_midiChan, note, vel, length});
} else if (trk.m_data[2] & 0x80 && trk.m_data[3] & 0x80) {
/* Control change */
uint8_t val = trk.m_data[2] & 0x7f;
uint8_t ctrl = trk.m_data[3] & 0x7f;
events.emplace(regStart + trk.m_eventWaitCountdown, Event{CtrlEvent{}, trk.m_midiChan, ctrl, val, 0});
} else if (trk.m_data[2] & 0x80) {
/* Program change */
uint8_t prog = trk.m_data[2] & 0x7f;
events.emplace(regStart + trk.m_eventWaitCountdown, Event{ProgEvent{}, trk.m_midiChan, prog});
}
trk.m_data += 4;
}
/* Set next delta-time */
int32_t absTick = (song.m_bigEndian ? SBig(*reinterpret_cast<const int32_t*>(trk.m_data))
: *reinterpret_cast<const int32_t*>(trk.m_data));
trk.m_eventWaitCountdown += absTick - trk.m_lastN64EventTick;
trk.m_lastN64EventTick = absTick;
trk.m_data += 4;
}
}
/* Merge events */
allEvents.insert(events.begin(), events.end());
/* Resolve key-off events */
for (auto& pair : events) {
if (pair.second.m_type == Event::Type::Note) {
auto it = allEvents.emplace(pair.first + pair.second.length, pair.second);
it->second.endEvent = true;
}
}
}
/* Add loop events */
if (!loopsAdded && trk.m_nextRegion->indexLoop(song.m_bigEndian) != -1) {
uint32_t loopEnd = song.m_bigEndian ? SBig(trk.m_nextRegion->m_startTick) : trk.m_nextRegion->m_startTick;
allEvents.emplace(trk.m_loopStartTick, Event{CtrlEvent{}, trk.m_midiChan, 0x66, 0, 0});
allEvents.emplace(loopEnd, Event{CtrlEvent{}, trk.m_midiChan, 0x67, 0, 0});
if (!(song.m_header.m_initialTempo & 0x80000000))
loopsAdded = true;
}
/* Emit MIDI events */
int lastTime = 0;
for (auto& pair : allEvents) {
encoder._sendContinuedValue(pair.first - lastTime);
lastTime = pair.first;
switch (pair.second.m_type) {
case Event::Type::Control:
encoder.controlChange(pair.second.channel, pair.second.noteOrCtrl, pair.second.velOrVal);
break;
case Event::Type::Program:
encoder.programChange(trk.m_midiChan, pair.second.program);
break;
case Event::Type::Pitch:
encoder.pitchBend(trk.m_midiChan, pair.second.pitchBend);
break;
case Event::Type::Note:
if (pair.second.endEvent)
encoder.noteOff(pair.second.channel, pair.second.noteOrCtrl, pair.second.velOrVal);
else
encoder.noteOn(pair.second.channel, pair.second.noteOrCtrl, pair.second.velOrVal);
break;
}
}
encoder.getResult().push_back(0);
encoder.getResult().push_back(0xff);
encoder.getResult().push_back(0x2f);
encoder.getResult().push_back(0);
/* Write out */
ret.push_back('M');
ret.push_back('T');
ret.push_back('r');
ret.push_back('k');
uint32_t trkSz = SBig(uint32_t(encoder.getResult().size()));
for (int i = 0; i < 4; ++i)
ret.push_back(reinterpret_cast<uint8_t*>(&trkSz)[i]);
ret.insert(ret.cend(), encoder.getResult().begin(), encoder.getResult().end());
}
}
return ret;
}
std::vector<uint8_t> SongConverter::MIDIToSong(const std::vector<uint8_t>& data, int version, bool big) {
std::vector<uint8_t> ret;
std::vector<uint8_t>::const_iterator it = data.cbegin();
struct MIDIHeader {
char magic[4];
uint32_t length;
uint16_t type;
uint16_t count;
uint16_t div;
void swapBig() {
length = SBig(length);
type = SBig(type);
count = SBig(count);
div = SBig(div);
}
};
MIDIHeader header = *reinterpret_cast<const MIDIHeader*>(&*it);
header.swapBig();
it += 8 + header.length;
if (memcmp(header.magic, "MThd", 4))
return {};
/* Only Type 0 and 1 MIDI files supported as input */
if (header.type == 0)
header.count = 1;
else if (header.type != 1)
return {};
std::vector<uint32_t> trackRegionIdxArr;
std::vector<uint32_t> regionDataIdxArr;
std::vector<SongState::TrackRegion> regionBuf;
uint32_t initTempo = 120;
std::vector<std::pair<uint32_t, uint32_t>> tempoBuf;
std::array<uint8_t, 64> chanMap;
for (int i = 0; i < 64; ++i)
chanMap[i] = 0xff;
struct Region {
std::vector<uint8_t> eventBuf;
std::vector<uint8_t> pitchBuf;
std::vector<uint8_t> modBuf;
int padding = 0;
bool operator==(const Region& other) const {
if (eventBuf.size() != other.eventBuf.size())
return false;
if (pitchBuf.size() != other.pitchBuf.size())
return false;
if (modBuf.size() != other.modBuf.size())
return false;
if (eventBuf.size() && memcmp(eventBuf.data(), other.eventBuf.data(), eventBuf.size()))
return false;
if (pitchBuf.size() && memcmp(pitchBuf.data(), other.pitchBuf.data(), pitchBuf.size()))
return false;
if (modBuf.size() && memcmp(modBuf.data(), other.modBuf.data(), modBuf.size()))
return false;
return true;
}
};
std::vector<Region> regions;
int curRegionOff = 0;
/* Pre-iterate to extract loop events */
int loopStart[16];
int loopEnd[16];
int loopChanCount = 0;
{
int loopChanIdx = -1;
for (int c = 0; c < 16; ++c) {
loopStart[c] = INT_MAX;
loopEnd[c] = INT_MAX;
std::vector<uint8_t>::const_iterator tmpIt = it;
for (int i = 0; i < header.count; ++i) {
if (memcmp(&*tmpIt, "MTrk", 4))
return {};
tmpIt += 4;
uint32_t length = SBig(*reinterpret_cast<const uint32_t*>(&*tmpIt));
tmpIt += 4;
std::vector<uint8_t>::const_iterator begin = tmpIt;
std::vector<uint8_t>::const_iterator end = tmpIt + length;
tmpIt = end;
MIDIDecoder dec;
dec.receiveBytes(begin, end);
loopStart[c] = std::min(dec.getMinLoopStart(c), loopStart[c]);
loopEnd[c] = std::min(dec.getMinLoopEnd(c), loopEnd[c]);
}
if (loopStart[c] == INT_MAX || loopEnd[c] == INT_MAX) {
loopStart[c] = INT_MAX;
loopEnd[c] = INT_MAX;
} else {
++loopChanCount;
loopChanIdx = c;
}
}
if (loopChanCount == 1) {
for (int c = 0; c < 16; ++c) {
loopStart[c] = loopStart[loopChanIdx];
loopEnd[c] = loopEnd[loopChanIdx];
}
}
}
for (int i = 0; i < header.count; ++i) {
if (memcmp(&*it, "MTrk", 4))
return {};
it += 4;
uint32_t length = SBig(*reinterpret_cast<const uint32_t*>(&*it));
it += 4;
if (i == 0) {
/* Extract tempo events from first track */
std::vector<uint8_t>::const_iterator begin = it;
std::vector<uint8_t>::const_iterator end = it + length;
MIDIDecoder dec;
dec.receiveBytes(begin, end);
std::multimap<int, int>& tempos = dec.getTempos();
if (tempos.size() == 1)
initTempo = tempos.begin()->second;
else if (tempos.size() > 1) {
auto iter = tempos.begin();
initTempo = iter->second;
++iter;
for (auto& pair : tempos) {
if (big)
tempoBuf.emplace_back(SBig(uint32_t(pair.first * 384 / header.div)), SBig(uint32_t(pair.second)));
else
tempoBuf.emplace_back(pair.first * 384 / header.div, pair.second);
}
}
if (header.type == 1) {
it = end;
continue;
}
}
/* Extract channel events */
std::vector<uint8_t>::const_iterator begin = it;
std::vector<uint8_t>::const_iterator end = it + length;
it = end;
MIDIDecoder dec;
int tmpLoopStart[16];
int tmpLoopEnd[16];
std::copy(std::begin(loopStart), std::end(loopStart), std::begin(tmpLoopStart));
std::copy(std::begin(loopEnd), std::end(loopEnd), std::begin(tmpLoopEnd));
dec.receiveBytes(begin, end, tmpLoopStart, tmpLoopEnd);
for (int c = 0; c < 16; ++c) {
std::vector<std::multimap<int, Event>>& results = dec.getResults(c);
bool didChanInit = false;
int lastEventTick = 0;
for (auto& chanRegion : results) {
bool didInit = false;
int startTick = 0;
lastEventTick = 0;
int lastPitchTick = 0;
int lastPitchVal = 0;
int lastModTick = 0;
int lastModVal = 0;
Region region;
for (auto& event : chanRegion) {
uint32_t eventTick = event.first * 384 / header.div;
if (event.second.channel == c) {
if (!didInit) {
didInit = true;
startTick = eventTick;
lastEventTick = startTick;
lastPitchTick = startTick;
lastPitchVal = 0;
lastModTick = startTick;
lastModVal = 0;
}
switch (event.second.m_type) {
case Event::Type::Control: {
if (event.second.noteOrCtrl == 1) {
int newMod = event.second.velOrVal * 128;
EncodeDelta(region.modBuf, eventTick - lastModTick, newMod - lastModVal);
lastModTick = eventTick;
lastModVal = newMod;
} else {
if (version == 1) {
EncodeTime(region.eventBuf, uint32_t(eventTick - lastEventTick));
lastEventTick = eventTick;
region.eventBuf.push_back(0x80 | event.second.velOrVal);
region.eventBuf.push_back(0x80 | event.second.noteOrCtrl);
} else {
if (big) {
const uint32_t tickBig = SBig(uint32_t(eventTick - startTick));
for (size_t j = 0; j < 4; ++j) {
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tickBig)[j]);
}
region.eventBuf.push_back(0x80 | event.second.velOrVal);
region.eventBuf.push_back(0x80 | event.second.noteOrCtrl);
} else {
const uint32_t tick = uint32_t(eventTick - startTick);
for (size_t j = 0; j < 4; ++j) {
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tick)[j]);
}
region.eventBuf.push_back(0x80 | event.second.velOrVal);
region.eventBuf.push_back(0x80 | event.second.noteOrCtrl);
}
}
}
break;
}
case Event::Type::Program: {
if (version == 1) {
EncodeTime(region.eventBuf, uint32_t(eventTick - lastEventTick));
lastEventTick = eventTick;
region.eventBuf.push_back(0x80 | event.second.program);
region.eventBuf.push_back(0);
} else {
if (big) {
const uint32_t tickBig = SBig(uint32_t(eventTick - startTick));
for (size_t j = 0; j < 4; ++j) {
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tickBig)[j]);
}
region.eventBuf.push_back(0x80 | event.second.program);
region.eventBuf.push_back(0);
} else {
const uint32_t tick = uint32_t(eventTick - startTick);
for (size_t j = 0; j < 4; ++j) {
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tick)[j]);
}
region.eventBuf.push_back(0x80 | event.second.program);
region.eventBuf.push_back(0);
}
}
break;
}
case Event::Type::Pitch: {
int newPitch = event.second.pitchBend - 0x2000;
EncodeDelta(region.pitchBuf, eventTick - lastPitchTick, newPitch - lastPitchVal);
lastPitchTick = eventTick;
lastPitchVal = newPitch;
break;
}
case Event::Type::Note: {
int lenTicks = event.second.length * 384 / header.div;
if (version == 1) {
EncodeTime(region.eventBuf, uint32_t(eventTick - lastEventTick));
lastEventTick = eventTick;
region.eventBuf.push_back(event.second.noteOrCtrl);
region.eventBuf.push_back(event.second.velOrVal);
const uint16_t lenBig = SBig(uint16_t(lenTicks));
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&lenBig)[0]);
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&lenBig)[1]);
} else {
if (big) {
const uint32_t tickBig = SBig(uint32_t(eventTick - startTick));
for (size_t j = 0; j < 4; ++j) {
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tickBig)[j]);
}
const uint16_t lenBig = SBig(uint16_t(lenTicks));
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&lenBig)[0]);
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&lenBig)[1]);
region.eventBuf.push_back(event.second.noteOrCtrl);
region.eventBuf.push_back(event.second.velOrVal);
} else {
const uint32_t tick = uint32_t(eventTick - startTick);
for (size_t j = 0; j < 4; ++j) {
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tick)[j]);
}
const uint16_t len = uint16_t(lenTicks);
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&len)[0]);
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&len)[1]);
region.eventBuf.push_back(event.second.noteOrCtrl);
region.eventBuf.push_back(event.second.velOrVal);
}
}
break;
}
}
}
}
if (didInit) {
if (!didChanInit) {
didChanInit = true;
if (trackRegionIdxArr.size() == 64)
return {};
chanMap[trackRegionIdxArr.size()] = c;
trackRegionIdxArr.push_back(regionBuf.size());
}
/* Terminate region */
if (version == 1) {
size_t pitchDelta = 0;
size_t modDelta = 0;
if (lastPitchTick > lastEventTick)
pitchDelta = lastPitchTick - lastEventTick;
if (lastModTick > lastEventTick)
modDelta = lastModTick - lastEventTick;
EncodeTime(region.eventBuf, std::max(pitchDelta, modDelta));
region.eventBuf.push_back(0xff);
region.eventBuf.push_back(0xff);
} else {
if (big) {
const uint32_t selTick =
std::max(std::max(lastEventTick - startTick, lastPitchTick - startTick), lastModTick - startTick);
const uint32_t tickBig = SBig(uint32_t(selTick));
for (size_t j = 0; j < 4; ++j) {
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tickBig)[j]);
}
region.eventBuf.push_back(0);
region.eventBuf.push_back(0);
region.eventBuf.push_back(0xff);
region.eventBuf.push_back(0xff);
} else {
const uint32_t selTick =
std::max(std::max(lastEventTick - startTick, lastPitchTick - startTick), lastModTick - startTick);
const uint32_t tick = uint32_t(selTick);
for (size_t j = 0; j < 4; ++j) {
region.eventBuf.push_back(reinterpret_cast<const uint8_t*>(&tick)[j]);
}
region.eventBuf.push_back(0);
region.eventBuf.push_back(0);
region.eventBuf.push_back(0xff);
region.eventBuf.push_back(0xff);
}
}
if (region.pitchBuf.size()) {
region.pitchBuf.push_back(0x80);
region.pitchBuf.push_back(0);
}
if (region.modBuf.size()) {
region.modBuf.push_back(0x80);
region.modBuf.push_back(0);
}
/* See if there's a matching region buffer already present */
size_t regIdx = 0;
for (Region& reg : regions) {
if (reg == region)
break;
++regIdx;
}
if (regIdx == regions.size()) {
regionDataIdxArr.push_back(curRegionOff);
curRegionOff += 12 + region.eventBuf.size() + region.pitchBuf.size() + region.modBuf.size();
int paddedRegOff = ((curRegionOff + 3) & ~3);
region.padding = paddedRegOff - curRegionOff;
curRegionOff = paddedRegOff;
regions.push_back(std::move(region));
}
/* Region header */
regionBuf.emplace_back();
SongState::TrackRegion& reg = regionBuf.back();
if (big) {
reg.m_startTick = SBig(uint32_t(startTick));
reg.m_progNum = 0xff;
reg.m_unk1 = 0xff;
reg.m_unk2 = 0;
reg.m_regionIndex = SBig(uint16_t(regIdx));
reg.m_loopToRegion = 0;
} else {
reg.m_startTick = uint32_t(startTick);
reg.m_progNum = 0xff;
reg.m_unk1 = 0xff;
reg.m_unk2 = 0;
reg.m_regionIndex = uint16_t(regIdx);
reg.m_loopToRegion = 0;
}
}
}
if (didChanInit) {
/* Terminating region header */
regionBuf.emplace_back();
SongState::TrackRegion& reg = regionBuf.back();
uint32_t termStartTick = 0;
int16_t termRegionIdx = -1;
int16_t termLoopToRegion = 0;
if (loopEnd[c] != INT_MAX) {
termStartTick = loopEnd[c];
if (lastEventTick >= loopStart[c]) {
termRegionIdx = -2;
termLoopToRegion = results.size() - 1;
}
}
if (big) {
reg.m_startTick = SBig(termStartTick);
reg.m_progNum = 0xff;
reg.m_unk1 = 0xff;
reg.m_unk2 = 0;
reg.m_regionIndex = SBig(termRegionIdx);
reg.m_loopToRegion = SBig(termLoopToRegion);
} else {
reg.m_startTick = termStartTick;
reg.m_progNum = 0xff;
reg.m_unk1 = 0xff;
reg.m_unk2 = 0;
reg.m_regionIndex = termRegionIdx;
reg.m_loopToRegion = termLoopToRegion;
}
}
}
}
if (version == 1) {
SongState::Header head;
head.m_initialTempo = initTempo;
head.m_loopStartTicks[0] = 0;
if (loopChanCount == 1) {
head.m_loopStartTicks[0] = loopStart[0] == INT_MAX ? 0 : loopStart[0];
} else if (loopChanCount > 1) {
for (int i = 0; i < 16; ++i)
head.m_loopStartTicks[i] = loopStart[i] == INT_MAX ? 0 : loopStart[i];
head.m_initialTempo |= 0x80000000;
}
size_t headSz = (head.m_initialTempo & 0x80000000) ? 0x58 : 0x18;
head.m_trackIdxOff = headSz;
head.m_regionIdxOff = headSz + 4 * 64 + regionBuf.size() * 12;
head.m_chanMapOff = head.m_regionIdxOff + 4 * regionDataIdxArr.size() + curRegionOff;
head.m_tempoTableOff = tempoBuf.size() ? head.m_chanMapOff + 64 : 0;
head.m_chanMapOff2 = head.m_chanMapOff;
uint32_t regIdxOff = head.m_regionIdxOff;
if (big)
head.swapToBig();
*reinterpret_cast<SongState::Header*>(&*ret.insert(ret.cend(), headSz, 0)) = head;
for (size_t i = 0; i < 64; ++i) {
if (i >= trackRegionIdxArr.size()) {
ret.insert(ret.cend(), 4, 0);
continue;
}
uint32_t idx = trackRegionIdxArr[i];
*reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
big ? SBig(uint32_t(headSz + 4 * 64 + idx * 12)) : uint32_t(headSz + 4 * 64 + idx * 12);
}
for (SongState::TrackRegion& reg : regionBuf)
*reinterpret_cast<SongState::TrackRegion*>(&*ret.insert(ret.cend(), 12, 0)) = reg;
uint32_t regBase = regIdxOff + 4 * regionDataIdxArr.size();
for (uint32_t regOff : regionDataIdxArr)
*reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
big ? SBig(uint32_t(regBase + regOff)) : uint32_t(regBase + regOff);
uint32_t curOffset = regBase;
for (Region& reg : regions) {
*reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = big ? SBig(uint32_t(8)) : 8;
if (reg.pitchBuf.size())
*reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
big ? SBig(uint32_t(curOffset + 12 + reg.eventBuf.size())) : uint32_t(curOffset + 12 + reg.eventBuf.size());
else
ret.insert(ret.cend(), 4, 0);
if (reg.modBuf.size())
*reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
big ? SBig(uint32_t(curOffset + 12 + reg.eventBuf.size() + reg.pitchBuf.size()))
: uint32_t(curOffset + 12 + reg.eventBuf.size() + reg.pitchBuf.size());
else
ret.insert(ret.cend(), 4, 0);
if (reg.eventBuf.size())
memmove(&*ret.insert(ret.cend(), reg.eventBuf.size(), 0), reg.eventBuf.data(), reg.eventBuf.size());
if (reg.pitchBuf.size())
memmove(&*ret.insert(ret.cend(), reg.pitchBuf.size(), 0), reg.pitchBuf.data(), reg.pitchBuf.size());
if (reg.modBuf.size())
memmove(&*ret.insert(ret.cend(), reg.modBuf.size(), 0), reg.modBuf.data(), reg.modBuf.size());
ret.insert(ret.cend(), reg.padding, 0);
curOffset += 12 + reg.eventBuf.size() + reg.pitchBuf.size() + reg.modBuf.size() + reg.padding;
}
memmove(&*ret.insert(ret.cend(), 64, 0), chanMap.data(), 64);
if (tempoBuf.size())
memmove(&*ret.insert(ret.cend(), tempoBuf.size() * 8, 0), tempoBuf.data(), tempoBuf.size() * 8);
*reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = uint32_t(0xffffffff);
} else {
SongState::Header head;
head.m_initialTempo = initTempo;
head.m_loopStartTicks[0] = 0;
if (loopChanCount == 1) {
head.m_loopStartTicks[0] = loopStart[0] == INT_MAX ? 0 : loopStart[0];
} else if (loopChanCount > 1) {
for (int i = 0; i < 16; ++i)
head.m_loopStartTicks[i] = loopStart[i] == INT_MAX ? 0 : loopStart[i];
head.m_initialTempo |= 0x80000000;
}
size_t headSz = (head.m_initialTempo & 0x80000000) ? 0x58 : 0x18;
head.m_trackIdxOff = headSz + regionBuf.size() * 12;
head.m_regionIdxOff = head.m_trackIdxOff + 4 * 64 + 64 + curRegionOff;
head.m_chanMapOff = head.m_trackIdxOff + 4 * 64;
head.m_tempoTableOff = tempoBuf.size() ? head.m_regionIdxOff + 4 * regionDataIdxArr.size() : 0;
head.m_chanMapOff2 = head.m_chanMapOff;
uint32_t chanMapOff = head.m_chanMapOff;
if (big)
head.swapToBig();
*reinterpret_cast<SongState::Header*>(&*ret.insert(ret.cend(), headSz, 0)) = head;
for (SongState::TrackRegion& reg : regionBuf)
*reinterpret_cast<SongState::TrackRegion*>(&*ret.insert(ret.cend(), 12, 0)) = reg;
for (size_t i = 0; i < 64; ++i) {
if (i >= trackRegionIdxArr.size()) {
ret.insert(ret.cend(), 4, 0);
continue;
}
uint32_t idx = trackRegionIdxArr[i];
*reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
big ? SBig(uint32_t(headSz + 4 * 64 + idx * 12)) : uint32_t(headSz + 4 * 64 + idx * 12);
}
memmove(&*ret.insert(ret.cend(), 64, 0), chanMap.data(), 64);
uint32_t regBase = chanMapOff + 64;
uint32_t curOffset = regBase;
for (Region& reg : regions) {
*reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = big ? SBig(uint32_t(8)) : 8;
if (reg.pitchBuf.size())
*reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
big ? SBig(uint32_t(curOffset + 12 + reg.eventBuf.size())) : uint32_t(curOffset + 12 + reg.eventBuf.size());
else
ret.insert(ret.cend(), 4, 0);
if (reg.modBuf.size())
*reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
big ? SBig(uint32_t(curOffset + 12 + reg.eventBuf.size() + reg.pitchBuf.size()))
: uint32_t(curOffset + 12 + reg.eventBuf.size() + reg.pitchBuf.size());
else
ret.insert(ret.cend(), 4, 0);
if (reg.eventBuf.size())
memmove(&*ret.insert(ret.cend(), reg.eventBuf.size(), 0), reg.eventBuf.data(), reg.eventBuf.size());
if (reg.pitchBuf.size())
memmove(&*ret.insert(ret.cend(), reg.pitchBuf.size(), 0), reg.pitchBuf.data(), reg.pitchBuf.size());
if (reg.modBuf.size())
memmove(&*ret.insert(ret.cend(), reg.modBuf.size(), 0), reg.modBuf.data(), reg.modBuf.size());
ret.insert(ret.cend(), reg.padding, 0);
curOffset += 12 + reg.eventBuf.size() + reg.pitchBuf.size() + reg.modBuf.size();
}
for (uint32_t regOff : regionDataIdxArr)
*reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) =
big ? SBig(uint32_t(regBase + regOff)) : uint32_t(regBase + regOff);
if (tempoBuf.size())
memmove(&*ret.insert(ret.cend(), tempoBuf.size() * 8, 0), tempoBuf.data(), tempoBuf.size() * 8);
*reinterpret_cast<uint32_t*>(&*ret.insert(ret.cend(), 4, 0)) = uint32_t(0xffffffff);
}
return ret;
}
} // namespace amuse
Reference in New Issue View Git Blame Copy Permalink