romdevtools 0.71.1 → 0.84.1

package/src/platforms/gametank/lib/gt/audio/audio_fw.asm

@@ -0,0 +1,223 @@
+DAC = $8000
+AccBuf = $00
+WavePTR = $02
+WavePTR_MSB = $03
+FeedbackAmount = $04
+;reserve $05
+;reserve $06
+;reserve $07
+LastSample = $08
+;reserve $09
+;reserve $0A
+;reserve $0B
+FreqsH = $10
+FreqsL = $20
+BufferedAmplitudes = $30
+WaveStatesH = $50
+WaveStatesL = $60
+Inputs = $70
+	.zeropage
+	;AccBuf
+	.byte 0, 0
+	;WavePTR
+	.byte 0, 0
+	;Feedback
+	.byte $80, $80, $80, $80
+	;UNUSED
+	.repeat 8
+	.byte 0
+	.endrep
+	;Frequencies
+    .repeat $20
+    .byte 0
+    .endrep
+	;Amplitudes
+	.repeat $10
+	.byte $80
+	.endrep
+	;Wave States
+	.repeat $80
+	.byte 0
+	.endrep
+
+	.code
+RESET:
+	CLI
+    LDA #<Sine
+    STA WavePTR
+    LDA #>Sine
+    STA WavePTR+1
+Forever:
+    WAI
+	JMP Forever
+
+.macro tickWave op, out
+	CLC
+	LDA WaveStatesL+op
+	ADC FreqsL+op
+	STA WaveStatesL+op
+	LDA out
+	ADC FreqsH+op
+	STA out
+.endmacro
+
+.macro doChannel ch
+.local Op1
+.local Op1State
+.local Op1Param
+.local Op2
+.local Op2Param
+.local Op3
+.local Op3Param
+.local Op4
+.local Op4Param
+.local SaveFeedback
+.local SampleFeedback
+.local LastSample
+
+	LDA BufferedAmplitudes+(ch*4)+0
+	STA Op1+1
+	LDA BufferedAmplitudes+(ch*4)+1
+	STA Op2+1
+	LDA BufferedAmplitudes+(ch*4)+2
+	STA Op3+1
+	LDA BufferedAmplitudes+(ch*4)+3
+	STA Op4+1
+
+	tickWave (ch*4)+1, Op2Param+1
+	tickWave (ch*4)+2, Op3Param+1
+	tickWave (ch*4)+3, Op4Param+1
+
+	tickWave (ch * 4), Op1State+1
+Op1State:
+	LDA #0
+LastSample:
+	ADC #0
+	
+	TAY
+	CLC
+SampleFeedback:
+	ADC FeedbackAmount+ch
+	TAX
+	CLC
+	LDA Sine, y
+	ADC Sine, x 
+
+SaveFeedback:
+	STA LastSample+1
+	TYA
+
+	CLC
+Op1:
+	ADC #0
+	TAX
+	CLC
+	LDA Sine, y
+	ADC Sine, x 
+
+	CLC
+Op2Param:
+	ADC #0
+	TAY
+	CLC
+Op2:
+	ADC #0
+	TAX
+	CLC
+	LDA Sine, y
+	ADC Sine, x 
+
+	CLC
+Op3Param:
+	ADC #0
+	TAY
+	CLC
+Op3:
+	ADC #0
+	TAX
+	CLC
+	LDA Sine, y
+	ADC Sine, x 
+
+	CLC
+Op4Param:
+	ADC #0
+	TAY
+	CLC
+Op4:
+	ADC #0
+	TAX
+	CLC
+	LDA Sine, y
+	ADC Sine, x 
+
+	CMP #$80
+	ROR
+	CMP #$80
+	ROR
+
+	CLC
+	ADC AccBuf
+	STA AccBuf
+.endmacro
+
+.macro GetSine
+.local ScaleConstant
+	; Returns sin(Acc + X) + sin(Acc - X)
+	TAY
+	STX ScaleConstant+1
+	CLC
+ScaleConstant:
+	ADC #0
+	TAX
+	CLC
+	LDA Sine, y
+	ADC Sine, x 
+.endmacro
+
+
+IRQ:
+	;Clear sum buffer
+	STZ AccBuf
+
+	doChannel 0
+	doChannel 1
+	doChannel 2
+	doChannel 3
+
+	LDA AccBuf
+	CLC
+	ADC #$80
+	STA DAC
+
+	RTI ;6
+
+;Read inputs addr, val until addr=0
+NMI_handler:
+    PHY
+    PHX
+    PHA
+    LDY #0
+NMI_Loop:
+    LDX Inputs, y
+    BEQ NMI_Done
+    INY
+    LDA Inputs, y
+    STA $00, x
+    INY
+    JMP NMI_Loop
+    
+NMI_Done:
+    PLA
+    PLX
+    PLY
+	RTI
+
+	.segment "WAVES"
+Sine:
+	.incbin "sine_256_-63_63.bin"
+
+	.segment "VECTORS"
+	.addr NMI_handler
+	.addr RESET
+	.addr IRQ

