mirror of https://github.com/AxioDL/amuse.git
Minor code cleanup
This commit is contained in:
parent
6e896fa1d3
commit
f37a067174
GPG Key ID:
F8BEE4C83DACA60D
|
|
@ -74,8 +74,8 @@ class SongState {
|
|||
uint32_t m_curTick = 0; /**< Current playback position for this track */
|
||||
uint32_t m_loopStartTick = 0; /**< Tick to loop back to */
|
||||
/** Current pointer to tempo control, iterated over playback */
|
||||
const TempoChange* m_tempoPtr;
|
||||
uint32_t m_tempo; /**< Current tempo (beats per minute) */
|
||||
const TempoChange* m_tempoPtr = nullptr;
|
||||
uint32_t m_tempo = 0; /**< Current tempo (beats per minute) */
|
||||
|
||||
const unsigned char* m_data = nullptr; /**< Pointer to upcoming command data */
|
||||
const unsigned char* m_pitchWheelData = nullptr; /**< Pointer to upcoming pitch data */
|
||||
|
|
|
|||
|
|
@ -17,10 +17,10 @@ bool Copy(const SystemChar* from, const SystemChar* to) {
|
|||
return CopyFileW(from, to, FALSE) != 0;
|
||||
#else
|
||||
FILE* fi = fopen(from, "rb");
|
||||
if (!fi)
|
||||
if (fi == nullptr)
|
||||
return false;
|
||||
FILE* fo = fopen(to, "wb");
|
||||
if (!fo) {
|
||||
if (fo == nullptr) {
|
||||
fclose(fi);
|
||||
return false;
|
||||
}
|
||||
|
|
@ -30,7 +30,7 @@ bool Copy(const SystemChar* from, const SystemChar* to) {
|
|||
fwrite(buf.get(), 1, readSz, fo);
|
||||
fclose(fi);
|
||||
fclose(fo);
|
||||
struct stat theStat;
|
||||
struct stat theStat{};
|
||||
if (::stat(from, &theStat))
|
||||
return true;
|
||||
#if __APPLE__
|
||||
|
|
@ -294,13 +294,16 @@ template struct SoundMacroStepDNA<athena::Endian::Little>;
|
|||
|
||||
ObjectId NameDB::generateId(Type tp) const {
|
||||
uint16_t maxMatch = 0;
|
||||
if (tp == Type::Layer)
|
||||
if (tp == Type::Layer) {
|
||||
maxMatch = 0x8000;
|
||||
else if (tp == Type::Keymap)
|
||||
} else if (tp == Type::Keymap) {
|
||||
maxMatch = 0x4000;
|
||||
for (const auto& p : m_idToString)
|
||||
if (p.first.id >= maxMatch)
|
||||
}
|
||||
for (const auto& p : m_idToString) {
|
||||
if (p.first.id >= maxMatch) {
|
||||
maxMatch = p.first.id + 1;
|
||||
}
|
||||
}
|
||||
return maxMatch;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -9,8 +9,8 @@
|
|||
|
||||
#include "amuse/Common.hpp"
|
||||
|
||||
#include <zlib.h>
|
||||
#include <lzokay.hpp>
|
||||
#include <zlib.h>
|
||||
|
||||
#if __SWITCH__
|
||||
/*-
|
||||
|
|
|
|||
|
|
@ -8,8 +8,8 @@
|
|||
namespace amuse {
|
||||
|
||||
static uint16_t DecodeUnsignedValue(const unsigned char*& data) {
|
||||
uint16_t ret;
|
||||
if (data[0] & 0x80) {
|
||||
uint16_t ret = 0;
|
||||
if ((data[0] & 0x80) != 0) {
|
||||
ret = data[1] | ((data[0] & 0x7f) << 8);
|
||||
data += 2;
|
||||
} else {
|
||||
|
|
@ -20,13 +20,13 @@ static uint16_t DecodeUnsignedValue(const unsigned char*& data) {
|
|||
}
|
||||
|
||||
static int16_t DecodeSignedValue(const unsigned char*& data) {
|
||||
int16_t ret;
|
||||
if (data[0] & 0x80) {
|
||||
ret = data[1] | ((data[0] & 0x7f) << 8);
|
||||
int16_t ret = 0;
|
||||
if ((data[0] & 0x80) != 0) {
|
||||
ret = static_cast<int16_t>(data[1] | ((data[0] & 0x7f) << 8));
|
||||
ret |= ((ret << 1) & 0x8000);
|
||||
data += 2;
|
||||
} else {
|
||||
ret = int8_t(data[0] | ((data[0] << 1) & 0x80));
|
||||
ret = static_cast<int16_t>(data[0] | ((data[0] << 1) & 0x80));
|
||||
data += 1;
|
||||
}
|
||||
return ret;
|
||||
|
|
@ -70,9 +70,10 @@ void SongState::Header::swapFromBig() {
|
|||
m_chanMapOff = SBig(m_chanMapOff);
|
||||
m_tempoTableOff = SBig(m_tempoTableOff);
|
||||
m_initialTempo = SBig(m_initialTempo);
|
||||
if (m_initialTempo & 0x80000000) {
|
||||
for (int i = 0; i < 16; ++i)
|
||||
m_loopStartTicks[i] = SBig(m_loopStartTicks[i]);
|
||||
if ((m_initialTempo & 0x80000000) != 0u) {
|
||||
for (unsigned int& loopStartTick : m_loopStartTicks) {
|
||||
loopStartTick = SBig(loopStartTick);
|
||||
}
|
||||
m_chanMapOff2 = SBig(m_chanMapOff2);
|
||||
} else {
|
||||
m_loopStartTicks[0] = SBig(m_loopStartTicks[0]);
|
||||
|
|
@ -85,9 +86,10 @@ void SongState::Header::swapToBig() {
|
|||
m_chanMapOff = SBig(m_chanMapOff);
|
||||
m_tempoTableOff = SBig(m_tempoTableOff);
|
||||
m_initialTempo = SBig(m_initialTempo);
|
||||
if (m_initialTempo & 0x00000080) {
|
||||
for (int i = 0; i < 16; ++i)
|
||||
m_loopStartTicks[i] = SBig(m_loopStartTicks[i]);
|
||||
if ((m_initialTempo & 0x00000080) != 0u) {
|
||||
for (unsigned int& loopStartTick : m_loopStartTicks) {
|
||||
loopStartTick = SBig(loopStartTick);
|
||||
}
|
||||
m_chanMapOff2 = SBig(m_chanMapOff2);
|
||||
} else {
|
||||
m_loopStartTicks[0] = SBig(m_loopStartTicks[0]);
|
||||
|
|
@ -100,9 +102,10 @@ SongState::Header& SongState::Header::operator=(const Header& other) {
|
|||
m_chanMapOff = other.m_chanMapOff;
|
||||
m_tempoTableOff = other.m_tempoTableOff;
|
||||
m_initialTempo = other.m_initialTempo;
|
||||
if (SBig(m_initialTempo) & 0x80000000) {
|
||||
for (int i = 0; i < 16; ++i)
|
||||
if ((SBig(m_initialTempo) & 0x80000000) != 0u) {
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
m_loopStartTicks[i] = other.m_loopStartTicks[i];
|
||||
}
|
||||
m_chanMapOff2 = other.m_chanMapOff2;
|
||||
} else {
|
||||
m_loopStartTicks[0] = other.m_loopStartTicks[0];
|
||||
|
|
@ -120,8 +123,9 @@ bool SongState::TrackRegion::indexValid(bool bigEndian) const {
|
|||
}
|
||||
|
||||
int SongState::TrackRegion::indexLoop(bool bigEndian) const {
|
||||
if ((bigEndian ? SBig(m_regionIndex) : m_regionIndex) != -2)
|
||||
if ((bigEndian ? SBig(m_regionIndex) : m_regionIndex) != -2) {
|
||||
return -1;
|
||||
}
|
||||
return (bigEndian ? SBig(m_loopToRegion) : m_loopToRegion);
|
||||
}
|
||||
|
||||
|
|
@ -141,7 +145,6 @@ SongState::Track::Track(SongState& parent, uint8_t midiChan, uint32_t loopStart,
|
|||
: m_parent(&parent)
|
||||
, m_midiChan(midiChan)
|
||||
, m_initRegion(regions)
|
||||
, m_curRegion(nullptr)
|
||||
, m_nextRegion(regions)
|
||||
, m_loopStartTick(loopStart)
|
||||
, m_tempo(tempo) {
|
||||
|
|
@ -157,15 +160,16 @@ void SongState::Track::setRegion(const TrackRegion* region) {
|
|||
(m_parent->m_bigEndian ? SBig(m_parent->m_regionIdx[regionIdx]) : m_parent->m_regionIdx[regionIdx]);
|
||||
|
||||
Header header = *reinterpret_cast<const Header*>(m_data);
|
||||
if (m_parent->m_bigEndian)
|
||||
if (m_parent->m_bigEndian) {
|
||||
header.swapBig();
|
||||
}
|
||||
m_data += 12;
|
||||
|
||||
m_pitchWheelData = nullptr;
|
||||
m_nextPitchTick = 0x7fffffff;
|
||||
m_nextPitchDelta = 0;
|
||||
m_pitchVal = 0;
|
||||
if (header.m_pitchOff) {
|
||||
if (header.m_pitchOff != 0u) {
|
||||
m_pitchWheelData = m_parent->m_songData + header.m_pitchOff;
|
||||
if (m_pitchWheelData[0] != 0x80 || m_pitchWheelData[1] != 0x00) {
|
||||
auto delta = DecodeDelta(m_pitchWheelData);
|
||||
|
|
@ -178,7 +182,7 @@ void SongState::Track::setRegion(const TrackRegion* region) {
|
|||
m_nextModTick = 0x7fffffff;
|
||||
m_nextModDelta = 0;
|
||||
m_modVal = 0;
|
||||
if (header.m_modOff) {
|
||||
if (header.m_modOff != 0u) {
|
||||
m_modWheelData = m_parent->m_songData + header.m_modOff;
|
||||
if (m_modWheelData[0] != 0x80 || m_modWheelData[1] != 0x00) {
|
||||
auto delta = DecodeDelta(m_modWheelData);
|
||||
|
|
@ -204,18 +208,18 @@ void SongState::Track::advanceRegion() { setRegion(m_nextRegion); }
|
|||
int SongState::DetectVersion(const unsigned char* ptr, bool& isBig) {
|
||||
isBig = ptr[0] == 0;
|
||||
Header header = *reinterpret_cast<const Header*>(ptr);
|
||||
if (isBig)
|
||||
if (isBig) {
|
||||
header.swapFromBig();
|
||||
const uint32_t* trackIdx = reinterpret_cast<const uint32_t*>(ptr + header.m_trackIdxOff);
|
||||
const uint32_t* regionIdxTable = reinterpret_cast<const uint32_t*>(ptr + header.m_regionIdxOff);
|
||||
}
|
||||
const auto* trackIdx = reinterpret_cast<const uint32_t*>(ptr + header.m_trackIdxOff);
|
||||
const auto* regionIdxTable = reinterpret_cast<const uint32_t*>(ptr + header.m_regionIdxOff);
|
||||
|
||||
/* First determine maximum index of MIDI regions across all tracks */
|
||||
uint32_t maxRegionIdx = 0;
|
||||
for (int i = 0; i < 64; ++i) {
|
||||
if (trackIdx[i]) {
|
||||
if (trackIdx[i] != 0) {
|
||||
const TrackRegion* region = nullptr;
|
||||
const TrackRegion* nextRegion =
|
||||
reinterpret_cast<const TrackRegion*>(ptr + (isBig ? SBig(trackIdx[i]) : trackIdx[i]));
|
||||
const auto* nextRegion = reinterpret_cast<const TrackRegion*>(ptr + (isBig ? SBig(trackIdx[i]) : trackIdx[i]));
|
||||
|
||||
/* Iterate all regions */
|
||||
while (nextRegion->indexValid(isBig)) {
|
||||
|
|
@ -234,10 +238,9 @@ int SongState::DetectVersion(const unsigned char* ptr, bool& isBig) {
|
|||
|
||||
/* Validate all tracks */
|
||||
for (int i = 0; i < 64; ++i) {
|
||||
if (trackIdx[i]) {
|
||||
if (trackIdx[i] != 0) {
|
||||
const TrackRegion* region = nullptr;
|
||||
const TrackRegion* nextRegion =
|
||||
reinterpret_cast<const TrackRegion*>(ptr + (isBig ? SBig(trackIdx[i]) : trackIdx[i]));
|
||||
const auto* nextRegion = reinterpret_cast<const TrackRegion*>(ptr + (isBig ? SBig(trackIdx[i]) : trackIdx[i]));
|
||||
|
||||
/* Iterate all regions */
|
||||
while (nextRegion->indexValid(isBig)) {
|
||||
|
|
@ -248,37 +251,43 @@ int SongState::DetectVersion(const unsigned char* ptr, bool& isBig) {
|
|||
const unsigned char* data = ptr + (isBig ? SBig(regionIdxTable[regionIdx]) : regionIdxTable[regionIdx]);
|
||||
|
||||
/* Can't reliably validate final region */
|
||||
if (regionIdx == maxRegionIdx)
|
||||
if (regionIdx == maxRegionIdx) {
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Expected end pointer (next region) */
|
||||
const unsigned char* expectedEnd =
|
||||
ptr + (isBig ? SBig(regionIdxTable[regionIdx + 1]) : regionIdxTable[regionIdx + 1]);
|
||||
|
||||
auto header2 = *reinterpret_cast<const Track::Header*>(data);
|
||||
if (isBig)
|
||||
if (isBig) {
|
||||
header2.swapBig();
|
||||
}
|
||||
data += 12;
|
||||
|
||||
/* continuous pitch data */
|
||||
if (header2.m_pitchOff) {
|
||||
if (header2.m_pitchOff != 0u) {
|
||||
const unsigned char* dptr = ptr + header2.m_pitchOff;
|
||||
while (dptr[0] != 0x80 || dptr[1] != 0x00)
|
||||
while (dptr[0] != 0x80 || dptr[1] != 0x00) {
|
||||
DecodeDelta(dptr);
|
||||
}
|
||||
dptr += 2;
|
||||
if (dptr >= (expectedEnd - 4) && (dptr <= expectedEnd))
|
||||
if (dptr >= (expectedEnd - 4) && (dptr <= expectedEnd)) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
/* continuous modulation data */
|
||||
if (header2.m_modOff) {
|
||||
if (header2.m_modOff != 0u) {
|
||||
const unsigned char* dptr = ptr + header2.m_modOff;
|
||||
while (dptr[0] != 0x80 || dptr[1] != 0x00)
|
||||
while (dptr[0] != 0x80 || dptr[1] != 0x00) {
|
||||
DecodeDelta(dptr);
|
||||
}
|
||||
dptr += 2;
|
||||
if (dptr >= (expectedEnd - 4) && (dptr <= expectedEnd))
|
||||
if (dptr >= (expectedEnd - 4) && (dptr <= expectedEnd)) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
/* Loop through as many commands as we can for this time period */
|
||||
if (v == 1) {
|
||||
|
|
@ -292,10 +301,11 @@ int SongState::DetectVersion(const unsigned char* ptr, bool& isBig) {
|
|||
/* End of channel */
|
||||
data += 2;
|
||||
break;
|
||||
} else if (data[0] & 0x80 && data[1] & 0x80) {
|
||||
}
|
||||
if ((data[0] & 0x80) != 0 && (data[1] & 0x80) != 0) {
|
||||
/* Control change */
|
||||
data += 2;
|
||||
} else if (data[0] & 0x80) {
|
||||
} else if ((data[0] & 0x80) != 0) {
|
||||
/* Program change */
|
||||
data += 2;
|
||||
} else {
|
||||
|
|
@ -314,30 +324,31 @@ int SongState::DetectVersion(const unsigned char* ptr, bool& isBig) {
|
|||
/* End of channel */
|
||||
data += 4;
|
||||
break;
|
||||
} else {
|
||||
}
|
||||
if ((data[2] & 0x80) != 0x80) {
|
||||
/* Note */
|
||||
} else if (data[2] & 0x80 && data[3] & 0x80) {
|
||||
} else if (((data[2] & 0x80) != 0) && ((data[3] & 0x80) != 0)) {
|
||||
/* Control change */
|
||||
} else if (data[2] & 0x80) {
|
||||
} else if ((data[2] & 0x80) != 0) {
|
||||
/* Program change */
|
||||
}
|
||||
data += 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (data < (expectedEnd - 4) || (data > expectedEnd)) {
|
||||
bad = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (bad)
|
||||
if (bad) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (bad)
|
||||
}
|
||||
if (bad) {
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -347,29 +358,32 @@ int SongState::DetectVersion(const unsigned char* ptr, bool& isBig) {
|
|||
bool SongState::initialize(const unsigned char* ptr, bool loop) {
|
||||
m_loop = loop;
|
||||
m_sngVersion = DetectVersion(ptr, m_bigEndian);
|
||||
if (m_sngVersion < 0)
|
||||
if (m_sngVersion < 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
m_songData = ptr;
|
||||
m_header = *reinterpret_cast<const Header*>(ptr);
|
||||
if (m_bigEndian)
|
||||
if (m_bigEndian) {
|
||||
m_header.swapFromBig();
|
||||
const uint32_t* trackIdx = reinterpret_cast<const uint32_t*>(ptr + m_header.m_trackIdxOff);
|
||||
}
|
||||
|
||||
const auto* trackIdx = reinterpret_cast<const uint32_t*>(ptr + m_header.m_trackIdxOff);
|
||||
m_regionIdx = reinterpret_cast<const uint32_t*>(ptr + m_header.m_regionIdxOff);
|
||||
const uint8_t* chanMap = reinterpret_cast<const uint8_t*>(ptr + m_header.m_chanMapOff);
|
||||
const auto* chanMap = reinterpret_cast<const uint8_t*>(ptr + m_header.m_chanMapOff);
|
||||
|
||||
/* Initialize all tracks */
|
||||
for (int i = 0; i < 64; ++i) {
|
||||
if (trackIdx[i]) {
|
||||
const TrackRegion* region =
|
||||
reinterpret_cast<const TrackRegion*>(ptr + (m_bigEndian ? SBig(trackIdx[i]) : trackIdx[i]));
|
||||
if (trackIdx[i] != 0u) {
|
||||
const auto* region = reinterpret_cast<const TrackRegion*>(ptr + (m_bigEndian ? SBig(trackIdx[i]) : trackIdx[i]));
|
||||
uint8_t chan = chanMap[i];
|
||||
uint32_t loopStart =
|
||||
(m_header.m_initialTempo & 0x80000000) ? m_header.m_loopStartTicks[chan] : m_header.m_loopStartTicks[0];
|
||||
(m_header.m_initialTempo & 0x80000000) != 0u ? m_header.m_loopStartTicks[chan] : m_header.m_loopStartTicks[0];
|
||||
m_tracks[i] = Track(*this, chan, loopStart, region, m_header.m_initialTempo & 0x7fffffff);
|
||||
} else
|
||||
} else {
|
||||
m_tracks[i] = Track();
|
||||
}
|
||||
}
|
||||
|
||||
m_songState = SongPlayState::Playing;
|
||||
|
||||
|
|
@ -377,32 +391,35 @@ bool SongState::initialize(const unsigned char* ptr, bool loop) {
|
|||
}
|
||||
|
||||
void SongState::Track::resetTempo() {
|
||||
if (m_parent->m_header.m_tempoTableOff)
|
||||
if (m_parent->m_header.m_tempoTableOff != 0u) {
|
||||
m_tempoPtr = reinterpret_cast<const TempoChange*>(m_parent->m_songData + m_parent->m_header.m_tempoTableOff);
|
||||
else
|
||||
} else {
|
||||
m_tempoPtr = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
bool SongState::Track::advance(Sequencer& seq, double dt) {
|
||||
m_remDt += dt;
|
||||
|
||||
/* Compute ticks to compute based on current tempo */
|
||||
double ticksPerSecond = m_tempo * 384 / 60;
|
||||
double ticksPerSecond = static_cast<double>(m_tempo) * 384 / 60;
|
||||
uint32_t ticks = uint32_t(std::floor(m_remDt * ticksPerSecond));
|
||||
|
||||
/* See if there's an upcoming tempo change in this interval */
|
||||
while (m_tempoPtr && m_tempoPtr->m_tick != 0xffffffff) {
|
||||
while ((m_tempoPtr != nullptr) && m_tempoPtr->m_tick != 0xffffffff) {
|
||||
TempoChange change = *m_tempoPtr;
|
||||
if (m_parent->m_bigEndian)
|
||||
if (m_parent->m_bigEndian) {
|
||||
change.swapBig();
|
||||
}
|
||||
|
||||
if (m_curTick + ticks > change.m_tick)
|
||||
if (m_curTick + ticks > change.m_tick) {
|
||||
ticks = change.m_tick - m_curTick;
|
||||
}
|
||||
|
||||
if (ticks <= 0) {
|
||||
/* Turn over tempo */
|
||||
m_tempo = change.m_tempo & 0x7fffffff;
|
||||
ticksPerSecond = m_tempo * 384 / 60;
|
||||
ticksPerSecond = static_cast<double>(m_tempo) * 384 / 60;
|
||||
ticks = uint32_t(std::floor(m_remDt * ticksPerSecond));
|
||||
seq.setTempo(m_midiChan, m_tempo * 384 / 60.0);
|
||||
++m_tempoPtr;
|
||||
|
|
@ -417,11 +434,12 @@ bool SongState::Track::advance(Sequencer& seq, double dt) {
|
|||
/* Advance region if needed */
|
||||
while (m_nextRegion->indexValid(m_parent->m_bigEndian)) {
|
||||
uint32_t nextRegTick = (m_parent->m_bigEndian ? SBig(m_nextRegion->m_startTick) : m_nextRegion->m_startTick);
|
||||
if (uint32_t(endTick) > nextRegTick)
|
||||
if (uint32_t(endTick) > nextRegTick) {
|
||||
advanceRegion();
|
||||
else
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Stop finished notes */
|
||||
for (int i = 0; i < 128; ++i) {
|
||||
|
|
@ -432,14 +450,14 @@ bool SongState::Track::advance(Sequencer& seq, double dt) {
|
|||
}
|
||||
}
|
||||
|
||||
if (m_data) {
|
||||
if (m_data != nullptr) {
|
||||
/* Update continuous pitch data */
|
||||
if (m_pitchWheelData) {
|
||||
int32_t pitchTick = m_curTick;
|
||||
int32_t remPitchTicks = ticks;
|
||||
if (m_pitchWheelData != nullptr) {
|
||||
auto pitchTick = static_cast<int32_t>(m_curTick);
|
||||
auto remPitchTicks = static_cast<int32_t>(ticks);
|
||||
while (pitchTick < int32_t(endTick)) {
|
||||
/* See if there's an upcoming pitch change in this interval */
|
||||
int32_t nextTick = m_nextPitchTick;
|
||||
auto nextTick = static_cast<int32_t>(m_nextPitchTick);
|
||||
if (pitchTick + remPitchTicks > nextTick) {
|
||||
/* Update pitch */
|
||||
m_pitchVal += m_nextPitchDelta;
|
||||
|
|
@ -458,12 +476,12 @@ bool SongState::Track::advance(Sequencer& seq, double dt) {
|
|||
}
|
||||
|
||||
/* Update continuous modulation data */
|
||||
if (m_modWheelData) {
|
||||
int32_t modTick = m_curTick;
|
||||
int32_t remModTicks = ticks;
|
||||
if (m_modWheelData != nullptr) {
|
||||
auto modTick = static_cast<int32_t>(m_curTick);
|
||||
auto remModTicks = static_cast<int32_t>(ticks);
|
||||
while (modTick < int32_t(endTick)) {
|
||||
/* See if there's an upcoming modulation change in this interval */
|
||||
int32_t nextTick = m_nextModTick;
|
||||
auto nextTick = static_cast<int32_t>(m_nextModTick);
|
||||
if (modTick + remModTicks > nextTick) {
|
||||
/* Update modulation */
|
||||
m_modVal += m_nextModDelta;
|
||||
|
|
@ -486,28 +504,30 @@ bool SongState::Track::advance(Sequencer& seq, double dt) {
|
|||
/* Revision */
|
||||
while (true) {
|
||||
/* Advance wait timer if active, returning if waiting */
|
||||
if (m_eventWaitCountdown) {
|
||||
m_eventWaitCountdown -= ticks;
|
||||
if (m_eventWaitCountdown != 0) {
|
||||
m_eventWaitCountdown -= static_cast<int32_t>(ticks);
|
||||
ticks = 0;
|
||||
if (m_eventWaitCountdown > 0)
|
||||
if (m_eventWaitCountdown > 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Load next command */
|
||||
if (*reinterpret_cast<const uint16_t*>(m_data) == 0xffff) {
|
||||
/* End of channel */
|
||||
m_data = nullptr;
|
||||
break;
|
||||
} else if (m_data[0] & 0x80 && m_data[1] & 0x80) {
|
||||
}
|
||||
if ((m_data[0] & 0x80) != 0u && (m_data[1] & 0x80) != 0u) {
|
||||
/* Control change */
|
||||
uint8_t val = m_data[0] & 0x7f;
|
||||
uint8_t ctrl = m_data[1] & 0x7f;
|
||||
seq.setCtrlValue(m_midiChan, ctrl, val);
|
||||
seq.setCtrlValue(m_midiChan, ctrl, static_cast<int8_t>(val));
|
||||
m_data += 2;
|
||||
} else if (m_data[0] & 0x80) {
|
||||
} else if ((m_data[0] & 0x80) != 0u) {
|
||||
/* Program change */
|
||||
uint8_t prog = m_data[0] & 0x7f;
|
||||
seq.setChanProgram(m_midiChan, prog);
|
||||
seq.setChanProgram(static_cast<int8_t>(m_midiChan), static_cast<int8_t>(prog));
|
||||
m_data += 2;
|
||||
} else {
|
||||
/* Note */
|
||||
|
|
@ -516,8 +536,9 @@ bool SongState::Track::advance(Sequencer& seq, double dt) {
|
|||
uint16_t length = (m_parent->m_bigEndian ? SBig(*reinterpret_cast<const uint16_t*>(m_data + 2))
|
||||
: *reinterpret_cast<const uint16_t*>(m_data + 2));
|
||||
seq.keyOn(m_midiChan, note, vel);
|
||||
if (length == 0)
|
||||
if (length == 0) {
|
||||
seq.keyOff(m_midiChan, note, 0);
|
||||
}
|
||||
m_remNoteLengths[note] = length;
|
||||
m_data += 4;
|
||||
}
|
||||
|
|
@ -529,19 +550,20 @@ bool SongState::Track::advance(Sequencer& seq, double dt) {
|
|||
/* Legacy */
|
||||
while (true) {
|
||||
/* Advance wait timer if active, returning if waiting */
|
||||
if (m_eventWaitCountdown) {
|
||||
m_eventWaitCountdown -= ticks;
|
||||
if (m_eventWaitCountdown != 0) {
|
||||
m_eventWaitCountdown -= static_cast<int32_t>(ticks);
|
||||
ticks = 0;
|
||||
if (m_eventWaitCountdown > 0)
|
||||
if (m_eventWaitCountdown > 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Load next command */
|
||||
if (*reinterpret_cast<const uint16_t*>(&m_data[2]) == 0xffff) {
|
||||
/* End of channel */
|
||||
m_data = nullptr;
|
||||
break;
|
||||
} else {
|
||||
}
|
||||
if ((m_data[2] & 0x80) != 0x80) {
|
||||
/* Note */
|
||||
uint16_t length = (m_parent->m_bigEndian ? SBig(*reinterpret_cast<const uint16_t*>(m_data))
|
||||
|
|
@ -549,21 +571,21 @@ bool SongState::Track::advance(Sequencer& seq, double dt) {
|
|||
uint8_t note = m_data[2] & 0x7f;
|
||||
uint8_t vel = m_data[3] & 0x7f;
|
||||
seq.keyOn(m_midiChan, note, vel);
|
||||
if (length == 0)
|
||||
if (length == 0) {
|
||||
seq.keyOff(m_midiChan, note, 0);
|
||||
}
|
||||
m_remNoteLengths[note] = length;
|
||||
} else if (m_data[2] & 0x80 && m_data[3] & 0x80) {
|
||||
} else if ((m_data[2] & 0x80) != 0u && (m_data[3] & 0x80) != 0u) {
|
||||
/* Control change */
|
||||
uint8_t val = m_data[2] & 0x7f;
|
||||
uint8_t ctrl = m_data[3] & 0x7f;
|
||||
seq.setCtrlValue(m_midiChan, ctrl, val);
|
||||
} else if (m_data[2] & 0x80) {
|
||||
seq.setCtrlValue(m_midiChan, ctrl, static_cast<int8_t>(val));
|
||||
} else if ((m_data[2] & 0x80) != 0u) {
|
||||
/* Program change */
|
||||
uint8_t prog = m_data[2] & 0x7f;
|
||||
seq.setChanProgram(m_midiChan, prog);
|
||||
seq.setChanProgram(static_cast<int8_t>(m_midiChan), static_cast<int8_t>(prog));
|
||||
}
|
||||
m_data += 4;
|
||||
}
|
||||
|
||||
/* Set next delta-time */
|
||||
int32_t absTick = (m_parent->m_bigEndian ? SBig(*reinterpret_cast<const int32_t*>(m_data))
|
||||
|
|
@ -579,7 +601,7 @@ bool SongState::Track::advance(Sequencer& seq, double dt) {
|
|||
|
||||
/* Handle loop end */
|
||||
if (m_parent->m_loop) {
|
||||
int loopTo;
|
||||
int loopTo = 0;
|
||||
if ((loopTo = m_nextRegion->indexLoop(m_parent->m_bigEndian)) != -1) {
|
||||
uint32_t loopEndTick = (m_parent->m_bigEndian ? SBig(m_nextRegion->m_startTick) : m_nextRegion->m_startTick);
|
||||
if (uint32_t(endTick) > loopEndTick) {
|
||||
|
|
@ -593,25 +615,30 @@ bool SongState::Track::advance(Sequencer& seq, double dt) {
|
|||
}
|
||||
}
|
||||
|
||||
if (!m_data)
|
||||
if (m_data == nullptr) {
|
||||
return m_nextRegion->indexDone(m_parent->m_bigEndian, m_parent->m_loop);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool SongState::advance(Sequencer& seq, double dt) {
|
||||
/* Stopped */
|
||||
if (m_songState == SongPlayState::Stopped)
|
||||
if (m_songState == SongPlayState::Stopped) {
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Advance all tracks */
|
||||
bool done = true;
|
||||
for (Track& trk : m_tracks)
|
||||
if (trk)
|
||||
for (Track& trk : m_tracks) {
|
||||
if (trk) {
|
||||
done &= trk.advance(seq, dt);
|
||||
}
|
||||
}
|
||||
|
||||
if (done)
|
||||
if (done) {
|
||||
m_songState = SongPlayState::Stopped;
|
||||
}
|
||||
return done;
|
||||
}
|
||||
} // namespace amuse
|
||||
|
|
|
|||
Loading…
Reference in New Issue