int blake2xs_final(blake2xs_state *S, void *out, size_t outlen) {
blake2s_state C[1];
blake2s_param P[1];
uint16_t xof_length = load16(&S->P->xof_length);
uint8_t root[BLAKE2S_BLOCKBYTES];
size_t i;
if (NULL == out) {
return -1;
}
/* outlen must match the output size defined in xof_length, */
/* unless it was -1, in which case anything goes except 0. */
if(xof_length == 0xFFFFUL) {
if(outlen == 0) {
return -1;
}
} else {
if(outlen != xof_length) {
return -1;
}
}
/* Finalize the root hash */
if (blake2s_final(S->S, root, BLAKE2S_OUTBYTES) < 0) {
return -1;
}
/* Set common block structure values */
/* Copy values from parent instance, and only change the ones below */
memcpy(P, S->P, sizeof(blake2s_param));
P->key_length = 0;
P->fanout = 0;
P->depth = 0;
store32(&P->leaf_length, BLAKE2S_OUTBYTES);
P->inner_length = BLAKE2S_OUTBYTES;
P->node_depth = 0;
for (i = 0; outlen > 0; ++i) {
const size_t block_size = (outlen < BLAKE2S_OUTBYTES) ? outlen : BLAKE2S_OUTBYTES;
/* Initialize state */
P->digest_length = block_size;
store32(&P->node_offset, i);
blake2s_init_param(C, P);
/* Process key if needed */
blake2s_update(C, root, BLAKE2S_OUTBYTES);
if (blake2s_final(C, (uint8_t *)out + i * BLAKE2S_OUTBYTES, block_size) < 0) {
return -1;
}
outlen -= block_size;
}
secure_zero_memory(root, sizeof(root));
secure_zero_memory(P, sizeof(P));
secure_zero_memory(C, sizeof(C));
/* Put blake2xs in an invalid state? cf. blake2s_is_lastblock */
return 0;
}
// 08080168
u8 *battle_load_arguments(struct battle_config_entry *bce, u8 *cursor) {
while (1) {
switch (bce->target_type) {
case LOAD_8: *(u8 *)bce->target = load8 (cursor); cursor += 1; break;
case LOAD_16: *(u16*)bce->target = load16(cursor); cursor += 2; break;
case LOAD_32: *(u32*)bce->target = load32(cursor); cursor += 4; break;
case ZERO_8: *(u8 *)bce->target = 0; cursor += 1; break;
case ZERO_16: *(u16*)bce->target = 0; cursor += 2; break;
case ZERO_32: *(u32*)bce->target = 0; cursor += 4; break;
case END: *(u32*)bce->target = (u32)cursor; return cursor;
default: break;
}
bce++;
}
}
TrackFrames buildTrackFramesFromMidi(const std::string& filename)
{
TrackFrames trackFrames;
FILE* pFic;
fopen_s(&pFic, filename.c_str(), "rb");
// Load header
struct HeaderChunk
{
char HThd[4];
uint32_t size;
uint16_t format;
uint16_t nbTrack;
uint16_t division;
} headerChunk;
loadStr(headerChunk.HThd, 4, pFic);
headerChunk.size = load32(pFic);
headerChunk.format = load16(pFic);
headerChunk.nbTrack = load16(pFic);
headerChunk.division = load16(pFic);
uint32_t maxTime = 0;
std::set<int> channelSet;
//int midiToChannels[] = { // mario
// 5, 0, 1, 2,
// 5, 5, 5, 5,
// 5, 5, 5, 5,
// 5, 5, 5, 5,
//};
//int midiToChannels[] = { // sm2
// 0, 2, 1, 5,
// 5, 5, 5, 5,
// 5, 3, 5, 5,
// 5, 5, 5, 5,
//};
int midiToChannels[] = {
0, 1, 2, 5,
5, 5, 5, 5,
5, 5, 5, 5,
5, 5, 5, 5,
};
//int midiToChannels[] = { // zelda
// 0, 1, 2, 5,
// 5, 5, 5, 5,
// 5, 3, 5, 5,
// 5, 5, 5, 5,
//};
// Load tracks
for (auto i = 0u; i < headerChunk.nbTrack; ++i)
{
char MTrk[4];
loadStr(MTrk, 4, pFic);
auto len = load32(pFic);
auto start = ftell(pFic);
auto cur = start;
uint32_t curTime = 0;
while (cur - start < static_cast<decltype(cur)>(len))
{
auto v_time = loadLength(pFic);
auto event = load8(pFic);
curTime += v_time;// / (headerChunk.division / 24);
maxTime = std::max(maxTime, curTime);
trackFrames.resize(maxTime * 4 + 16);
if (event == 0xFF)
{
// Meta event
event = load8(pFic);
if (event == 0x58)
{
// Time Signature
event = load8(pFic);
assert(event == 0x04);
load32(pFic); // Ignore who f*****g cares
}
else if (event == 0x7F)
{
// Sequencer Specific Meta-Event
auto dataLen = load8(pFic); // Len, ignore
while (dataLen)
{
load8(pFic);
--dataLen;
}
}
else if (event == 0x51)
{
// Set Tempo
event = load8(pFic);
assert(event == 0x03);
load8(pFic);
load8(pFic);
load8(pFic);
}
else if (event == 0x2F)
{
// End of Track
event = load8(pFic);
assert(event == 0x00);
}
else if (event == 0x03)
{
// Sequence/Track Name
auto textLen = load8(pFic);
char text[257] = {0};
loadStr(text, textLen, pFic);
printf("Track found: %i, %s\n", i, text);
}
else if (event == 0x59)
{
// Key Signature
event = load8(pFic);
assert(event == 0x02);
auto sf = load8(pFic);
auto mi = load8(pFic);
}
else if (event == 0x21)
{
// End of Track
event = load8(pFic);
assert(event == 0x01);
load8(pFic);
}
else if (event == 0x20)
{
// MIDI Channel Prefix
event = load8(pFic);
assert(event == 0x01);
auto channel = load8(pFic);
}
else
{
assert(false);
}
}
else if (event & 0x80)
{
auto channelNo = event & 0x0F;
channelSet.insert(channelNo);
if (channelNo < sizeof(midiToChannels) / sizeof(int)) channelNo = midiToChannels[channelNo];
event = event & 0xF0;
if (event == 0xB0)
{
// Control Change
auto controllerNumber = load8(pFic) & 0x7F;
auto controllerValue = load8(pFic) & 0x7F;
}
else if (event == 0xC0)
{
// Program Change
auto programNumber = load8(pFic) & 0x7F;
}
else if (event == 0x90)
{
// Note On event
auto note = load8(pFic) & 0x7F;
auto vol = load8(pFic) & 0x7F;
if (channelNo < 3)
{
auto& trackFrame = trackFrames[curTime * 4 + channelNo];
trackFrame = NOTE(noteTable[note], channelNo, (vol * 15) / 127);
}
else if (channelNo == 3)
{
auto& trackFrame = trackFrames[curTime * 4 + channelNo];
trackFrame = NOTE(noteTable[note + 12], channelNo, (vol * 15) / 127);
}
}
else if (event == 0x80)
{
// Note Off event
auto note = load8(pFic) & 0x7F;
auto vol = load8(pFic) & 0x7F;
if (channelNo == 2)
{
//auto& trackFrame = trackFrames[curTime * 4 + channelNo];
//trackFrame = NOTE(noteTable[note + 12], channelNo, 0);
}
if (channelNo == 3)
{
auto& trackFrame = trackFrames[curTime * 4 + channelNo];
trackFrame = NOTE(noteTable[note], channelNo, 0);
}
}
else if (event == 0xE0)
{
// Pitch Wheel Change
auto l = load8(pFic) & 0x7F;
auto m = load8(pFic) & 0x7F;
}
else
{
assert(false);
}
}
else if (event <= 0x7F)
{
load8(pFic);
}
else
{
assert(false);
}
cur = ftell(pFic);
}
}
fclose(pFic);
for (auto& channelNo : channelSet)
{
printf("%i\n", channelNo);
}
return trackFrames;
}