package/src/platforms/gametank/lib/gt/audio/audio_fw_blob.s

@@ -0,0 +1,8 @@
+; romdev single-bank GameTank: the ACP firmware embedded UNCOMPRESSED (the SDK
+; deflate-compresses it + inflatemem()s it; the bare path has no zopfli, so we
+; assemble audio_fw.asm to a raw 4 KB ACP image and memcpy it in). The build
+; stages the assembled image next to this file as acp_image.bin.
+.export _AudioFWPkg
+.segment "COMMON"
+_AudioFWPkg:
+    .incbin "acp_image.bin"

package/src/platforms/gametank/lib/gt/audio/instruments.c

@@ -0,0 +1,79 @@
+#include "instruments.h"
+
+const Instrument piano = {
+  0x30, 0x40, 0x40, 0x5f,
+  0x04, 0x02, 0x10, 0x02,
+  0x04, 0x02, 0x10, 0x30,
+  0, 0, 0, 0, 
+  0,
+  0
+};
+
+const Instrument guitar = {
+  0x6f, 0x40, 0x68, 0x5f, //initial amplitudes
+  0x00, 0xFF, 0x02, 0x08, //decay rates
+  0x00, 0x00, 0x40, 0x08, //sustain values
+  12, 36, 0, 24, //per operator note offsets
+  8, //feedback amount
+  -12 //channel note offset
+};
+
+const Instrument guitar2 = {
+  0x60, 0x40, 0x88, 0x4f,
+  0x00, 0xFF, 0x02, 0x01,
+  0x00, 0x00, 0x40, 0x30,
+  12, 36, 0, 24,
+  8,
+  -12
+};
+
+const Instrument slapbass = {
+  0x58, 0x88, 0x58, 0x5f,
+  0x18, 0x08, 0x04, 0x02,
+  0x18, 0x08, 0x04, 0x02,
+  28, 12, 0, 12,
+  0,
+  -24
+};
+
+const Instrument snare = {
+  0x88, 0x8f, 0x8f, 0x38,
+  0x18, 0x02, 0x04, 0x04,
+  0x18, 0x08, 0x08, 0x04,
+  36, 0, 0, 0,
+  8,
+  -8
+};
+
+const Instrument sitar = {
+  0x60, 0x40, 0x01, 0x10,
+  0x00, 0xFF, 0xF8, 0xFF,
+  0x00, 0x60, 0x60, 0x30,
+  12, 36, 12, 24,
+  4,
+  -24
+};
+
+const Instrument horn = {
+  0x00, 0x00, 0x01, 0x10,
+  0x00, 0x00, 0xFC, 0xFC,
+  0x00, 0x00, 0x30, 0x50,
+  12, 36, 12, 24,
+  0,
+  -12
+};
+
+Instrument* instrument_table[] = {
+    (Instrument*) 0xFFFF,
+    &piano,
+    &guitar,
+    &guitar2,
+    &slapbass,
+    &snare,
+    &sitar,
+    &horn
+};
+
+Instrument* get_instrument_ptr(char idx) {
+    return instrument_table[idx];
+}

package/src/platforms/gametank/lib/gt/audio/instruments.h

