diff --git a/include/jaudio_NES/audiocommon.h b/include/jaudio_NES/audiocommon.h index 7c5d2d36..46f27370 100644 --- a/include/jaudio_NES/audiocommon.h +++ b/include/jaudio_NES/audiocommon.h @@ -401,22 +401,485 @@ typedef enum AudioCmd { /* 0xFF */ AUDIOCMD_MAIN_GROUP_SET_VOL_SCALE } AudioCmd; -typedef enum SeqCmd { - SEQCMD_BRANCH_REL_NOT_EQ_ZERO = 0xF2, - SEQCMD_BRANCH_REL_EQ_ZERO = 0xF3, - SEQCMD_BRANCH_REL = 0xF4, - SEQCMD_BRANCH_ABS_GREQ_ZERO = 0xF5, - SEQCMD_BREAK = 0xF6, - SEQCMD_LOOP_END = 0xF7, - SEQCMD_LOOP = 0xF8, - SEQCMD_BRANCH_ABS_NOT_EQ_ZERO = 0xF9, - SEQCMD_BRANCH_ABS_EQ_ZERO = 0xFA, - SEQCMD_BRANCH_ABS = 0xFB, - SEQCMD_CALL = 0xFC, - SEQCMD_DELAY_N_FRAMES = 0xFD, - SEQCMD_DELAY_1_FRAME = 0xFE, - SEQCMD_STOP_SCRIPT = 0xFF, -} SeqCmd; +typedef enum CommonCmd { + COMMON_CMD_BRANCH_REL_NOT_EQ_ZERO = 0xF2, + COMMON_CMD_BRANCH_REL_EQ_ZERO = 0xF3, + COMMON_CMD_BRANCH_REL = 0xF4, + COMMON_CMD_BRANCH_ABS_GREQ_ZERO = 0xF5, + COMMON_CMD_BREAK = 0xF6, + COMMON_CMD_LOOP_END = 0xF7, + COMMON_CMD_LOOP = 0xF8, + COMMON_CMD_BRANCH_ABS_NOT_EQ_ZERO = 0xF9, + COMMON_CMD_BRANCH_ABS_EQ_ZERO = 0xFA, + COMMON_CMD_BRANCH_ABS = 0xFB, + COMMON_CMD_CALL = 0xFC, + COMMON_CMD_DELAY_N_FRAMES = 0xFD, + COMMON_CMD_DELAY_1_FRAME = 0xFE, + COMMON_CMD_STOP_SCRIPT = 0xFF, +} CommonCmd; + +typedef enum GroupCmd { + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK_DISABLED_MASK = 0x00, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK0_DISABLED = 0x00, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK1_DISABLED = 0x01, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK2_DISABLED = 0x02, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK3_DISABLED = 0x03, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK4_DISABLED = 0x04, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK5_DISABLED = 0x05, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK6_DISABLED = 0x06, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK7_DISABLED = 0x07, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK8_DISABLED = 0x08, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK9_DISABLED = 0x09, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK10_DISABLED = 0x0A, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK11_DISABLED = 0x0B, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK12_DISABLED = 0x0C, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK13_DISABLED = 0x0D, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK14_DISABLED = 0x0E, + GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK15_DISABLED = 0x0F, + + GRP_CMD_DISABLE_SUBTRACK_MASK = 0x40, + GRP_CMD_DISABLE_SUBTRACK0 = 0x40, + GRP_CMD_DISABLE_SUBTRACK1 = 0x41, + GRP_CMD_DISABLE_SUBTRACK2 = 0x42, + GRP_CMD_DISABLE_SUBTRACK3 = 0x43, + GRP_CMD_DISABLE_SUBTRACK4 = 0x44, + GRP_CMD_DISABLE_SUBTRACK5 = 0x45, + GRP_CMD_DISABLE_SUBTRACK6 = 0x46, + GRP_CMD_DISABLE_SUBTRACK7 = 0x47, + GRP_CMD_DISABLE_SUBTRACK8 = 0x48, + GRP_CMD_DISABLE_SUBTRACK9 = 0x49, + GRP_CMD_DISABLE_SUBTRACK10 = 0x4A, + GRP_CMD_DISABLE_SUBTRACK11 = 0x4B, + GRP_CMD_DISABLE_SUBTRACK12 = 0x4C, + GRP_CMD_DISABLE_SUBTRACK13 = 0x4D, + GRP_CMD_DISABLE_SUBTRACK14 = 0x4E, + GRP_CMD_DISABLE_SUBTRACK15 = 0x4F, + + GRP_CMD_MACRO_VALUE_SUBTRACT_FROM_PORT_MASK = 0x50, + GRP_CMD_MACRO_VALUE_SUBTRACT_BY_PORT0 = 0x50, + GRP_CMD_MACRO_VALUE_SUBTRACT_BY_PORT1 = 0x51, + GRP_CMD_MACRO_VALUE_SUBTRACT_BY_PORT2 = 0x52, + GRP_CMD_MACRO_VALUE_SUBTRACT_BY_PORT3 = 0x53, + GRP_CMD_MACRO_VALUE_SUBTRACT_BY_PORT4 = 0x54, + GRP_CMD_MACRO_VALUE_SUBTRACT_BY_PORT5 = 0x55, + GRP_CMD_MACRO_VALUE_SUBTRACT_BY_PORT6 = 0x56, + GRP_CMD_MACRO_VALUE_SUBTRACT_BY_PORT7 = 0x57, + + GRP_CMD_ASYNC_LOAD_MASK = 0x60, + GRP_CMD_ASYNC_LOAD_PORT0 = 0x60, + GRP_CMD_ASYNC_LOAD_PORT1 = 0x61, + GRP_CMD_ASYNC_LOAD_PORT2 = 0x62, + GRP_CMD_ASYNC_LOAD_PORT3 = 0x63, + GRP_CMD_ASYNC_LOAD_PORT4 = 0x64, + GRP_CMD_ASYNC_LOAD_PORT5 = 0x65, + GRP_CMD_ASYNC_LOAD_PORT6 = 0x66, + GRP_CMD_ASYNC_LOAD_PORT7 = 0x67, + + GRP_CMD_MACRO_VALUE_WRITE_PORT_MASK = 0x70, + GRP_CMD_MACRO_VALUE_WRITE_PORT0 = 0x70, + GRP_CMD_MACRO_VALUE_WRITE_PORT1 = 0x71, + GRP_CMD_MACRO_VALUE_WRITE_PORT2 = 0x72, + GRP_CMD_MACRO_VALUE_WRITE_PORT3 = 0x73, + GRP_CMD_MACRO_VALUE_WRITE_PORT4 = 0x74, + GRP_CMD_MACRO_VALUE_WRITE_PORT5 = 0x75, + GRP_CMD_MACRO_VALUE_WRITE_PORT6 = 0x76, + GRP_CMD_MACRO_VALUE_WRITE_PORT7 = 0x77, + + GRP_CMD_MACRO_VALUE_READ_PORT_MASK = 0x80, + GRP_CMD_MACRO_VALUE_READ_PORT0 = 0x80, // cleared to 0xFF on read + GRP_CMD_MACRO_VALUE_READ_PORT1 = 0x81, // cleared to 0xFF on read + GRP_CMD_MACRO_VALUE_READ_PORT2 = 0x82, + GRP_CMD_MACRO_VALUE_READ_PORT3 = 0x83, + GRP_CMD_MACRO_VALUE_READ_PORT4 = 0x84, + GRP_CMD_MACRO_VALUE_READ_PORT5 = 0x85, + GRP_CMD_MACRO_VALUE_READ_PORT6 = 0x86, + GRP_CMD_MACRO_VALUE_READ_PORT7 = 0x87, + + // Absolute address + GRP_CMD_START_SUBTRACK_MASK = 0x90, + GRP_CMD_START_SUBTRACK0 = 0x90, + GRP_CMD_START_SUBTRACK1 = 0x91, + GRP_CMD_START_SUBTRACK2 = 0x92, + GRP_CMD_START_SUBTRACK3 = 0x93, + GRP_CMD_START_SUBTRACK4 = 0x94, + GRP_CMD_START_SUBTRACK5 = 0x95, + GRP_CMD_START_SUBTRACK6 = 0x96, + GRP_CMD_START_SUBTRACK7 = 0x97, + GRP_CMD_START_SUBTRACK8 = 0x98, + GRP_CMD_START_SUBTRACK9 = 0x99, + GRP_CMD_START_SUBTRACK10 = 0x9A, + GRP_CMD_START_SUBTRACK11 = 0x9B, + GRP_CMD_START_SUBTRACK12 = 0x9C, + GRP_CMD_START_SUBTRACK13 = 0x9D, + GRP_CMD_START_SUBTRACK14 = 0x9E, + GRP_CMD_START_SUBTRACK15 = 0x9F, + + // Relative address + GRP_CMD_START_RELATIVE_SUBTRACK_MASK = 0xA0, + GRP_CMD_START_RELATIVE_SUBTRACK0 = 0xA0, + GRP_CMD_START_RELATIVE_SUBTRACK1 = 0xA1, + GRP_CMD_START_RELATIVE_SUBTRACK2 = 0xA2, + GRP_CMD_START_RELATIVE_SUBTRACK3 = 0xA3, + GRP_CMD_START_RELATIVE_SUBTRACK4 = 0xA4, + GRP_CMD_START_RELATIVE_SUBTRACK5 = 0xA5, + GRP_CMD_START_RELATIVE_SUBTRACK6 = 0xA6, + GRP_CMD_START_RELATIVE_SUBTRACK7 = 0xA7, + GRP_CMD_START_RELATIVE_SUBTRACK8 = 0xA8, + GRP_CMD_START_RELATIVE_SUBTRACK9 = 0xA9, + GRP_CMD_START_RELATIVE_SUBTRACK10 = 0xAA, + GRP_CMD_START_RELATIVE_SUBTRACK11 = 0xAB, + GRP_CMD_START_RELATIVE_SUBTRACK12 = 0xAC, + GRP_CMD_START_RELATIVE_SUBTRACK13 = 0xAD, + GRP_CMD_START_RELATIVE_SUBTRACK14 = 0xAE, + GRP_CMD_START_RELATIVE_SUBTRACK15 = 0xAF, + + // Result is placed in port[X] + GRP_CMD_SEQ_LOAD_MASK = 0xB0, + GRP_CMD_SEQ_LOAD_PORT0 = 0xB0, + GRP_CMD_SEQ_LOAD_PORT1 = 0xB1, + GRP_CMD_SEQ_LOAD_PORT2 = 0xB2, + GRP_CMD_SEQ_LOAD_PORT3 = 0xB3, + GRP_CMD_SEQ_LOAD_PORT4 = 0xB4, + GRP_CMD_SEQ_LOAD_PORT5 = 0xB5, + GRP_CMD_SEQ_LOAD_PORT6 = 0xB6, + GRP_CMD_SEQ_LOAD_PORT7 = 0xB7, + + GRP_CMD_CALLBACK = 0xBE, + + GRP_CMD_C1 = 0xC1, // unused + GRP_CMD_DYNAMIC_BRANCH = 0xC2, + GRP_CMD_MUTE_SUBTRACKS = 0xC3, + GRP_CMD_START_SEQ = 0xC4, + GRP_CMD_UPDATE_COUNTER = 0xC5, + GRP_CMD_STOP_SEQ = 0xC6, + GRP_CMD_MACRO_VALUE_STORE = 0xC7, + GRP_CMD_MACRO_VALUE_SUBTRACT = 0xC8, + GRP_CMD_MACRO_VALUE_BIT_AND = 0xC9, + GRP_CMD_CA = 0xCA, // unused + GRP_CMD_CB = 0xCB, // unused + GRP_CMD_MACRO_VALUE_LOAD = 0xCC, + GRP_CMD_DYN_TBL_CALL = 0xCD, + GRP_CMD_MACRO_VALUE_RANDOM = 0xCE, + GRP_CMD_CF = 0xCF, // unused + + GRP_CMD_SET_NOTE_ALLOC_POLICY = 0xD0, + GRP_CMD_SET_SHORT_NOTE_GATE_TIME_TBL = 0xD1, + GRP_CMD_SET_SHORT_NOTE_VELOCITY_TBL = 0xD2, + GRP_CMD_SET_MUTE_BEHAVIOR = 0xD3, + GRP_CMD_MUTE = 0xD4, + GRP_CMD_SET_MUTE_SCALE = 0xD5, + GRP_CMD_DISABLE_SUBTRACKS = 0xD6, // non-functional + GRP_CMD_ALLOC_SUBTRACKS = 0xD7, + GRP_CMD_D8 = 0xD8, // unused? + GRP_CMD_SET_VOLUME_SCALE = 0xD9, + GRP_CMD_CHANGE_VOLUME = 0xDA, + GRP_CMD_SET_VOLUME = 0xDB, + GRP_CMD_SET_TEMPO_CHANGE = 0xDC, + GRP_CMD_SET_TEMPO = 0xDD, + GRP_CMD_TRANSPOSITION_RELATIVE = 0xDE, + GRP_CMD_TRANSPOSITION_ABSOLUTE = 0xDF, + + GRP_CMD_EF = 0xEF, // non-functional + + GRP_CMD_RELEASE_VOICES = 0xF0, + GRP_CMD_RESERVE_VOICES = 0xF1, +} GroupCmd; + +typedef enum SubtrackCmd { + SUBTRACK_CMD_DELAY_MASK = 0x00, + SUBTRACK_CMD_DELAY_CLEAR = 0x00, // remove delay + SUBTRACK_CMD_DELAY_1 = 0x01, // delay 1 frame + SUBTRACK_CMD_DELAY_2 = 0x02, // delay 2 frames + SUBTRACK_CMD_DELAY_3 = 0x03, // delay 3 frames + SUBTRACK_CMD_DELAY_4 = 0x04, // delay 4 frames + SUBTRACK_CMD_DELAY_5 = 0x05, // delay 5 frames + SUBTRACK_CMD_DELAY_6 = 0x06, // delay 6 frames + SUBTRACK_CMD_DELAY_7 = 0x07, // delay 7 frames + SUBTRACK_CMD_DELAY_8 = 0x08, // delay 8 frames + SUBTRACK_CMD_DELAY_9 = 0x09, // delay 9 frames + SUBTRACK_CMD_DELAY_10 = 0x0A, // delay 10 frames + SUBTRACK_CMD_DELAY_11 = 0x0B, // delay 11 frames + SUBTRACK_CMD_DELAY_12 = 0x0C, // delay 12 frames + SUBTRACK_CMD_DELAY_13 = 0x0D, // delay 13 frames + SUBTRACK_CMD_DELAY_14 = 0x0E, // delay 14 frames + SUBTRACK_CMD_DELAY_15 = 0x0F, // delay 15 frames + + SUBTRACK_CMD_VOICELOAD_MASK = 0x10, + SUBTRACK_CMD_VOICELOAD_PORT0 = 0x10, // loads instrument samples using the subtrack's instrument bank id and the instrument id from macro->value, result in subrack->port[cmd & 7] + SUBTRACK_CMD_VOICELOAD_PORT1 = 0x11, + SUBTRACK_CMD_VOICELOAD_PORT2 = 0x12, + SUBTRACK_CMD_VOICELOAD_PORT3 = 0x13, + SUBTRACK_CMD_VOICELOAD_PORT4 = 0x14, + SUBTRACK_CMD_VOICELOAD_PORT5 = 0x15, + SUBTRACK_CMD_VOICELOAD_PORT6 = 0x16, + SUBTRACK_CMD_VOICELOAD_PORT7 = 0x17, + SUBTRACK_CMD_SYNTHLOAD_PORT0 = 0x18, // loads synth instrument samples? from subtrack bank id and 0x100 + subtrack->dynamic_value, result is placed in subtrack->port[cmd & 7] + SUBTRACK_CMD_SYNTHLOAD_PORT1 = 0x19, + SUBTRACK_CMD_SYNTHLOAD_PORT2 = 0x1A, + SUBTRACK_CMD_SYNTHLOAD_PORT3 = 0x1B, + SUBTRACK_CMD_SYNTHLOAD_PORT4 = 0x1C, + SUBTRACK_CMD_SYNTHLOAD_PORT5 = 0x1D, + SUBTRACK_CMD_SYNTHLOAD_PORT6 = 0x1E, + SUBTRACK_CMD_SYNTHLOAD_PORT7 = 0x1F, + + // These commands start a new subtrack with its PC set to group->seq_data[param] + SUBTRACK_CMD_START_SUBTRACK_MASK = 0x20, + SUBTRACK_CMD_START_SUBTRACK0 = 0x20, + SUBTRACK_CMD_START_SUBTRACK1 = 0x21, + SUBTRACK_CMD_START_SUBTRACK2 = 0x22, + SUBTRACK_CMD_START_SUBTRACK3 = 0x23, + SUBTRACK_CMD_START_SUBTRACK4 = 0x24, + SUBTRACK_CMD_START_SUBTRACK5 = 0x25, + SUBTRACK_CMD_START_SUBTRACK6 = 0x26, + SUBTRACK_CMD_START_SUBTRACK7 = 0x27, + SUBTRACK_CMD_START_SUBTRACK8 = 0x28, + SUBTRACK_CMD_START_SUBTRACK9 = 0x29, + SUBTRACK_CMD_START_SUBTRACK10 = 0x2A, + SUBTRACK_CMD_START_SUBTRACK11 = 0x2B, + SUBTRACK_CMD_START_SUBTRACK12 = 0x2C, + SUBTRACK_CMD_START_SUBTRACK13 = 0x2D, + SUBTRACK_CMD_START_SUBTRACK14 = 0x2E, + SUBTRACK_CMD_START_SUBTRACK15 = 0x2F, + + // These commands write to another subtrack's input/output ports at subtrack[cmd & 0xF]->ports[param] + SUBTRACK_CMD_WRITE_SUBTRACK_PORT_MASK = 0x30, + SUBTRACK_CMD_WRITE_SUBTRACK0_PORT = 0x30, + SUBTRACK_CMD_WRITE_SUBTRACK1_PORT = 0x31, + SUBTRACK_CMD_WRITE_SUBTRACK2_PORT = 0x32, + SUBTRACK_CMD_WRITE_SUBTRACK3_PORT = 0x33, + SUBTRACK_CMD_WRITE_SUBTRACK4_PORT = 0x34, + SUBTRACK_CMD_WRITE_SUBTRACK5_PORT = 0x35, + SUBTRACK_CMD_WRITE_SUBTRACK6_PORT = 0x36, + SUBTRACK_CMD_WRITE_SUBTRACK7_PORT = 0x37, + SUBTRACK_CMD_WRITE_SUBTRACK8_PORT = 0x38, + SUBTRACK_CMD_WRITE_SUBTRACK9_PORT = 0x39, + SUBTRACK_CMD_WRITE_SUBTRACK10_PORT = 0x3A, + SUBTRACK_CMD_WRITE_SUBTRACK11_PORT = 0x3B, + SUBTRACK_CMD_WRITE_SUBTRACK12_PORT = 0x3C, + SUBTRACK_CMD_WRITE_SUBTRACK13_PORT = 0x3D, + SUBTRACK_CMD_WRITE_SUBTRACK14_PORT = 0x3E, + SUBTRACK_CMD_WRITE_SUBTRACK15_PORT = 0x3F, + + // These commands read another subtrack's input/output port value into this subtrack's macro->value register, same logic as writing + SUBTRACK_CMD_READ_SUBTRACK_PORT_MASK = 0x40, + SUBTRACK_CMD_READ_SUBTRACK0_PORT = 0x40, + SUBTRACK_CMD_READ_SUBTRACK1_PORT = 0x41, + SUBTRACK_CMD_READ_SUBTRACK2_PORT = 0x42, + SUBTRACK_CMD_READ_SUBTRACK3_PORT = 0x43, + SUBTRACK_CMD_READ_SUBTRACK4_PORT = 0x44, + SUBTRACK_CMD_READ_SUBTRACK5_PORT = 0x45, + SUBTRACK_CMD_READ_SUBTRACK6_PORT = 0x46, + SUBTRACK_CMD_READ_SUBTRACK7_PORT = 0x47, + SUBTRACK_CMD_READ_SUBTRACK8_PORT = 0x48, + SUBTRACK_CMD_READ_SUBTRACK9_PORT = 0x49, + SUBTRACK_CMD_READ_SUBTRACK10_PORT = 0x4A, + SUBTRACK_CMD_READ_SUBTRACK11_PORT = 0x4B, + SUBTRACK_CMD_READ_SUBTRACK12_PORT = 0x4C, + SUBTRACK_CMD_READ_SUBTRACK13_PORT = 0x4D, + SUBTRACK_CMD_READ_SUBTRACK14_PORT = 0x4E, + SUBTRACK_CMD_READ_SUBTRACK15_PORT = 0x4F, + + // These commands subtract the value in port[X] from the subtrack's macro value register + SUBTRACK_CMD_MACRO_SUBTRACT_MASK = 0x50, + SUBTRACK_CMD_MACRO_SUBTRACT_PORT0 = 0x50, + SUBTRACK_CMD_MACRO_SUBTRACT_PORT1 = 0x51, + SUBTRACK_CMD_MACRO_SUBTRACT_PORT2 = 0x52, + SUBTRACK_CMD_MACRO_SUBTRACT_PORT3 = 0x53, + SUBTRACK_CMD_MACRO_SUBTRACT_PORT4 = 0x54, + SUBTRACK_CMD_MACRO_SUBTRACT_PORT5 = 0x55, + SUBTRACK_CMD_MACRO_SUBTRACT_PORT6 = 0x56, + SUBTRACK_CMD_MACRO_SUBTRACT_PORT7 = 0x57, + + // These commands read the value in port[X] into the subtrack's macro value register + // When the port is 0 or 1, the port value is set to -1 + SUBTRACK_CMD_MACRO_READ_PORT0_MASK = 0x60, + SUBTRACK_CMD_MACRO_READ_PORT0 = 0x60, + SUBTRACK_CMD_MACRO_READ_PORT1 = 0x61, + SUBTRACK_CMD_MACRO_READ_PORT2 = 0x62, + SUBTRACK_CMD_MACRO_READ_PORT3 = 0x63, + SUBTRACK_CMD_MACRO_READ_PORT4 = 0x64, + SUBTRACK_CMD_MACRO_READ_PORT5 = 0x65, + SUBTRACK_CMD_MACRO_READ_PORT6 = 0x66, + SUBTRACK_CMD_MACRO_READ_PORT7 = 0x67, + + SUBTRACK_CMD_PORT_WRITE_MACRO_REG_MASK = 0x70, + SUBTRACK_CMD_PORT0_WRITE_MACRO_REG = 0x70, + SUBTRACK_CMD_PORT1_WRITE_MACRO_REG = 0x71, + SUBTRACK_CMD_PORT2_WRITE_MACRO_REG = 0x72, + SUBTRACK_CMD_PORT3_WRITE_MACRO_REG = 0x73, + SUBTRACK_CMD_PORT4_WRITE_MACRO_REG = 0x74, + SUBTRACK_CMD_PORT5_WRITE_MACRO_REG = 0x75, + SUBTRACK_CMD_PORT6_WRITE_MACRO_REG = 0x76, + SUBTRACK_CMD_PORT7_WRITE_MACRO_REG = 0x77, + + // Notes start at current subtrack PC + param + SUBTRACK_CMD_NOTE_START_MASK = 0x78, // not really the mask but w/e + SUBTRACk_CMD_NOTE0_START = 0x78, + SUBTRACk_CMD_NOTE1_START = 0x79, + SUBTRACk_CMD_NOTE2_START = 0x7A, + SUBTRACk_CMD_NOTE3_START = 0x7B, + + SUBTRACK_CMD_READ_NOTE_FINISHED_MASK = 0x80, + SUBTRACK_CMD_READ_NOTE0_FINISHED = 0x80, + SUBTRACK_CMD_READ_NOTE1_FINISHED = 0x81, + SUBTRACK_CMD_READ_NOTE2_FINISHED = 0x82, + SUBTRACK_CMD_READ_NOTE3_FINISHED = 0x83, + + SUBTRACK_CMD_NOTE_SET_PC_MASK = 0x88, // not really the mask but w/e + SUBTRACK_CMD_NOTE0_SET_PC = 0x88, + SUBTRACK_CMD_NOTE1_SET_PC = 0x89, + SUBTRACK_CMD_NOTE2_SET_PC = 0x8A, + SUBTRACK_CMD_NOTE3_SET_PC = 0x8B, + + SUBTRACK_CMD_NOTE_STOP_MASK = 0x90, + SUBTRACK_CMD_NOTE0_STOP = 0x90, + SUBTRACK_CMD_NOTE1_STOP = 0x91, + SUBTRACK_CMD_NOTE2_STOP = 0x92, + SUBTRACK_CMD_NOTE3_STOP = 0x93, + + // Notes start at group sequence + dyn_tbl[macro->value] + SUBTRACK_CMD_NOTE_START_DYNTBL_MASK = 0x98, // not really the mask but w/e + SUBTRACK_CMD_NOTE0_START_DYNTBL = 0x98, + SUBTRACK_CMD_NOTE1_START_DYNTBL = 0x99, + SUBTRACK_CMD_NOTE2_START_DYNTBL = 0x9A, + SUBTRACK_CMD_NOTE3_START_DYNTBL = 0x9B, + + SUBTRACK_CMD_MACRO_LOAD_FROM_SFX_STATE = 0xA0, // loads a macro register value from the SFX state using the command param as the offset + SUBTRACK_CMD_MACRO_LOAD_FROM_SFX_STATE_DYNVAL = 0xA1, // loads the macro register value from the SFX state using the dynamic value as the offset + SUBTRACK_CMD_SFX_STATE_SET = 0xA2, // sets the SFX state using the command param as the offset + SUBTRACK_CMD_SFX_STATE_SET_DYNVAL = 0xA3, // sets the SFX state using the dynamic value as the offset + SUBTRACK_CMD_SURROUND_EFFECT_IDX_SET = 0xA4, // sets the surround effect index + SUBTRACK_CMD_MACRO_ADD_SUBTRACK_IDX = 0xA5, // adds the subtrack index to the macro register value + SUBTRACK_CMD_WRITE_GOUP_SEQ_OFFSET_BY_SUBTRACK = 0xA6, // writes a value into the parent group sequence with the offset being a param plus the subtrack id + SUBTRACK_CMD_MACRO_BIT_MOD = 0xA7, // performs a bitwise operation on the macro register value + SUBTRACK_CMD_DYNVAL_SPECIAL = 0xA8, // performs a special operation on the dynamic value + + SUBTRACK_CMD_SET_FILTER = 0xB0, // sets the subtrack filter + SUBTRACK_CMD_CLEAR_FILTER = 0xB1, // clears the subtrack filter + SUBTRACK_CMD_LOAD_DYNVAL_FROM_GROUP_SEQ = 0xB2, // loads the dynamic value from an offset into the parent group sequence + SUBTRACK_CMD_LOAD_FILTER = 0xB3, // loads filter from subtrack filter pointer with lowpass & hipass cutoff vals + SUBTRACK_CMD_SET_DYNTBL_FROM_GROUP_SEQ = 0xB4, // sets the dynamic table address relative to the parent group sequence + SUBTRACK_CMD_LOAD_DYNVAL_FROM_DYNTBL = 0xB5, // loads the dynamic value from the dynamic table + SUBTRACK_CMD_MACRO_LOAD_FROM_DYNTBL = 0xB6, // loads a macro register value from the dynamic table + SUBTRACK_CMD_RANDOM_DYNVAL = 0xB7, // generates a random value for the dynamic value, optionally constrained when param is non-zero + SUBTRACK_CMD_MACRO_RANDOM_VAL = 0xB8, // generates a random value for the macro register value, optionally constrained when param is non-zero + SUBTRACK_CMD_SET_VEL_RANDOM_VARIANCE = 0xB9, // sets the velocity random variance + SUBTRACK_CMD_SET_GATE_TIME_RANDOM_VARIANCE = 0xBA, // sets the gate time random variance + SUBTRACK_CMD_SET_COMB_FILTER_SIZE_GAIN = 0xBB, // sets the comb filter size and gain + SUBTRACK_CMD_ADD_DYNVAL = 0xBC, // adds the param to the current dynamic value + SUBTRACK_CMD_SET_SAMPLE_START_POS = 0xBD, // sets the sample start position + SUBTRACK_CMD_MACRO_SET_FROM_CALLBACK = 0xBE, // sets the macro register value from a callback + + SUBTRACK_CMD_VOICE_SET = 0xC1, + SUBTRACK_CMD_SET_DYNTBL = 0xC2, + SUBTRACK_CMD_LARGE_NOTE_ON = 0xC3, + SUBTRACK_CMD_LARGE_NOTE_OFF = 0xC4, + SUBTRACK_CMD_JMP_DYNTBL = 0xC5, + SUBTRACK_CMD_SET_INSTRUMENT_BANK = 0xC6, + SUBTRACK_CMD_WRITE_GROUP_SEQ = 0xC7, + SUBTRACK_CMD_MACRO_SUBTRACT = 0xC8, + SUBTRACK_CMD_MACRO_AND = 0xC9, + SUBTRACK_CMD_SET_MUTE_FLAGS = 0xCA, + SUBTRACK_CMD_MACRO_LOAD_FROM_GROUP_SEQ = 0xCB, + SUBTRACK_CMD_MACRO_SET = 0xCC, + SUBTRACK_CMD_DISABLE_SUBTRACK = 0xCD, + SUBTRACK_CMD_SET_DYNVAL = 0xCE, + SUBTRACK_CMD_WRITE_DYNVAL_TO_GROUP_SEQ = 0xCF, + + SUBTRACK_CMD_STEREO_PHASE_SET = 0xD0, + SUBTRACK_CMD_SET_NOTE_ALLOC_POLICY = 0xD1, + SUBTRACK_CMD_SET_SUSTAIN = 0xD2, + SUBTRACK_CMD_LARGE_BEND_PITCH = 0xD3, + SUBTRACK_CMD_SET_REVERB_VOL = 0xD4, + + SUBTRACK_CMD_SET_VIBRATO_RATE = 0xD7, + SUBTRACK_CMD_SET_VIBRATO_DEPTH = 0xD8, + SUBTRACK_CMD_SET_DECAY_IDX = 0xD9, + SUBTRACK_CMD_SET_ENVELOPE = 0xDA, + SUBTRACK_CMD_SET_TRANSPOSITION = 0xDB, + SUBTRACK_CMD_SET_PAN_WEIGHT = 0xDC, + SUBTRACK_CMD_SET_PAN = 0xDD, + SUBTRACK_CMD_SET_FREQ_SCALE = 0xDE, + SUBTRACK_CMD_SET_VOL = 0xDF, + + SUBTRACK_CMD_SET_VOL_SCALE = 0xE0, + SUBTRACK_CMD_SET_VIBRATO_RATE_LINEAR = 0xE1, + SUBTRACK_CMD_SET_VIBRATO_DEPTH_LINEAR = 0xE2, + SUBTRACK_CMD_SET_VIBRATO_DELAY = 0xE3, + SUBTRACK_CMD_DYNTBL_CALL = 0xE4, + SUBTRACK_CMD_SET_REVERB_IDX = 0xE5, + SUBTRACK_CMD_SET_BOOK_OFS = 0xE6, + SUBTRACK_CMD_SET_ENV_PARAMS_FROM_GROUP_SEQ = 0xE7, // offset into the parent group sequence is provided for data ofs + SUBTRACK_CMD_SET_ENV_PARAMS = 0xE8, // data is pulled from subtrack sequence + SUBTRACK_CMD_SET_PRIORITY = 0xE9, + SUBTRACK_CMD_STOP = 0xEA, + SUBTRACK_CMD_INIT_INSTRUMENTS = 0xEB, + SUBTRACK_CMD_RESET_VIBRATO = 0xEC, + SUBTRACK_CMD_SET_GAIN = 0xED, + SUBTRACK_CMD_SMALL_BEND_PITCH = 0xEE, + + SUBTRACK_CMD_DEALLOC_VOICES = 0xF0, + SUBTRACK_CMD_ALLOC_VOICES = 0xF1 +} SubtrackCmd; + +typedef enum NoteCmd { + + NOTE_CMD_MUTE = 0xC0, // mute for N frames + NOTE_CMD_SET_VELOCITY_SQ = 0xC1, + NOTE_CMD_SET_TRANSPOSITION = 0xC2, + NOTE_CMD_SET_SHORT_NOTE_DEFAULT_DELAY = 0xC3, + NOTE_CMD_CONTINUOUS_ON = 0xC4, + NOTE_CMD_CONTINUOUS_OFF = 0xC5, + NOTE_CMD_SET_INSTRUMENT = 0xC6, + NOTE_CMD_ENABLE_SWEEP = 0xC7, + NOTE_CMD_DISABLE_SWEEP = 0xC8, + NOTE_CMD_SET_GATE_TIME = 0xC9, + NOTE_CMD_SET_PAN = 0xCA, + NOTE_CMD_SET_ADSR_ENVELOPE_DECAY_IDX = 0xCB, + NOTE_CMD_IGNORE_DRUM_PAN = 0xCC, + NOTE_CMD_SET_STEREO_PHASE = 0xCD, + NOTE_CMD_SET_BEND = 0xCE, + NOTE_CMD_SET_ADSR_DECAY_IDX = 0xCF, + + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ_MASK = 0xD0, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ0 = 0xD0, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ1 = 0xD1, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ2 = 0xD2, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ3 = 0xD3, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ4 = 0xD4, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ5 = 0xD5, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ6 = 0xD6, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ7 = 0xD7, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ8 = 0xD8, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ9 = 0xD9, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ10 = 0xDA, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ11 = 0xDB, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ12 = 0xDC, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ13 = 0xDD, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ14 = 0xDE, + NOTE_CMD_SHORT_NOTE_VELOCITY_SQ15 = 0xDF, + + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME_MASK = 0xE0, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME0 = 0xE0, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME1 = 0xE1, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME2 = 0xE2, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME3 = 0xE3, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME4 = 0xE4, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME5 = 0xE5, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME6 = 0xE6, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME7 = 0xE7, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME8 = 0xE8, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME9 = 0xE9, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME10 = 0xEA, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME11 = 0xEB, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME12 = 0xEC, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME13 = 0xED, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME14 = 0xEE, + NOTE_CMD_SET_SHORT_NOTE_GATE_TIME15 = 0xEF, + + NOTE_CMD_DISABLE_FLAGS = 0xF0, + NOTE_CMD_SET_SURROUND_EFFECT_IDX = 0xF1, +} NoteCmd; typedef enum AUDIO_CALLBACKS { /* 0x00 */ AUDIO_CALLBACK_SEQ_0, diff --git a/src/static/jaudio_NES/internal/track.c b/src/static/jaudio_NES/internal/track.c index 8761f88f..33935b30 100644 --- a/src/static/jaudio_NES/internal/track.c +++ b/src/static/jaudio_NES/internal/track.c @@ -173,26 +173,26 @@ static s32 Common_Com(group* group, macro* macro, s32 cmd, s32 arg) { s8 rel; switch (cmd) { - case SEQCMD_STOP_SCRIPT: + case COMMON_CMD_STOP_SCRIPT: if (macro->depth == 0) { return COMMON_SCRIPT_END; } macro->pc = macro->stack[--macro->depth]; break; - case SEQCMD_DELAY_N_FRAMES: + case COMMON_CMD_DELAY_N_FRAMES: return Nas_ReadLengthData(macro); - case SEQCMD_DELAY_1_FRAME: + case COMMON_CMD_DELAY_1_FRAME: return 1; - case SEQCMD_CALL: + case COMMON_CMD_CALL: macro->stack[macro->depth++] = macro->pc; macro->pc = group->seq_data + (arg & 0xFFFF); break; - case SEQCMD_LOOP: + case COMMON_CMD_LOOP: macro->remaining_loop_iters[macro->depth] = arg & 0xFF; macro->stack[macro->depth++] = macro->pc; break; - case SEQCMD_LOOP_END: + case COMMON_CMD_LOOP_END: iters = macro->remaining_loop_iters[macro->depth - 1]; iters--; macro->remaining_loop_iters[macro->depth - 1] = iters; @@ -202,31 +202,31 @@ static s32 Common_Com(group* group, macro* macro, s32 cmd, s32 arg) { macro->depth--; } break; - case SEQCMD_BREAK: + case COMMON_CMD_BREAK: macro->depth--; break; - case SEQCMD_BRANCH_ABS_GREQ_ZERO: - case SEQCMD_BRANCH_ABS_NOT_EQ_ZERO: - case SEQCMD_BRANCH_ABS_EQ_ZERO: - case SEQCMD_BRANCH_ABS: + case COMMON_CMD_BRANCH_ABS_GREQ_ZERO: + case COMMON_CMD_BRANCH_ABS_NOT_EQ_ZERO: + case COMMON_CMD_BRANCH_ABS_EQ_ZERO: + case COMMON_CMD_BRANCH_ABS: abs = arg & 0xFFFF; - if (cmd == SEQCMD_BRANCH_ABS_EQ_ZERO && macro->value != 0) { + if (cmd == COMMON_CMD_BRANCH_ABS_EQ_ZERO && macro->value != 0) { break; - } else if (cmd == SEQCMD_BRANCH_ABS_NOT_EQ_ZERO && macro->value >= 0) { + } else if (cmd == COMMON_CMD_BRANCH_ABS_NOT_EQ_ZERO && macro->value >= 0) { break; - } else if (cmd == SEQCMD_BRANCH_ABS_GREQ_ZERO && macro->value < 0) { + } else if (cmd == COMMON_CMD_BRANCH_ABS_GREQ_ZERO && macro->value < 0) { break; } else { macro->pc = group->seq_data + abs; } break; - case SEQCMD_BRANCH_REL_NOT_EQ_ZERO: - case SEQCMD_BRANCH_REL_EQ_ZERO: - case SEQCMD_BRANCH_REL: + case COMMON_CMD_BRANCH_REL_NOT_EQ_ZERO: + case COMMON_CMD_BRANCH_REL_EQ_ZERO: + case COMMON_CMD_BRANCH_REL: rel = (s8)(arg & 0xFF); - if (cmd == SEQCMD_BRANCH_REL_EQ_ZERO && macro->value != 0) { + if (cmd == COMMON_CMD_BRANCH_REL_EQ_ZERO && macro->value != 0) { break; - } else if (cmd == SEQCMD_BRANCH_REL_NOT_EQ_ZERO && macro->value >= 0) { + } else if (cmd == COMMON_CMD_BRANCH_REL_NOT_EQ_ZERO && macro->value >= 0) { break; } else { macro->pc += rel; @@ -561,13 +561,13 @@ static void Nas_NoteSeq(note* n) { } cmd = __SetNote(n, cmd); - } while (cmd == -1 && n->delay == 0); + } while (cmd == COMMON_SCRIPT_END && n->delay == 0); - if (cmd != -1) { + if (cmd != COMMON_SCRIPT_END) { cmd = __SetVoice(n, cmd); } - if (cmd != -1) { + if (cmd != COMMON_SCRIPT_END) { __SetChannel(n, cmd); } @@ -640,11 +640,11 @@ static s32 __Command_Seq(note* n) { while (TRUE) { cmd = Nas_ReadByteData(m); - if (cmd <= 0xC0) { + if (cmd <= NOTE_CMD_MUTE) { return cmd; } - if (cmd >= SEQCMD_BRANCH_REL_NOT_EQ_ZERO) { + if (cmd >= COMMON_CMD_BRANCH_REL_NOT_EQ_ZERO) { cmdArgU16 = Convert_Com(m, cmd); if (Common_Com(grp, m, cmd, cmdArgU16) == 0) { @@ -657,42 +657,42 @@ static s32 __Command_Seq(note* n) { } switch (cmd) { - case 0xC1: - case 0xCA: + case NOTE_CMD_SET_VELOCITY_SQ: + case NOTE_CMD_SET_PAN: cmdArgU8 = *m->pc++; - if (cmd == 0xC1) { + if (cmd == NOTE_CMD_SET_VELOCITY_SQ) { n->velocity_square = (f32)(cmdArgU8 * cmdArgU8) / (f32)(127 * 127); } else { n->pan = cmdArgU8; } break; - case 0xC2: - case 0xC9: + case NOTE_CMD_SET_TRANSPOSITION: + case NOTE_CMD_SET_GATE_TIME: cmdArgU8 = *m->pc++; - if (cmd == 0xC9) { + if (cmd == NOTE_CMD_SET_GATE_TIME) { n->gate_time = cmdArgU8; } else { n->transposition = cmdArgU8; } break; - case 0xC4: - case 0xC5: - n->continuous = cmd == 0xC4; + case NOTE_CMD_CONTINUOUS_ON: + case NOTE_CMD_CONTINUOUS_OFF: + n->continuous = cmd == NOTE_CMD_CONTINUOUS_ON; n->_00bit1 = FALSE; Nas_Release_Channel(n); break; - case 0xC3: + case NOTE_CMD_SET_SHORT_NOTE_DEFAULT_DELAY: n->short_note_default_delay = Nas_ReadLengthData(m); break; - case 0xC6: + case NOTE_CMD_SET_INSTRUMENT: cmdArgU8 = Nas_ReadByteData(m); if (cmdArgU8 >= 0x7E) { if (cmdArgU8 == 0x7E) { // effect/sfx - n->inst_or_wave = 1; + n->inst_or_wave = VOICE_TYPE_SOUND_EFF; } else if (cmdArgU8 == 0x7F) { // percussion/drum - n->inst_or_wave = 0; + n->inst_or_wave = VOICE_TYPE_PERCUSSION; } else { // synth wave n->inst_or_wave = cmdArgU8; @@ -711,7 +711,7 @@ static s32 __Command_Seq(note* n) { } } break; - case 0xC7: + case NOTE_CMD_ENABLE_SWEEP: n->portamento_sweep.mode = Nas_ReadByteData(m); cmdArgU8 = Nas_ReadByteData(m); cmdArgU8 = cmdArgU8 + subtrack->transposition; @@ -736,39 +736,39 @@ static s32 __Command_Seq(note* n) { n->portamento_time = Nas_ReadLengthData(m); } break; - case 0xC8: + case NOTE_CMD_DISABLE_SWEEP: n->portamento_sweep.mode = PORTAMENTO_MODE_OFF; break; - case 0xCB: + case NOTE_CMD_SET_ADSR_ENVELOPE_DECAY_IDX: n->adsr_env.envelope = (envdat*)(grp->seq_data + (Nas_ReadWordData(m) & 0xFFFF)); // fallthrough 0xCB -> 0xCF - case 0xCF: + case NOTE_CMD_SET_ADSR_DECAY_IDX: n->adsr_env.decay_idx = Nas_ReadByteData(m); break; - case 0xCC: + case NOTE_CMD_IGNORE_DRUM_PAN: n->ignore_drum_pan = TRUE; break; - case 0xCD: + case NOTE_CMD_SET_STEREO_PHASE: *(u8*)&n->stereo_phase = Nas_ReadByteData(m); break; - case 0xCE: + case NOTE_CMD_SET_BEND: cmdArgU8 = 128 + Nas_ReadByteData(m); n->bend = PCENTTABLE2[cmdArgU8]; break; - case 0xF0: + case NOTE_CMD_DISABLE_FLAGS: cmdArgU16 = Nas_ReadWordData(m); n->_0A.asU16 &= cmdArgU16 ^ 0xFFFF; break; - case 0xF1: + case NOTE_CMD_SET_SURROUND_EFFECT_IDX: n->surround_effect_idx = Nas_ReadByteData(m); break; default: switch (cmd & 0xF0) { - case 0xD0: + case NOTE_CMD_SHORT_NOTE_VELOCITY_SQ_MASK: velocity = grp->short_note_velocity_tbl[cmd & 0xF]; n->velocity_square = (f32)(velocity * velocity) / (f32)(127 * 127); break; - case 0xE0: + case NOTE_CMD_SET_SHORT_NOTE_GATE_TIME_MASK: n->gate_time = grp->short_note_gate_time_tbl[cmd & 0xF]; break; } @@ -1248,7 +1248,7 @@ static void Nas_SubSeq(sub* subtrack) { hi_bits = hi_bits << 1; } - if (cmd >= 0xF2) { + if (cmd >= COMMON_CMD_BRANCH_REL_NOT_EQ_ZERO) { s32 delay = Common_Com(grp, m, cmd, cmdArgs[0]); if (delay != 0) { @@ -1262,27 +1262,27 @@ static void Nas_SubSeq(sub* subtrack) { } } else { switch ((u8)cmd) { - case 0xEA: // stop subtrack seq script + case SUBTRACK_CMD_STOP: // stop subtrack seq script subtrack->stop_script = TRUE; goto note_seq; - case 0xF1: // alloc voices + case SUBTRACK_CMD_ALLOC_VOICES: // alloc voices Nas_DeAllocAllVoices(&subtrack->channel_node); Nas_AllocVoices(&subtrack->channel_node, cmdArgs[0] & 0xFF); break; - case 0xF0: // dealloc voices + case SUBTRACK_CMD_DEALLOC_VOICES: // dealloc voices Nas_DeAllocAllVoices(&subtrack->channel_node); break; - case 0xC2: // set dynamic table + case SUBTRACK_CMD_SET_DYNTBL: // set dynamic table subtrack->dyn_tbl = (unsigned char(*)[][2])&grp->seq_data[(u16)cmdArgs[0]]; break; - case 0xC5: // jump to entry in dynamic table + case SUBTRACK_CMD_JMP_DYNTBL: // jump to entry in dynamic table if (m->value != -1) { data = (*subtrack->dyn_tbl)[m->value]; cmdArgU16 = (u16)((data[0] << 8) + data[1]); m->pc = (u8*)&grp->seq_data[cmdArgU16]; } break; - case 0xEB: // Load subtrack bank and set instruments + case SUBTRACK_CMD_INIT_INSTRUMENTS: // Load subtrack bank and set instruments cmdArgU8 = cmdArgs[0]; if (grp->bank_id != 0xFF) { cmdArgU16 = AG.map_header[grp->seq_id]; @@ -1296,76 +1296,76 @@ static void Nas_SubSeq(sub* subtrack) { cmdArgs[0] = cmdArgs[1]; // fallthrough 0xEB -> 0xC1 - case 0xC1: // Set subtrack voice + case SUBTRACK_CMD_VOICE_SET: // Set subtrack voice Nas_SubVoiceSet(subtrack, cmdArgs[0]); break; - case 0xC3: // turn off large notes + case SUBTRACK_CMD_LARGE_NOTE_ON: // turn off large notes subtrack->large_notes = FALSE; break; - case 0xC4: // turn on large notes + case SUBTRACK_CMD_LARGE_NOTE_OFF: // turn on large notes subtrack->large_notes = TRUE; break; - case 0xDF: // set volume + case SUBTRACK_CMD_SET_VOL: // set volume cmdArgU8 = (u8)cmdArgs[0]; Nas_SubVolumeSet(subtrack, cmdArgU8); subtrack->changes.flags.volume = TRUE; break; - case 0xE0: // set volume scale + case SUBTRACK_CMD_SET_VOL_SCALE: // set volume scale cmdArgU8 = (u8)cmdArgs[0]; subtrack->volume_scale = (f32)(s32)cmdArgU8 / 128.0f; subtrack->changes.flags.volume = TRUE; break; - case 0xDE: // set frequency scale + case SUBTRACK_CMD_SET_FREQ_SCALE: // set frequency scale cmdArgU16 = (u16)cmdArgs[0]; subtrack->frequency_scale = (f32)(s32)cmdArgU16 / (f32)0x8000; subtrack->changes.flags.frequency_scale = TRUE; break; - case 0xD3: // large bend pitch + case SUBTRACK_CMD_LARGE_BEND_PITCH: // large bend pitch cmdArgU8 = (u8)cmdArgs[0]; cmdArgU8 += 128; subtrack->frequency_scale = PCENTTABLE[cmdArgU8]; subtrack->changes.flags.frequency_scale = TRUE; break; - case 0xEE: // small bend pitch + case SUBTRACK_CMD_SMALL_BEND_PITCH: // small bend pitch cmdArgU8 = 128 + (u8)cmdArgs[0]; subtrack->frequency_scale = PCENTTABLE2[cmdArgU8]; subtrack->changes.flags.frequency_scale = TRUE; break; - case 0xDD: // set pan + case SUBTRACK_CMD_SET_PAN: // set pan cmdArgU8 = (u8)cmdArgs[0]; subtrack->new_pan = cmdArgU8; subtrack->changes.flags.pan = TRUE; break; - case 0xDC: // set pan mix/channel weight + case SUBTRACK_CMD_SET_PAN_WEIGHT: // set pan mix/channel weight cmdArgU8 = (u8)cmdArgs[0]; subtrack->pan_channel_weight = cmdArgU8; subtrack->changes.flags.pan = TRUE; break; - case 0xDB: // set transposition + case SUBTRACK_CMD_SET_TRANSPOSITION: // set transposition cmdArgS8 = (s8)cmdArgs[0]; subtrack->transposition = cmdArgS8; break; - case 0xDA: // set envelope + case SUBTRACK_CMD_SET_ENVELOPE: // set envelope cmdArgU16 = (u16)cmdArgs[0]; subtrack->adsr_env.envelope = (envdat*)&grp->seq_data[cmdArgU16]; break; - case 0xD9: // set decay index + case SUBTRACK_CMD_SET_DECAY_IDX: // set decay index cmdArgU8 = (u8)cmdArgs[0]; subtrack->adsr_env.decay_idx = cmdArgU8; break; - case 0xD8: // set vibrato depth + case SUBTRACK_CMD_SET_VIBRATO_DEPTH: // set vibrato depth cmdArgU8 = (u8)cmdArgs[0]; subtrack->vibrato_params.depth_target = cmdArgU8 * 8; subtrack->vibrato_params.depth_start = 0; subtrack->vibrato_params.depth_change_delay = 0; break; - case 0xD7: // set vibrato rate + case SUBTRACK_CMD_SET_VIBRATO_RATE: // set vibrato rate cmdArgU8 = (u8)cmdArgs[0]; subtrack->vibrato_params.rate_target = cmdArgU8 * 32; subtrack->vibrato_params.rate_start = cmdArgU8 * 32; subtrack->vibrato_params.rate_change_delay = 0; break; - case 0xE2: // set vibrato depth linear + case SUBTRACK_CMD_SET_VIBRATO_DEPTH_LINEAR: // set vibrato depth linear cmdArgU8 = (u8)cmdArgs[0]; subtrack->vibrato_params.depth_start = cmdArgU8 * 8; cmdArgU8 = (u8)cmdArgs[1]; @@ -1373,7 +1373,7 @@ static void Nas_SubSeq(sub* subtrack) { cmdArgU8 = (u8)cmdArgs[2]; subtrack->vibrato_params.depth_change_delay = cmdArgU8 * 16; break; - case 0xE1: // set vibrato rate linear + case SUBTRACK_CMD_SET_VIBRATO_RATE_LINEAR: // set vibrato rate linear cmdArgU8 = (u8)cmdArgs[0]; subtrack->vibrato_params.rate_start = cmdArgU8 * 32; cmdArgU8 = (u8)cmdArgs[1]; @@ -1381,15 +1381,15 @@ static void Nas_SubSeq(sub* subtrack) { cmdArgU8 = (u8)cmdArgs[2]; subtrack->vibrato_params.rate_change_delay = cmdArgU8 * 16; break; - case 0xE3: // set vibrato delay + case SUBTRACK_CMD_SET_VIBRATO_DELAY: // set vibrato delay cmdArgU8 = (u8)cmdArgs[0]; subtrack->vibrato_params.delay = cmdArgU8 * 16; break; - case 0xD4: // set reverb volume + case SUBTRACK_CMD_SET_REVERB_VOL: // set reverb volume cmdArgU8 = (u8)cmdArgs[0]; subtrack->target_reverb_vol = cmdArgU8; break; - case 0xC6: // set bank + case SUBTRACK_CMD_SET_INSTRUMENT_BANK: // set bank cmdArgU8 = cmdArgs[0]; if (grp->bank_id != 0xFF) { cmdArgU16 = AG.map_header[grp->seq_id]; // get offset for bank info for seq @@ -1401,48 +1401,48 @@ static void Nas_SubSeq(sub* subtrack) { subtrack->bank_id = cmdArgU8; } break; - case 0xC7: // write to sequence script + case SUBTRACK_CMD_WRITE_GROUP_SEQ: // write to sequence script cmdArgU8 = (u8)cmdArgs[0]; cmdArgU16 = (u16)cmdArgs[1]; seq_data = &grp->seq_data[cmdArgU16]; seq_data[0] = (u8)m->value + cmdArgU8; break; - case 0xC8: // subtract macro value - case 0xCC: // set macro value - case 0xC9: // bit& macro value + case SUBTRACK_CMD_MACRO_SUBTRACT: // subtract macro value + case SUBTRACK_CMD_MACRO_SET: // set macro value + case SUBTRACK_CMD_MACRO_AND: // bit& macro value cmdArgS8 = (s8)cmdArgs[0]; - if (cmd == 0xC8) { + if (cmd == SUBTRACK_CMD_MACRO_SUBTRACT) { m->value -= cmdArgS8; - } else if (cmd == 0xCC) { + } else if (cmd == SUBTRACK_CMD_MACRO_SET) { m->value = cmdArgS8; } else { m->value &= cmdArgS8; } break; - case 0xCD: // disable subtrack + case SUBTRACK_CMD_DISABLE_SUBTRACK: // disable subtrack cmdArgU8 = (u8)cmdArgs[0]; Nas_ReleaseSubTrack(grp->subtracks[cmdArgU8]); break; - case 0xCA: // set mute flags + case SUBTRACK_CMD_SET_MUTE_FLAGS: // set mute flags cmdArgU8 = (u8)cmdArgs[0]; subtrack->mute_flags = cmdArgU8; subtrack->changes.flags.volume = TRUE; break; - case 0xCB: // load macro register value from table + case SUBTRACK_CMD_MACRO_LOAD_FROM_GROUP_SEQ: // load macro register value from table cmdArgU16 = (u16)cmdArgs[0]; m->value = grp->seq_data[(u32)(cmdArgU16 + m->value)]; break; - case 0xCE: // set stored sequence data index + case SUBTRACK_CMD_SET_DYNVAL: // set stored sequence data index cmdArgU16 = (u16)cmdArgs[0]; subtrack->dynamic_value = cmdArgU16; break; - case 0xCF: // write u16 into sequence script + case SUBTRACK_CMD_WRITE_DYNVAL_TO_GROUP_SEQ: // write u16 into sequence script cmdArgU16 = (u16)cmdArgs[0]; seq_data = &grp->seq_data[cmdArgU16]; seq_data[0] = (subtrack->dynamic_value >> 8) & 0xFF; seq_data[1] = subtrack->dynamic_value & 0xFF; break; - case 0xD0: // stereo phase effects + case SUBTRACK_CMD_STEREO_PHASE_SET: // stereo phase effects cmdArgU8 = (u8)cmdArgs[0]; if (cmdArgU8 & 0x80) { subtrack->stereo_effects = TRUE; @@ -1452,19 +1452,19 @@ static void Nas_SubSeq(sub* subtrack) { *(u8*)&subtrack->stereo_phase = cmdArgU8 & 0x7F; break; - case 0xD1: // set note allocation policy + case SUBTRACK_CMD_SET_NOTE_ALLOC_POLICY: // set note allocation policy cmdArgU8 = (u8)cmdArgs[0]; subtrack->note_alloc_policy = cmdArgU8; break; - case 0xD2: // set sustain + case SUBTRACK_CMD_SET_SUSTAIN: // set sustain cmdArgU8 = (u8)cmdArgs[0]; subtrack->adsr_env.sustain = cmdArgU8; break; - case 0xE5: // set reverb index + case SUBTRACK_CMD_SET_REVERB_IDX: // set reverb index cmdArgU8 = (u8)cmdArgs[0]; subtrack->reverb_idx = cmdArgU8; break; - case 0xE4: // dynamic call + case SUBTRACK_CMD_DYNTBL_CALL: // dynamic call if (m->value != -1) { data = (*subtrack->dyn_tbl)[m->value]; /* @BUG - missing stack depth bounds check */ @@ -1473,11 +1473,11 @@ static void Nas_SubSeq(sub* subtrack) { m->pc = &grp->seq_data[cmdArgU16]; } break; - case 0xE6: // set book ofs + case SUBTRACK_CMD_SET_BOOK_OFS: // set book ofs cmdArgU8 = (u8)cmdArgs[0]; subtrack->book_ofs = cmdArgU8; break; - case 0xE7: // + case SUBTRACK_CMD_SET_ENV_PARAMS_FROM_GROUP_SEQ: // cmdArgU16 = (u16)cmdArgs[0]; data = &grp->seq_data[cmdArgU16]; subtrack->mute_flags = data[0]; @@ -1491,7 +1491,7 @@ static void Nas_SubSeq(sub* subtrack) { /* @BUG - didn't update reverb state as changed */ subtrack->changes.flags.pan = TRUE; break; - case 0xE8: // + case SUBTRACK_CMD_SET_ENV_PARAMS: // subtrack->mute_flags = cmdArgs[0]; subtrack->note_alloc_policy = cmdArgs[1]; cmdArgU8 = (u8)cmdArgs[2]; @@ -1504,7 +1504,7 @@ static void Nas_SubSeq(sub* subtrack) { /* @BUG - didn't update reverb state as changed */ subtrack->changes.flags.pan = TRUE; break; - case 0xEC: // reset vibrato + case SUBTRACK_CMD_RESET_VIBRATO: // reset vibrato subtrack->frequency_scale = 1.0f; subtrack->vibrato_params.depth_target = 0; subtrack->vibrato_params.depth_start = 0; @@ -1523,23 +1523,23 @@ static void Nas_SubSeq(sub* subtrack) { subtrack->sample_start_pos = 0; subtrack->_E0 = 0; break; - case 0xE9: // set priority + case SUBTRACK_CMD_SET_PRIORITY: // set priority cmdArgU8 = (u8)cmdArgs[0]; Nas_PriorityChanger(subtrack, cmdArgU8); break; - case 0xED: // set gain + case SUBTRACK_CMD_SET_GAIN: // set gain cmdArgU8 = (u8)cmdArgs[0]; subtrack->gain = cmdArgU8; break; - case 0xB0: // set filter + case SUBTRACK_CMD_SET_FILTER: // set filter cmdArgU16 = (u16)cmdArgs[0]; data = &grp->seq_data[cmdArgU16]; subtrack->filter = (s16*)data; break; - case 0xB1: // clear filter + case SUBTRACK_CMD_CLEAR_FILTER: // clear filter subtrack->filter = nullptr; break; - case 0xB3: // load filter + case SUBTRACK_CMD_LOAD_FILTER: // load filter cmdArgU8 = (u8)cmdArgs[0]; if (subtrack->filter != nullptr) { lo_bits = (cmdArgU8 >> 4) & 0xF; @@ -1547,59 +1547,59 @@ static void Nas_SubSeq(sub* subtrack) { Nas_SetBPFilter(subtrack->filter, lo_bits, cmdArgU8); } break; - case 0xB2: // load dynamic idx + case SUBTRACK_CMD_LOAD_DYNVAL_FROM_GROUP_SEQ: // load dynamic idx cmdArgU16 = (u16)cmdArgs[0]; subtrack->dynamic_value = *(u16*)&grp->seq_data[cmdArgU16 + m->value * 2]; break; - case 0xB4: // set dynamic table + case SUBTRACK_CMD_SET_DYNTBL_FROM_GROUP_SEQ: // set dynamic table subtrack->dyn_tbl = (unsigned char(*)[][2]) & grp->seq_data[subtrack->dynamic_value]; break; - case 0xB5: // read from dynamic table + case SUBTRACK_CMD_LOAD_DYNVAL_FROM_DYNTBL: // read from dynamic table subtrack->dynamic_value = ((u16*)subtrack->dyn_tbl)[m->value]; break; - case 0xB6: // read to macro register from dynamic table + case SUBTRACK_CMD_MACRO_LOAD_FROM_DYNTBL: // read to macro register from dynamic table m->value = (*subtrack->dyn_tbl)[0][m->value]; break; - case 0xB7: // random dynamic value + case SUBTRACK_CMD_RANDOM_DYNVAL: // random dynamic value if (cmdArgs[0] == 0) { subtrack->dynamic_value = Nap_GetRandom(); } else { subtrack->dynamic_value = Nap_GetRandom() % cmdArgs[0]; } break; - case 0xB8: // macro register random value + case SUBTRACK_CMD_MACRO_RANDOM_VAL: // macro register random value if (cmdArgs[0] == 0) { m->value = Nap_GetRandom(); } else { m->value = Nap_GetRandom() % cmdArgs[0]; } break; - case 0xB9: // set velocity random variance + case SUBTRACK_CMD_SET_VEL_RANDOM_VARIANCE: // set velocity random variance cmdArgU8 = (u8)cmdArgs[0]; subtrack->velocity_random_variance = cmdArgU8; break; - case 0xBA: // set gate time random variance + case SUBTRACK_CMD_SET_GATE_TIME_RANDOM_VARIANCE: // set gate time random variance cmdArgU8 = (u8)cmdArgs[0]; subtrack->gate_time_random_variance = cmdArgU8; break; - case 0xBB: // set comb filter size & gain + case SUBTRACK_CMD_SET_COMB_FILTER_SIZE_GAIN: // set comb filter size & gain cmdArgU8 = (u8)cmdArgs[0]; subtrack->comb_filter_size = cmdArgU8; cmdArgU16 = (u16)cmdArgs[1]; subtrack->comb_filter_gain = cmdArgU16; break; - case 0xBC: // Add to dynamic value + case SUBTRACK_CMD_ADD_DYNVAL: // Add to dynamic value subtrack->dynamic_value += cmdArgs[0]; break; - case 0xA8: // Dynamic value bit shift & negate (when s16), differs from OoT and MM + case SUBTRACK_CMD_DYNVAL_SPECIAL: // Dynamic value bit shift & negate (when s16), differs from OoT and MM new_var2 = (subtrack->dynamic_value & 0x7F); new_var2 |= 0x8000 | ((subtrack->dynamic_value & 0x7FC0) << 1); subtrack->dynamic_value = new_var2; break; - case 0xBD: // set sample start pos + case SUBTRACK_CMD_SET_SAMPLE_START_POS: // set sample start pos subtrack->sample_start_pos = cmdArgs[0]; break; - case 0xBE: // call custom sequence callback and update macro register value + case SUBTRACK_CMD_MACRO_SET_FROM_CALLBACK: // call custom sequence callback and update macro register value if (cmdArgs[0] <= 4) { if (AG.seq_callbacks[cmdArgs[0]] != nullptr) { NA_CALLBACK = AG.seq_callbacks[cmdArgs[0]]; @@ -1607,37 +1607,37 @@ static void Nas_SubSeq(sub* subtrack) { } } break; - case 0xA0: // read from sfx state using macro register value as index - case 0xA1: // read from sfx state using dynamic value as index - case 0xA2: // write to sfx state using macro register value as index - case 0xA3: // write to sfx state using dynamic value as index - if (cmd == 0xA0 || cmd == 0xA2) { + case SUBTRACK_CMD_MACRO_LOAD_FROM_SFX_STATE: // read from sfx state using macro register value as index + case SUBTRACK_CMD_MACRO_LOAD_FROM_SFX_STATE_DYNVAL: // read from sfx state using dynamic value as index + case SUBTRACK_CMD_SFX_STATE_SET: // write to sfx state using macro register value as index + case SUBTRACK_CMD_SFX_STATE_SET_DYNVAL: // write to sfx state using dynamic value as index + if (cmd == SUBTRACK_CMD_MACRO_LOAD_FROM_SFX_STATE || cmd == SUBTRACK_CMD_SFX_STATE_SET) { cmdArgU16 = cmdArgs[0]; } else { cmdArgU16 = subtrack->dynamic_value; } if (subtrack->sfx_state != nullptr) { - if (cmd == 0xA0 || cmd == 0xA1) { + if (cmd == SUBTRACK_CMD_MACRO_LOAD_FROM_SFX_STATE || cmd == SUBTRACK_CMD_MACRO_LOAD_FROM_SFX_STATE_DYNVAL) { m->value = subtrack->sfx_state[cmdArgU16]; } else { subtrack->sfx_state[cmdArgU16] = m->value; } } break; - case 0xA4: // set surround effect index + case SUBTRACK_CMD_SURROUND_EFFECT_IDX_SET: // set surround effect index subtrack->surround_effect_idx = cmdArgs[0]; break; - case 0xA5: // add subtrack index to macro register value + case SUBTRACK_CMD_MACRO_ADD_SUBTRACK_IDX: // add subtrack index to macro register value m->value += subtrack->subtrack_idx; break; - case 0xA6: // Set value in sequence data to macro register value plus arg value + case SUBTRACK_CMD_WRITE_GOUP_SEQ_OFFSET_BY_SUBTRACK: // Set value in sequence data to macro register value plus arg value cmdArgU8 = (u8)cmdArgs[0]; cmdArgU16 = (u16)cmdArgs[1]; seq_data = &grp->seq_data[cmdArgU16 + subtrack->subtrack_idx]; *seq_data = (u8)m->value + cmdArgU8; break; - case 0xA7: // manipulate macro register value + case SUBTRACK_CMD_MACRO_BIT_MOD: // manipulate macro register value u32 shift = (cmdArgs[0] & 0xF); lo_bits = (m->value & 0x80); new_var2 = (cmdArgs[0] & 0x80); @@ -1659,19 +1659,19 @@ static void Nas_SubSeq(sub* subtrack) { } } // continue; - } else if (cmd >= 0x70) { + } else if (cmd >= SUBTRACK_CMD_PORT_WRITE_MACRO_REG_MASK) { s32 hi_bits = (cmd & (u8)~7); lo_bits = cmd; lo_bits &= ~0xF8; /* if command is not in range [0x70, 0x77] and the lower 4 bits are >= 4, set them to be 0xY0*/ - if (hi_bits != 0x70 && lo_bits >= ARRAY_COUNT(subtrack->note_layers)) { + if (hi_bits != SUBTRACK_CMD_PORT_WRITE_MACRO_REG_MASK && lo_bits >= ARRAY_COUNT(subtrack->note_layers)) { lo_bits = 0; } switch (hi_bits) { // [0x80 - 0x83] - case 0x80: // macro register value = subtrack->note_layers[idx]->finished + case SUBTRACK_CMD_READ_NOTE_FINISHED_MASK: // macro register value = subtrack->note_layers[idx]->finished if (subtrack->note_layers[lo_bits] != nullptr) { m->value = subtrack->note_layers[lo_bits]->finished; } else { @@ -1679,18 +1679,18 @@ static void Nas_SubSeq(sub* subtrack) { } break; // [0x88 - 0x8B] - case 0x88: // start note layer and initialize note macro pc + case SUBTRACK_CMD_NOTE_SET_PC_MASK: // start note layer and initialize note macro pc cmdArgU16 = Nas_ReadWordData(m); if (Nas_EntryNoteTrack(subtrack, lo_bits) == 0) { subtrack->note_layers[lo_bits]->macro_player.pc = &grp->seq_data[cmdArgU16]; } break; // [0x90 - 0x93] - case 0x90: // stop note layer + case SUBTRACK_CMD_NOTE_STOP_MASK: // stop note layer Nas_CloseNoteTrack(subtrack, lo_bits); break; // [0x98 - 0x9B] - case 0x98: // start note layer and initialize note macro pc from data at macro register offset + case SUBTRACK_CMD_NOTE_START_DYNTBL_MASK: // start note layer and initialize note macro pc from data at macro register offset if (m->value != -1) { if (Nas_EntryNoteTrack(subtrack, lo_bits) != -1) { data = (*subtrack->dyn_tbl)[m->value]; @@ -1700,11 +1700,11 @@ static void Nas_SubSeq(sub* subtrack) { } break; // [0x70 - 0x77] - case 0x70: // write macro register value into subtrack port + case SUBTRACK_CMD_PORT_WRITE_MACRO_REG_MASK: // write macro register value into subtrack port subtrack->port[lo_bits] = m->value; break; // [0x78 - 0x7B] - case 0x78: // start note layer and initialize note macro pc from subtrack pc and rel offset + case SUBTRACK_CMD_NOTE_START_MASK: // start note layer and initialize note macro pc from subtrack pc and rel offset temp1 = Nas_ReadWordData(m); if (Nas_EntryNoteTrack(subtrack, lo_bits) == 0) { subtrack->note_layers[lo_bits]->macro_player.pc = m->pc + temp1; @@ -1716,7 +1716,7 @@ static void Nas_SubSeq(sub* subtrack) { lo_bits = cmd & 0xF; // each command has 16 indicies which come from the lower 4 bits switch (cmd & 0xF0) { // [0x00, 0x0F] - case 0x00: // set delay + case SUBTRACK_CMD_DELAY_MASK: // set delay subtrack->delay = lo_bits; if (lo_bits == 0) { break; /* clear delay, continue processing */ @@ -1724,7 +1724,7 @@ static void Nas_SubSeq(sub* subtrack) { goto note_seq; /* delay > 0 so stop processing subtrack commands for now */ } // [0x10, 0x17] & [0x18, 0x1F] - case 0x10: // load new wave samples + case SUBTRACK_CMD_VOICELOAD_MASK: // load new wave samples if (lo_bits < 8) { subtrack->port[lo_bits] = -1; // clear port /* Load samples from bank with inst id being macro's register value, load result in @@ -1738,28 +1738,28 @@ static void Nas_SubSeq(sub* subtrack) { } break; // [0x60, 0x6F] (only 0x60, 0x67 are valid) - case 0x60: // read port value into macro register value + case SUBTRACK_CMD_MACRO_READ_PORT0_MASK: // read port value into macro register value m->value = subtrack->port[lo_bits]; if (lo_bits < 2) { subtrack->port[lo_bits] = -1; } break; // [0x50, 0x5F] (only 0x50, 0x57 are valid) - case 0x50: // subtrack port value from macro register value + case SUBTRACK_CMD_MACRO_SUBTRACT_MASK: // subtrack port value from macro register value m->value -= subtrack->port[lo_bits]; break; // [0x20, 0x2F] - case 0x20: // start subtrack + case SUBTRACK_CMD_START_SUBTRACK_MASK: // start subtrack cmdArgU16 = (u16)Nas_ReadWordData(m); Nas_OpenSub(grp, lo_bits, &grp->seq_data[cmdArgU16]); break; // [0x30, 0x3F] - case 0x30: // set subtrack port to this subtrack's macro register value + case SUBTRACK_CMD_WRITE_SUBTRACK_PORT_MASK: // set subtrack port to this subtrack's macro register value cmdArgU8 = Nas_ReadByteData(m); grp->subtracks[lo_bits]->port[cmdArgU8] = m->value; break; // [0x40, 0x4F] - case 0x40: // set this subtrack's macro register value to other subtrack's port + case SUBTRACK_CMD_READ_SUBTRACK_PORT_MASK: // set this subtrack's macro register value to other subtrack's port cmdArgU8 = Nas_ReadByteData(m); m->value = grp->subtracks[lo_bits]->port[cmdArgU8]; break; @@ -1838,7 +1838,7 @@ static void Nas_GroupSeq(group* grp) { /* Sequence group commands processing loop */ while (TRUE) { cmd = Nas_ReadByteData(m); - if (cmd >= 0xF2) { + if (cmd >= COMMON_CMD_BRANCH_REL_NOT_EQ_ZERO) { u16 arg = Convert_Com(m, cmd); delay = Common_Com(grp, m, cmd, arg); @@ -1854,22 +1854,22 @@ static void Nas_GroupSeq(group* grp) { } } else if (cmd >= 0xC0) { switch (cmd) { - case 0xF1: // reserve voices + case GRP_CMD_RESERVE_VOICES: // reserve voices Nas_DeAllocAllVoices(&grp->channel_node); cmd = Nas_ReadByteData(m); Nas_AllocVoices(&grp->channel_node, (u8)cmd); break; - case 0xF0: // release voices + case GRP_CMD_RELEASE_VOICES: // release voices Nas_DeAllocAllVoices(&grp->channel_node); break; - case 0xDF: // absolute transposition + case GRP_CMD_TRANSPOSITION_ABSOLUTE: // absolute transposition grp->transposition = 0; // fallthrough 0xDF -> 0xDE - case 0xDE: // relative transposition + case GRP_CMD_TRANSPOSITION_RELATIVE: // relative transposition argU8 = Nas_ReadByteData(m); grp->transposition = grp->transposition + (s8)argU8; break; - case 0xDD: // set tempo + case GRP_CMD_SET_TEMPO: // set tempo grp->tempo = Nas_ReadByteData(m) * AUDIO_TATUMS_PER_BEAT; if (grp->tempo > AG.max_tempo) { grp->tempo = AG.max_tempo; @@ -1878,10 +1878,10 @@ static void Nas_GroupSeq(group* grp) { grp->tempo = 1; } break; - case 0xDC: // adjust tempo relative + case GRP_CMD_SET_TEMPO_CHANGE: // adjust tempo relative grp->tempo_change = (s8)Nas_ReadByteData(m) * AUDIO_TATUMS_PER_BEAT; break; - case 0xDA: // change volume + case GRP_CMD_CHANGE_VOLUME: // change volume cmd = Nas_ReadByteData(m); temp = Nas_ReadWordData(m); switch (cmd) { @@ -1899,7 +1899,7 @@ static void Nas_GroupSeq(group* grp) { break; } break; - case 0xDB: // set volume + case GRP_CMD_SET_VOLUME: // set volume tempf32 = (s32)Nas_ReadByteData(m) / 127.0f; switch (grp->state) { case GROUP_STATE_FADE_IN: @@ -1921,39 +1921,39 @@ static void Nas_GroupSeq(group* grp) { break; } break; - case 0xD9: // set volume scale + case GRP_CMD_SET_VOLUME_SCALE: // set volume scale grp->fade_volume_scale = (s8)Nas_ReadByteData(m) / 127.0f; break; - case 0xD7: // initialize subtracks + case GRP_CMD_ALLOC_SUBTRACKS: // initialize subtracks temp = Nas_ReadWordData(m); Nas_AllocSub(grp, temp); break; - case 0xD6: // [ineffective] - disable subtracks + case GRP_CMD_DISABLE_SUBTRACKS: // [ineffective] - disable subtracks Nas_ReadWordData(m); break; - case 0xD5: // set mute scale + case GRP_CMD_SET_MUTE_SCALE: // set mute scale grp->mute_volume_scale = (s8)Nas_ReadByteData(m) / 127.0f; break; - case 0xD4: // mute + case GRP_CMD_MUTE: // mute grp->flags.muted = TRUE; break; - case 0xD3: // set mute behaivor + case GRP_CMD_SET_MUTE_BEHAVIOR: // set mute behaivor grp->mute_flags = Nas_ReadByteData(m); break; - case 0xD1: // set short note gate-time table - case 0xD2: // set short note velocity table + case GRP_CMD_SET_SHORT_NOTE_GATE_TIME_TBL: // set short note gate-time table + case GRP_CMD_SET_SHORT_NOTE_VELOCITY_TBL: // set short note velocity table temp = Nas_ReadWordData(m); data3 = &grp->seq_data[temp]; - if (cmd == 0xD2) { + if (cmd == GRP_CMD_SET_SHORT_NOTE_VELOCITY_TBL) { grp->short_note_velocity_tbl = data3; } else { grp->short_note_gate_time_tbl = data3; } break; - case 0xD0: // set note allocation policy + case GRP_CMD_SET_NOTE_ALLOC_POLICY: // set note allocation policy grp->note_alloc_policy = Nas_ReadByteData(m); break; - case 0xCE: // set macro register value to random value + case GRP_CMD_MACRO_VALUE_RANDOM: // set macro register value to random value cmd = Nas_ReadByteData(m); if (cmd == 0) { /* 0-255 */ @@ -1963,7 +1963,7 @@ static void Nas_GroupSeq(group* grp) { m->value = (AG.audio_random_seed >> 2) % cmd; } break; - case 0xCD: // dynamic look-up table call + case GRP_CMD_DYN_TBL_CALL: // dynamic look-up table call temp = Nas_ReadWordData(m); if (m->value != -1 && m->depth != 3) { data1 = &grp->seq_data[(u32)(temp + (m->value << 1))]; @@ -1972,22 +1972,22 @@ static void Nas_GroupSeq(group* grp) { m->pc = &grp->seq_data[temp]; } break; - case 0xCC: // set macro register value + case GRP_CMD_MACRO_VALUE_LOAD: // set macro register value m->value = Nas_ReadByteData(m); break; - case 0xC9: // macro register bit mask + case GRP_CMD_MACRO_VALUE_BIT_AND: // macro register bit mask m->value &= Nas_ReadByteData(m); break; - case 0xC8: // macro register subtraction + case GRP_CMD_MACRO_VALUE_SUBTRACT: // macro register subtraction m->value -= Nas_ReadByteData(m); break; - case 0xC7: // write macro register value to sequence data + case GRP_CMD_MACRO_VALUE_STORE: // write macro register value to sequence data cmd = Nas_ReadByteData(m); temp = Nas_ReadWordData(m); data2 = &grp->seq_data[temp]; data2[0] = (u8)m->value + cmd; break; - case 0xC2: // dynamic lookup branch (no return) + case GRP_CMD_DYNAMIC_BRANCH: // dynamic lookup branch (no return) temp = Nas_ReadWordData(m); if (m->value != -1) { data4 = &grp->seq_data[(u32)(temp + (m->value << 1))]; @@ -1995,17 +1995,17 @@ static void Nas_GroupSeq(group* grp) { m->pc = &grp->seq_data[temp]; } break; - case 0xC6: // stop script + case GRP_CMD_STOP_SEQ: // stop script grp->flags.stop_seq_script = TRUE; return; - case 0xC5: // update counter + case GRP_CMD_UPDATE_COUNTER: // update counter grp->counter = Nas_ReadWordData(m); break; - case 0xEF: // + case GRP_CMD_EF: // Nas_ReadWordData(m); Nas_ReadByteData(m); break; - case 0xC4: // start sequence script + case GRP_CMD_START_SEQ: // start sequence script /* Get sequence group index */ cmd = Nas_ReadByteData(m); if (cmd == 0xFF) { @@ -2017,7 +2017,7 @@ static void Nas_GroupSeq(group* grp) { return; // stop processing since we just used this group for a new sequence } break; - case 0xC3: // mute subtracks from u16 bitfield + case GRP_CMD_MUTE_SUBTRACKS: // mute subtracks from u16 bitfield temp = Nas_ReadWordData(m); if (m->value != -1) { new_var = (u16*)(grp->seq_data + (u32)(temp + m->value * 2)); @@ -2029,7 +2029,7 @@ static void Nas_GroupSeq(group* grp) { } break; } - } else if (cmd == 0xBE) { + } else if (cmd == GRP_CMD_CALLBACK) { cmd = Nas_ReadByteData(m); if (cmd <= 4) { if (AG.seq_callbacks[cmd] != nullptr) { @@ -2044,47 +2044,47 @@ static void Nas_GroupSeq(group* grp) { cmd_lo_bits = cmd & 0x0F; switch (cmd & 0xF0) { // [0x00, 0x0F] - case 0x00: // macro register value = !subtrack->enabled + case GRP_CMD_MACRO_VALUE_LOAD_SUBTRACK_DISABLED_MASK: // macro register value = !subtrack->enabled m->value = grp->subtracks[cmd_lo_bits]->enabled ^ TRUE; break; // [0x50, 0x57] @BUG - ([0x58, 0x5F] end here but would result in undefined behavior) - case 0x50: // macro register subtract port value + case GRP_CMD_MACRO_VALUE_SUBTRACT_FROM_PORT_MASK: // macro register subtract port value m->value -= grp->port[cmd_lo_bits]; break; // [0x70, 0x77] @BUG - ([0x78, 0x7F] end here but would result in undefined behavior) - case 0x70: // write macro register value into port + case GRP_CMD_MACRO_VALUE_WRITE_PORT_MASK: // write macro register value into port grp->port[cmd_lo_bits] = m->value; break; // [0x80, 0x87] @BUG - ([0x88, 0x8F] end here but would result in undefined behavior) - case 0x80: // read macro register value from port + case GRP_CMD_MACRO_VALUE_READ_PORT_MASK: // read macro register value from port m->value = grp->port[cmd_lo_bits]; if (cmd_lo_bits < 2) { grp->port[cmd_lo_bits] = -1; } break; // [0x40, 0x4F] - case 0x40: // disable subtrack + case GRP_CMD_DISABLE_SUBTRACK_MASK: // disable subtrack Nas_ReleaseSubTrack(grp->subtracks[cmd_lo_bits]); break; // [0x90, 0x9F] - case 0x90: // start subtrack w/ absolute script address + case GRP_CMD_START_SUBTRACK_MASK: // start subtrack w/ absolute script address temp = Nas_ReadWordData(m); Nas_OpenSub(grp, cmd_lo_bits, &grp->seq_data[temp]); break; // [0xA0, 0xAF] - case 0xA0: // start subtrack w/ relative script address + case GRP_CMD_START_RELATIVE_SUBTRACK_MASK: // start subtrack w/ relative script address tempS = Nas_ReadWordData(m); Nas_OpenSub(grp, cmd_lo_bits, &m->pc[tempS]); break; // [0xB0, 0xB7] @BUG - ([0xB8, 0xBF] end here but would result in undefined behavior) - case 0xB0: // load sequence + case GRP_CMD_SEQ_LOAD_MASK: // load sequence cmd = Nas_ReadByteData(m); temp = Nas_ReadWordData(m); data2 = &grp->seq_data[temp]; SeqLoad(cmd, data2, &grp->port[cmd_lo_bits]); break; // [0x60, 0x67] @BUG - ([0x68, 0x6F] end here but would result in undefined behavior) - case 0x60: // async load + case GRP_CMD_ASYNC_LOAD_MASK: // async load cmd = (u8)Nas_ReadByteData(m); argU8 = Nas_ReadByteData(m); MK_load(cmd, argU8, (u8*)&grp->port[cmd_lo_bits]);