e+ Sequence Header Commands WIP

struct group;
struct macro {
    u8* data;
    u8* stack[4];
    s8 stackArgs[4];
    s8 stackIdx;
    s8 unk;
}

typedef char s8;
typedef unsigned char u8;
typedef short s16;
typedef unsigned short u16;
typedef int s32;
typedef unsigned int u32;

u16 Nas_ReadLengthData(macro* macro) {
    u16 data = *macro->data;
    macro->data++;
    if ((data & 0x80) != 0) {
        data = ((data & 0x7F) << 8) | *macro->data;
        macro->data++;
    }

    return data;
}

// 0x0X
void SeqHeaderCmd_0X(group* group, macro* macro, u8 cmd) {
    group->macro.char_0x19 = (group->subTracks[cmd & 0xF]->flags >> 7) ^ 1;
}

// 0x4X
// Releases a sub-track. (Sub sequence aka. channel)
void SeqHeaderCmd_4X(group* group, macro* macro, u8 cmd) {
    Nas_ReleaseSubTrack(group->subTracks[cmd & 0xF];
}

// 0x5X
void SeqHeaderCmd_5X(group* group, macro* macro, u8 cmd) {
    group->macro.char_0x19 -= group->pChar_0x15C[cmd & 0xF];
}

// 0x6X
void SeqHeaderCmd_6X(group* group, macro* macro, u8 cmd) {
    MK_load(Nas_ReadByteData(macro), Nas_ReadByteData(macro), group->pChar_0x15C[cmd & 0xF]);
}

// 0x7X
void SeqHeaderCmd_7X(group* group, macro* macro, u8 cmd) {
    group->pChar_0x15C[cmd & 0xF] = group->macro.char_0x19;
}

// 0x8X
void SeqHeaderCmd_8X(group* group, macro* macro, u8 cmd) {
    group->macro.char_0x19 = group->pChar_0x15C[cmd & 0xF];
    if (cmd & 0xF < 2) {
        group->pChar_0x15C[cmd & 0xF] = -1;
    }
}

// 0x9X
// Sets up a sub-track (aka. sub-sequence or channel)
// This is a global pointer.
void SeqHeaderCmd_9X(group* group, macro* macro, u8 cmd) {
    Nas_OpenSub(group, cmd & 0xF, group->seqData + Nas_ReadWordData(macro));
}

// 0xAX
// Sets up a sub-track.
// Same as 9X commands, except that the offset is relative to the current command.
void SeqHeaderCmd_AX(group* group, macro* macro, u8 cmd) {
    Nas_OpenSub(group, cmd & 0xF, macro->data + (s8)Nas_ReadWordData(macro));
}

// 0xBX
// Loads an entirely new sequence at the specified global offset.
// The first byte argument is the sequence id.
void SeqHeaderCmd_AX(group* group, macro* macro, u8 cmd) {
    SeqLoad(Nas_ReadByteData(macro), group->seqData + Nas_ReadWordData(macro), group->pChar_0x15C[cmd & 0xF]);
}

// 0xBE
// Sets up a callback function.
// This may only be in the N64 emulator as an addition.
void SeqHeaderCmd_BE(group* group, macro* macro) {
    u8 callbackIdx = Nas_ReadByteData(macro);
    if (callbackIdx < 5) {
        (s8 (*f)(s8, group*)) = sequenceMainCallbacks[callbackIdx];
        if (f != NULL) {
            s8 result = (*f)(group->macro->char_0x19, group);
        }
    }
}

// 0xC2
void SeqHeaderCmd_C2(group* group, macro* macro) {
    unsigned short offset = Nas_ReadWordData(macro);
    if (group->char_0x95 != -1) {
        short macroPtrAdjust = ((short*)group->pByte_0x1C + offset)[group->char_0x95];
        *macro = (macro)(group->pByte_0x1C + macroPtrAdjust);
    }
}

// 0xC3
void SeqHeaderCmd_C3(group* group, macro* macro) {
    u16 offset = Nas_ReadWordData(macro);
    if (group->char_0x95 != -1) {
        u16 bitfield = (u16)((short*)group->pByte_0x1C + offset)[group->char_0x95];
        for (u32 i = 0; i < 16; i++) {
            u8* value = group->arrayBytePtr_0x3C[i];
            *value = (u8)(((bitfield & 1) << 4) | (*value & 0xEF));
            bitfield >>= 1;
        }
    }
}

// 0xC4
// Calls another sequence.
// If the sequence id? is equal to the current one, further command parsing is halted.
void SeqHeaderCmd_C4(group* group, macro* macro) {
    u8 val1 = Nas_ReadByteData(macro);
    if (val1 == 0xFF) {
        val1 = group->byte_0x8;
    }

    u8 val2 = Nas_ReadByteData(macro);
    Nas_StartMySeq(val1, val2);

    // Used when in switch format
    if (val1 == group->byte_0x8) return;
}

// C5
void SeqHeaderCmd_C5(group* group, macro* macro) {
    group->ushort_0x18 = Nas_ReadWordData(macro);
}

// C6
// Sets a flag and then stops parsing.
// Sequence canceled flag?
void SeqHeaderCmd_C6(group* group, macro* macro) {
    group->byte_0x0 |= 2;
    return; // Used in switch statement
}

// C7
// Patch sequence data?
void SeqHeaderCmd_C7(group* group, macro* macro) {
    u8 adjust = Nas_ReadByteData(macro);
    u16 offset = Nas_ReadWordData(macro);

    group->pByte_0x1C[offset] = (byte)(group->char_0x95 + adjust);
}

// C8
// Subtract from work byte
void SeqHeaderCmd_C8(group* group, macro* macro) {
    group->char_0x95 -= Nas_ReadByteData(macro);
}

// C9
// Mask work byte
void SeqHeaderCmd_C9(group* group, macro* macro) {
    group->char_0x95 &= Nas_ReadByteData(macro);
}

// CC
// Set work byte
void SeqHeaderCmd_CC(group* group, macro* macro) {
    group->char_0x95 = Nas_ReadByteData(macro);
}

// CD
//
void SeqHeaderCmd_CD(group* group, macro* macro) {
    u8 adjust = Nas_ReadByteData(macro);
    if (group->char_0x95 != -1) {
        if (group->byte_0x94 != 3) {
            group->byte_0x94++;
            macro[group->byte_0x94] = *macro;
            *macro = group->pByte_0x1C + ((short*)group->pByte_0x1C)[group->char_0x95 + adjust];
        }
    }
}

// 0xCE
void SeqHeaderCmd_CE(group* group, macro* macro) {
    u8 val = Nas_ReadByteData(macro);
    if (val == 0) {
        group->char_0x95 = (char)(SET_WORD >> 2);
    }
    else {
        group->char_0x95 = (char)((SET_WORD >> 2) - ((SET_WORD >> 2) / val) * val;
    }
}

// 0xD0
void SeqHeaderCmd_D0(group* group, macro* macro) { {
    group->byte_0x2 = Nas_ReadByteData(macro);
}

// 0xD1
void SeqHeaderCmd_D1(group* group, macro* macro) { {
    group->pByte_0x9C = group->pByte_0x1C + Nas_ReadByteData(macro);
}

// 0xD2
void SeqHeaderCmd_D2(group* group, macro* macro) { {
    group->pByte_0x98 = group->pByte_0x1C + Nas_ReadByteData(macro);
}

// 0xD3
void SeqHeaderCmd_D3(group* group, macro* macro) { {
    group->byte_0x3 = Nas_ReadByteData(macro);
}

// 0xD4
void SeqHeaderCmd_D4(group* group, macro* macro) { {
    group->byte_0x0 |= 0x20;
}

// 0xD5
void SeqHeaderCmd_D5(group* group, macro* macro) { {
    group->float_0x2C = (float)Nas_ReadByteData(macro) / 127.0;
}

// 0xD6
// Disable channels. Unused.
void SeqHeaderCmd_D6(group* group, macro* macro) { {
    Nas_ReadWordData(macro);
}

// 0xD7
// Enable channels.
void SeqHeaderCmd_D7(group* group, macro* macro) { {
    Nas_AllocSub(group, Nas_ReadWordData(macro));
}

// 0xD9
void SeqHeaderCmd_D9(group* group, macro* macro) { {
    group->float_0x30 = (float)Nas_ReadByteData(macro) / 127.0;
}

// 0xDA
void SeqHeaderCmd_DA(group* group, macro* macro) { {
    u8 type = Nas_ReadByteData(macro);
    u16 unk = Nas_ReadWordData(macro);

    if (type == 2) {
        group->short_0x14 = unk;
        group->byte_0x1 = type;
        group->float_0x24 = -group->float_0x20 / (float)group->short_0x14;
    }
    else if (type < 2 && group->byte_0x1 != 2) {
        group->short_0x16 = unk;
        group->byte_0x1 = type;
    }
}

// 0xDB
void SeqHeaderCmd_DB_SetMasterVolume(group* group, macro* macro);
    masterVolume = (float)ReadByteData(macro) / 127.0f;
    if (group->byte_0x1 == 1) {
        group->float_0x20 = 1.0f;
        group->byte_0x1 = 0; // Reset state?
    }
    else {
        if (group->byte_0x1 != 0) break;
    }

    group->short_0x14 = group->short_0x16;
    if (group->short_0x16 == 0) {
        group->float_0x20 = masterVolume;
    }
    else {
        // Fade volume in?
        group->float_0x24 = (masterVolume - group->float_0x20) / (float)group->short_0x14;
    }
}

// 0xDC
// Something similar to tempo like 0xDD
void SeqHeaderCmd_DC(group* group, macro* macro) {
    group->short_0xE = (s16)(s8)ReadByteData(macro) * 48;
}

// 0xDD
// Tempo control
void SeqHeaderCmd_DD_SetTempo(group* group, macro* macro) {
    group->ushort_0xA = (u16)ReadByteData(macro) * 48; // Tempo
    if ((int)SOME_DATA < (int)group->ushort_0xA) {
        group->ushort_0xA = SOME_DATA;
    }

    if ((s8)group->ushort_0xA < 1) {
        group->ushort_0xA = 1;
    }
}

// 0xDE
void SeqHeaderCmd_DE(group* group, macro* macro) {
    group->short_0x10 += (short)(char)ReadByteData(macro);
}

// 0xDF
void SeqHeaderCmd_DF(group* group, macro* macro) {
    group->short_0x10 = 0;
}

// 0xEF
// Unused
void SeqHeaderCmd_EF(group* group, macro* macro) {
    ReadByteData(macro);
    ReadWordData(macro);
}

// 0xF0
void SeqHeaderCmd_F0(group* group, macro* macro) {
    Nas_DeAllocAllVoices(group->channelNodes); // group->chnode_0xA0[4]
}

// 0xF1
void SeqHeaderCmd_F1(group* group, macro* macro) {
    Nas_DeAllocAllVoices(group->channelNodes);
    Nas_AllocVoices(group->channelNodes, Nas_ReadByteData(macro));
}

// 0xF2
// Conditional skip when macro->char_0x19 < 0
// Skips 0xXXXX bytes of the header.
void SeqHeaderCmd_F2(group* group, macro* macro) {
    u16 offset = Nas_ReadWordData(macro);
    if (macro->char_0x19 < 0) {
        macro->data += offset;
    }
}

// 0xF3
// Conditional skip when macro->char_0x19 == 0
// Skips 0xXXXX bytes of the header.
void SeqHeaderCmd_F3(group* group, macro* macro) {
    u16 offset = Nas_ReadWordData(macro);
    if (macro->char_0x19 == 0) {
        macro->data += offset;
    }
}

// 0xF4
// Skips some sequence header data.
// Skips 0xXXXX bytes of the header.
void SeqHeaderCmd_F3(group* group, macro* macro) {
    macro->data += Nas_ReadWordData(macro);
}

// 0xF5
// Conditional jump when macro->char_0x19 > -1
void SeqHeaderCmd_F5(group* group, macro* macro) {
    u16 offset = Nas_ReadWordData(macro);
    if (macro->char_0x19 > -1) {
        macro->data = group->pByte_0x1C + offset;
    }
}

// 0xF6
// Decrement stack idx in the macro.
void SeqHeaderCmd_F6(group* group, macro* macro) {
    macro->stackIdx -= 1;
}

// 0xF7
// Execute counted loop
void SeqHeaderCmd_F6(group* group, macro* macro) {
    macro->stackArgs[macro->stackIdx]--;
    if (macro->stackArgs[macro->stackIdx] == 0) {
        macro->stackIdx--;
    }
    else {
        macro->data = macro->stack[macro->stackIdx];
    }
}

// 0xF8
// Set counted cmd loop
// Saves the address of the current command & the number of times the loop should execute.
void SeqHeaderCmd_F8(group* group, macro* macro, u16 args) {
    macro->stackArgs[macro->stackIdx] = (s8)args;
    macro->stack[macro->stackIdx++] = macro->data;
}

// 0xF9
// Conditional jump when macro->char_0x19 < 0
void SeqHeaderCmd_F9(group* group, macro* macro) {
    u16 offset = Nas_ReadWordData(macro);
    if (macro->char_0x19 < 0) {
        macro->data = group->pByte_0x1C + offset;
    }
}

// 0xFA
// Conditional jump when macro->char_0x19 == 0
void SeqHeaderCmd_FA(group* group, macro* macro) {
    u16 offset = Nas_ReadWordData(macro);
    if (macro->char_0x19 == 0) {
        macro->data = group->pByte_0x1C + offset;
    }
}

// 0xFB
// Jump to offset (used in loops)
void SeqHeaderCmd_FB(group* group, macro* macro) {
    macro->data = group->pByte_0x1C + Nas_ReadWordData(macro);
}

// 0xFC
// Jump to offset with return stack link
void SeqHeaderCmd_FC(group* group, macro* macro) {
    macro->stack[macro->stackIdx++] = macro->data;
    macro->data = group->pByte_0x1C + ReadWordData(macro);
}

// 0xFD
// Next command process time delay
short SeqHeaderCmd_FD(group* group, macro* macro) {
    return Nas_ReadLengthData(macro);
}

// 0xFE
short SeqHeaderCmd_FE(group* group, macro* macro) {
    return 1;
}

// 0xFF
// Sequence Header Termination
short SeqHeaderCmd_FF(group* group, macro* macro) {
    if (macro->stackIdx == 0) {
        return -1; // Ends the current header stack
    }

    macro->stackIdx--;
    macro->data = macro->stack[macro->stackIdx];

    return 0;
}