Minor code cleanup

This commit is contained in:
Phillip Stephens 2021-07-10 19:38:41 -07:00
parent 6e896fa1d3
commit f37a067174
Signed by: Antidote
GPG Key ID: F8BEE4C83DACA60D
4 changed files with 155 additions and 125 deletions

View File

@ -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 */

View File

@ -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;
}

View File

@ -9,8 +9,8 @@
#include "amuse/Common.hpp"
#include <zlib.h>
#include <lzokay.hpp>
#include <zlib.h>
#if __SWITCH__
/*-

View File

@ -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