char* loadLzfStringObject()
{
unsigned int slen, clen;
char* c, *s;
if ((clen = loadLength(NULL)) == REDIS_RDB_LENERR) {
return NULL;
}
if ((slen = loadLength(NULL)) == REDIS_RDB_LENERR) {
return NULL;
}
c = malloc(clen);
if (!readBytes(c, clen)) {
free(c);
return NULL;
}
s = malloc(slen + 1);
if (lzf_decompress(c, clen, s, slen) == 0) {
free(c);
free(s);
return NULL;
}
free(c);
return s;
}
/* returns NULL when not processable, char* when valid */
char* loadStringObject() {
uint32_t offset = CURR_OFFSET;
int isencoded;
uint32_t len;
char *buf;
len = loadLength(&isencoded);
if (isencoded) {
switch(len) {
case REDIS_RDB_ENC_INT8:
case REDIS_RDB_ENC_INT16:
case REDIS_RDB_ENC_INT32:
return loadIntegerObject(len);
case REDIS_RDB_ENC_LZF:
return loadLzfStringObject();
default:
/* unknown encoding */
SHIFT_ERROR(offset, "Unknown string encoding (0x%02x)", len);
return NULL;
}
}
if (len == REDIS_RDB_LENERR) return NULL;
buf = malloc(sizeof(char) * (len+1));
buf[len] = '\0';
if (!readBytes(buf, len)) {
free(buf);
return NULL;
}
return buf;
}
entry loadEntry() {
entry e = { NULL, -1, 0 };
uint32_t length, offset[4];
/* reset error container */
errors.level = 0;
offset[0] = CURR_OFFSET;
if (!loadType(&e)) {
return e;
}
offset[1] = CURR_OFFSET;
if (e.type == REDIS_SELECTDB) {
if ((length = loadLength(NULL)) == REDIS_RDB_LENERR) {
SHIFT_ERROR(offset[1],
"Error reading database number");
return e;
}
if (length > 63) {
SHIFT_ERROR(offset[1],
"Database number out of range (%d)", length);
return e;
}
} else if (e.type == REDIS_EOF) {
if (positions[level].offset < positions[level].size) {
SHIFT_ERROR(offset[0],
"Unexpected EOF");
} else {
e.success = 1;
}
return e;
} else {
/* optionally consume expire */
if (e.type == REDIS_EXPIRETIME) {
if (!processTime()) return e;
if (!loadType(&e)) return e;
db_stats.total_expires++;
}
offset[1] = CURR_OFFSET;
if (!loadPair(&e)) {
SHIFT_ERROR(offset[1], "Error for type %s", types[e.type]);
return e;
}
}
/* all entries are followed by a valid type:
* e.g. a new entry, SELECTDB, EXPIRE, EOF */
offset[2] = CURR_OFFSET;
if (peekType() == -1) {
SHIFT_ERROR(offset[2], "Followed by invalid type");
SHIFT_ERROR(offset[0], "Error for type %s", types[e.type]);
e.success = 0;
} else {
e.success = 1;
}
return e;
}
static char* loadLzfStringObject() {
unsigned int slen, clen;
char *c, *s;
if ((clen = loadLength(NULL)) == RDB_LENERR) return NULL;
if ((slen = loadLength(NULL)) == RDB_LENERR) return NULL;
c = zmalloc(clen);
if (!readBytes(c, clen)) {
zfree(c);
return NULL;
}
s = zmalloc(slen+1);
if (lzf_decompress(c,clen,s,slen) == 0) {
zfree(c); zfree(s);
return NULL;
}
zfree(c);
return s;
}
int loadPair(entry *e) {
uint32_t offset = CURR_OFFSET;
uint32_t i;
uint32_t length = 0;
/* read key first */
char *key;
if (processStringObject(&key)) {
e->key = key;
} else {
SHIFT_ERROR(offset, "Error reading entry key");
return 0;
}
if (e->type == REDIS_LIST ||
e->type == REDIS_SET ||
e->type == REDIS_ZSET ||
e->type == REDIS_HASH) {
if ((length = loadLength(NULL)) == REDIS_RDB_LENERR) {
SHIFT_ERROR(offset, "Error reading %s length", types[e->type]);
return 0;
}
}
switch(e->type) {
case REDIS_STRING:
case REDIS_HASH_ZIPMAP:
case REDIS_LIST_ZIPLIST:
case REDIS_SET_INTSET:
case REDIS_ZSET_ZIPLIST:
case REDIS_HASH_ZIPLIST:
if (!processStringObject(NULL)) {
SHIFT_ERROR(offset, "Error reading entry value");
return 0;
}
break;
case REDIS_LIST:
case REDIS_SET:
for (i = 0; i < length; i++) {
offset = CURR_OFFSET;
if (!processStringObject(NULL)) {
SHIFT_ERROR(offset, "Error reading element at index %d (length: %d)", i, length);
return 0;
}
}
break;
case REDIS_ZSET:
for (i = 0; i < length; i++) {
offset = CURR_OFFSET;
if (!processStringObject(NULL)) {
SHIFT_ERROR(offset, "Error reading element key at index %d (length: %d)", i, length);
return 0;
}
offset = CURR_OFFSET;
if (!processDoubleValue(NULL)) {
SHIFT_ERROR(offset, "Error reading element value at index %d (length: %d)", i, length);
return 0;
}
}
break;
case REDIS_HASH:
for (i = 0; i < length; i++) {
offset = CURR_OFFSET;
if (!processStringObject(NULL)) {
SHIFT_ERROR(offset, "Error reading element key at index %d (length: %d)", i, length);
return 0;
}
offset = CURR_OFFSET;
if (!processStringObject(NULL)) {
SHIFT_ERROR(offset, "Error reading element value at index %d (length: %d)", i, length);
return 0;
}
}
break;
default:
SHIFT_ERROR(offset, "Type not implemented");
return 0;
}
/* because we're done, we assume success */
e->success = 1;
return 1;
}
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;
}
/**
* @brief cwRegionLoadTask::loadNoteTranformation
* @param protoNoteTransformation
* @param noteTransformation
*/
void cwRegionLoadTask::loadNoteTranformation(const CavewhereProto::NoteTranformation& protoNoteTransformation, cwNoteTranformation *noteTransformation)
{
noteTransformation->setNorthUp(protoNoteTransformation.northup());
loadLength(protoNoteTransformation.scalenumerator(), noteTransformation->scaleNumerator());
loadLength(protoNoteTransformation.scaledenominator(), noteTransformation->scaleDenominator());
}