@@ -0,0 +1,25 @@
+#ifndef INSTRUMENTS_H
+#define INSTRUMENTS_H
+
+#include "audio_coprocessor.h"
+
+typedef struct {
+    unsigned char env_initial[OPS_PER_CHANNEL];
+    unsigned char env_decay[OPS_PER_CHANNEL];
+    unsigned char env_sustain[OPS_PER_CHANNEL];
+    unsigned char op_transpose[OPS_PER_CHANNEL];
+    unsigned char feedback;
+    signed char transpose;
+} Instrument;
+
+#define INSTR_IDX_PIANO 1
+#define INSTR_IDX_GUITAR 2
+#define INSTR_IDX_DISTGUITAR 3
+#define INSTR_IDX_SLAPBASS 4
+#define INSTR_IDX_SNARE 5
+#define INSTR_IDX_SITAR 6
+#define INSTR_IDX_HORN 7
+
+Instrument* get_instrument_ptr(char idx);
+
+#endif

package/src/platforms/gametank/lib/gt/audio/music.c

@@ -0,0 +1,370 @@
+#include "music.h"
+#include "gametank.h"
+#include "note_numbers.h"
+#include "banking.h"
+
+#include "bank_nums.h"
+#include "assets_index.h"
+
+typedef struct music_state_t {
+    const unsigned char* cursor;
+    unsigned char bank;
+    unsigned char cfg; //file flags
+    unsigned char delay;
+    const unsigned char* repeat_ptr;
+    unsigned char flags; //playback flags
+    const Instrument* instruments[NUM_FM_CHANNELS];
+} music_state_t;
+
+#define MUSIC_STACK_SIZE 8
+
+music_state_t music_state;
+music_state_t music_stack[MUSIC_STACK_SIZE];
+unsigned char music_stack_idx = 0;
+
+void push_song_stack() {
+    music_stack[music_stack_idx++] = music_state;
+    if(music_stack_idx == MUSIC_STACK_SIZE) { music_stack_idx = 0; }
+}
+
+void pop_song_stack() { 
+    if(music_stack_idx == 0) {
+        music_stack_idx = MUSIC_STACK_SIZE-1;
+    } else { 
+        --music_stack_idx;
+    }
+    music_state = music_stack[music_stack_idx];
+    load_instrument(0, music_state.instruments[0]);
+    load_instrument(0, music_state.instruments[1]);
+    load_instrument(0, music_state.instruments[2]);
+    load_instrument(0, music_state.instruments[3]);
+}
+
+unsigned char channel_masks[NUM_FM_CHANNELS] = {1, 2, 4, 8};
+signed char channel_note_offset[NUM_FM_CHANNELS] = {0, 0, 0, 0};
+unsigned char audio_amplitudes[NUM_FM_OPS] = { 0, 0, 0, 0,
+                                              0, 0, 0, 0,
+                                              0, 0, 0, 0,
+                                              0, 0, 0, 0 };
+unsigned char env_initial[NUM_FM_OPS] = { 0x00, 0x00, 0x00, 0x00,
+                                          0x00, 0x00, 0x00, 0x00,
+                                          0x00, 0x00, 0x00, 0x00,
+                                          0x00, 0x00, 0x00, 0x00 };
+unsigned char env_decay[NUM_FM_OPS] = { 0x00, 0x00, 0x00, 0x00,
+                                        0x00, 0x00, 0x00, 0x00,
+                                        0x00, 0x00, 0x00, 0x00,
+                                        0x00, 0x00, 0x00, 0x00 };
+unsigned char env_sustain[NUM_FM_OPS] = { 0x00, 0x00, 0x00, 0x00,
+                                        0x00, 0x00, 0x00, 0x00,
+                                        0x00, 0x00, 0x00, 0x00,
+                                        0x00, 0x00, 0x00, 0x00 };
+
+unsigned char op_transpose[NUM_FM_OPS] = { 0, 0, 0, 0, 
+                                       28, 12, 0, 19,
+                                       36, 0, 0, 0,
+                                       0, 0, 0, 0 };
+
+#define MUSIC_CFG_VELOCITY 1
+#define MUSIC_CFG_PROGCHANGE 2
+
+#define MUSIC_FLAG_POP_AT_END 1
+
+const unsigned char* paused_cursor = 0;
+unsigned char paused_bank = 0;
+unsigned char paused_cfg = 0;
+unsigned char paused_delay;
+unsigned char music_mode = REPEAT_NONE;
+
+unsigned char music_channel_mask;
+unsigned char percussion_channel_mask;
+unsigned char note_held_mask;
+const unsigned char* sound_effect_ptr[NUM_FM_CHANNELS];
+unsigned char sound_effect_bank[NUM_FM_CHANNELS];
+unsigned char sound_effect_length[NUM_FM_CHANNELS];
+unsigned char saved_feedback_value[NUM_FM_CHANNELS];
+unsigned char sound_effect_priority[NUM_FM_CHANNELS];
+
+void init_music() {
+    char i;
+    music_stack_idx = 0;
+    music_state.cursor = 0;
+    music_state.delay = 0;
+    music_channel_mask = 255;
+    note_held_mask = 0;
+    for(i = 0; i < NUM_FM_CHANNELS; ++i) {
+        sound_effect_length[i] = 0;
+        sound_effect_priority[i] = 0;
+    }
+    stop_music();
+}
+
+void load_instrument(char channel, const Instrument* instr) {
+    if(instr == ((Instrument*) 0xFFFF)) {
+        percussion_channel_mask |= channel_masks[channel];
+        return;
+    }
+    percussion_channel_mask &= ~channel_masks[channel];
+    music_state.instruments[channel] = instr;
+    channel_note_offset[channel] = instr->transpose;
+    aram[FEEDBACK_AMT + channel] = (instr->feedback << 3) + 128;
+    channel = channel << 2;
+    env_initial[channel] = instr->env_initial[0];
+    env_decay[channel] = instr->env_decay[0];
+    env_sustain[channel] = instr->env_sustain[0];
+    op_transpose[channel] = instr->op_transpose[0];
+    ++channel;
+    env_initial[channel] = instr->env_initial[1];
+    env_decay[channel] = instr->env_decay[1];
+    env_sustain[channel] = instr->env_sustain[1];
+    op_transpose[channel] = instr->op_transpose[1];
+    ++channel;
+    env_initial[channel] = instr->env_initial[2];
+    env_decay[channel] = instr->env_decay[2];
+    env_sustain[channel] = instr->env_sustain[2];
+    op_transpose[channel] = instr->op_transpose[2];
+    ++channel;
+    env_initial[channel] = instr->env_initial[3];
+    env_decay[channel] = instr->env_decay[3];
+    env_sustain[channel] = instr->env_sustain[3];
+    op_transpose[channel] = instr->op_transpose[3];
+}
+
+char n_mul;
+void set_note(char ch, char n) {
+    n_mul = op_transpose[ch] + n;
+    n_mul += n_mul;
+    set_audio_param(PITCH_MSB + ch, pitch_table[n_mul]);
+    set_audio_param(PITCH_LSB + ch, pitch_table[n_mul + 1]);
+    ++ch;
+    n_mul = op_transpose[ch] + n;
+    n_mul += n_mul;
+    set_audio_param(PITCH_MSB + ch, pitch_table[n_mul]);
+    set_audio_param(PITCH_LSB + ch, pitch_table[n_mul + 1]);
+    ++ch;
+    n_mul = op_transpose[ch] + n;
+    n_mul += n_mul;
+    set_audio_param(PITCH_MSB + ch, pitch_table[n_mul]);
+    set_audio_param(PITCH_LSB + ch, pitch_table[n_mul + 1]);
+    ++ch;
+    n_mul = op_transpose[ch] + n;
+    n_mul += n_mul;
+    set_audio_param(PITCH_MSB + ch, pitch_table[n_mul]);
+    set_audio_param(PITCH_LSB + ch, pitch_table[n_mul + 1]);
+}
+
+void play_song(const unsigned char* song, char bank_num, char loop) {
+    char n;
+    push_song_stack();
+    music_state.bank = bank_num;
+    push_rom_bank();
+    change_rom_bank(music_state.bank);
+    music_state.cursor = song;
+
+    for(n = 0; n < NUM_FM_OPS; ++n) {
+        audio_amplitudes[n] = 0;
+        set_audio_param(AMPLITUDE+n, 128);
+    }
+
+    switch(loop) {
+        case REPEAT_NONE: 
+            music_state.repeat_ptr = 0;
+            music_mode = REPEAT_NONE;
+            music_state.flags = 0;
+            break;
+        case REPEAT_LOOP:
+            music_state.repeat_ptr = music_state.cursor;
+            music_mode = REPEAT_LOOP;
+            music_state.flags = 0;
+            break;
+        case REPEAT_RESUME:
+            music_state.flags = MUSIC_FLAG_POP_AT_END;
+            break;
+    }
+
+    if(music_state.cursor) {
+        percussion_channel_mask = 0;
+        music_state.cfg = *(music_state.cursor++);
+        load_instrument(0, get_instrument_ptr(*(music_state.cursor++)));
+        load_instrument(1, get_instrument_ptr(*(music_state.cursor++)));
+        load_instrument(2, get_instrument_ptr(*(music_state.cursor++)));
+        load_instrument(3, get_instrument_ptr(*(music_state.cursor++)));
+        music_state.delay = *(music_state.cursor++);
+    }
+
+    pop_rom_bank();
+}
+
+void pause_music() {
+    push_song_stack();
+    music_state.cursor = 0;
+    note_held_mask = 0;
+}
+
+void unpause_music() {
+    pop_song_stack();
+}
+
+void tick_music() {
+    static unsigned char n, noteMask, ch;
+    register unsigned char a, op;
+    push_rom_bank();
+    for(n = 0; n < NUM_FM_CHANNELS; ++n) {
+        if(sound_effect_length[n]) {
+            --sound_effect_length[n];
+            if(sound_effect_length[n]) {
+                
+                change_rom_bank(sound_effect_bank[n]);
+
+                op = n << 2;
+                set_audio_param(AMPLITUDE + op, (*(sound_effect_ptr[n]+0) << 3) + 128);
+                a = *(sound_effect_ptr[n]+4) << 1;
+                set_audio_param(PITCH_MSB + op, pitch_table[a]);
+                set_audio_param(PITCH_LSB + op, pitch_table[a+1]);
+
+                ++op;
+                set_audio_param(AMPLITUDE + op, (*(sound_effect_ptr[n]+1) << 3) + 128);
+                a = *(sound_effect_ptr[n]+5) << 1;
+                set_audio_param(PITCH_MSB + op, pitch_table[a]);
+                set_audio_param(PITCH_LSB + op, pitch_table[a+1]);
+
+                ++op;
+                set_audio_param(AMPLITUDE + op, (*(sound_effect_ptr[n]+2) << 3) + 128);
+                a = *(sound_effect_ptr[n]+6) << 1;
+                set_audio_param(PITCH_MSB + op, pitch_table[a]);
+                set_audio_param(PITCH_LSB + op, pitch_table[a+1]);
+
+                ++op;
+                set_audio_param(AMPLITUDE + op, (*(sound_effect_ptr[n]+3) << 3) + 128);
+                a = *(sound_effect_ptr[n]+7) << 1;
+                set_audio_param(PITCH_MSB + op, pitch_table[a]);
+                set_audio_param(PITCH_LSB + op, pitch_table[a+1]);
+
+                sound_effect_ptr[n] += 8;
+
+            } else {
+                op = n << 2;
+                set_audio_param(AMPLITUDE+(op+3), 128);
+                aram[FEEDBACK_AMT + n] = saved_feedback_value[n];
+                music_channel_mask |= channel_masks[n];
+                sound_effect_priority[n] = 0;
+            }
+        }
+    }
+
+    change_rom_bank(music_state.bank);
+    op = 0;
+    for(ch = 1; ch < 16; ch = ch << 1) {
+        if(ch & ~(music_channel_mask & note_held_mask)) {
+            op+=4;
+            continue;
+        }
+        for(a = 0; a < 4; ++a) {
+            if(((env_sustain[op] - audio_amplitudes[op]) ^ (env_decay[op])) & 0x80) {
+                audio_amplitudes[op] -= env_decay[op];
+            } else {
+                audio_amplitudes[op] = env_sustain[op];
+            }
+            set_audio_param(AMPLITUDE+op, (audio_amplitudes[op] >> 1) + 128);
+            ++op;
+        }
+    }
+
+    if(music_state.cursor) {
+        loadAudioEvent:
+        if(music_state.delay > 0) {
+            music_state.delay--;
+        } else {
+            noteMask = *(music_state.cursor++);
+            for(ch = 0; ch < NUM_FM_CHANNELS; ++ch) {
+                if(channel_masks[ch] & noteMask) {
+                    n = *(music_state.cursor++);
+                    if(music_state.cfg & MUSIC_CFG_VELOCITY)
+                        a = *(music_state.cursor++);
+                    if(channel_masks[ch] & percussion_channel_mask) {
+                        if(n > 0) play_sound_effect(n - 1, ch);
+                    } else if(channel_masks[ch] & music_channel_mask) {
+                        op = ch << 2;
+                        if(n > 0) {
+                            
+                            set_note(op, n + channel_note_offset[ch]);
+                            audio_amplitudes[op] = env_initial[op];
+                            set_audio_param(AMPLITUDE+op, (audio_amplitudes[op] >> 1) + 128);
+                            ++op;
+                            audio_amplitudes[op] = env_initial[op];
+                            set_audio_param(AMPLITUDE+op, (audio_amplitudes[op] >> 1) + 128);
+                            ++op;
+                            audio_amplitudes[op] = env_initial[op];
+                            set_audio_param(AMPLITUDE+op, (audio_amplitudes[op] >> 1) + 128);
+                            ++op;
+                            if(music_state.cfg & MUSIC_CFG_VELOCITY)
+                                audio_amplitudes[op] = a;
+                            else
+                                audio_amplitudes[op] = env_initial[op];
+                            set_audio_param(AMPLITUDE+op, (audio_amplitudes[op] >> 1) + 128);
+                        } else {
+                            audio_amplitudes[op+3] = 0;
+                            set_audio_param(AMPLITUDE+op+3, 128);
+                        }
+                    }
+                    if(n) {
+                        note_held_mask |= channel_masks[ch];
+                    } else {
+                        note_held_mask &= ~channel_masks[ch];
+                    }
+                }
+            }
+            music_state.delay = *(music_state.cursor++);
+            if(music_state.delay == 0) {
+                if(music_state.flags & MUSIC_FLAG_POP_AT_END) {
+                    pop_song_stack();
+                } else {
+                    music_state.cursor = music_state.repeat_ptr;
+                    if(music_state.cursor) {
+                        music_state.cursor+=5; //skip cfg and instruments
+                        music_state.delay = *(music_state.cursor++);
+                        goto loadAudioEvent;
+                    } else {
+                        silence_all_channels();
+                    }
+                }
+            } else {
+                --music_state.delay;
+            }
+        }
+    }
+
+    flush_audio_params();
+    pop_rom_bank();
+}
+
+void silence_all_channels() {
+    char n;
+    for(n = 0; n < NUM_FM_OPS; ++n) {
+        audio_amplitudes[n] = 0;
+        set_audio_param(AMPLITUDE+n, 128);
+    }
+    note_held_mask = 0;
+}
+
+void stop_music() {
+    music_state.cursor = 0;
+    silence_all_channels();
+}
+
+void play_sound_effect(char sfx_id, char channel) { 
+    static char priority;
+    priority = channel & 0xF0;
+    channel &= 0x03;
+    if(priority < sound_effect_priority[channel]) return;
+    sound_effect_priority[channel] = priority;
+    push_rom_bank();
+    change_rom_bank(BANK_LOADERS);
+    sound_effect_bank[channel] = ASSET__sfx_bank_table[sfx_id];
+    sound_effect_ptr[channel] = ASSET__sfx_ptr_table[sfx_id];
+    change_rom_bank(sound_effect_bank[channel]);
+    sound_effect_length[channel] = *(sound_effect_ptr[channel]++) + 1;
+    saved_feedback_value[channel] = aram[FEEDBACK_AMT + channel];
+    aram[FEEDBACK_AMT + channel] = *(sound_effect_ptr[channel]++);
+    music_channel_mask &= ~(channel_masks[channel]);
+    pop_rom_bank();
+}