1 files changed, 238 insertions, 0 deletions

diff --git a/src/apu.c b/src/apu.c
new file mode 100644
index 0000000..8dd4ce5
--- /dev/null
+++ b/src/apu.c
@@ -0,0 +1,238 @@
+//
+//       REG_TM0D                    frequency    buffer size
+//          |                            |            |
+//          V                            V            V
+//
+// Timer = 62610 = 65536 - (16777216 /  5734), buf = 96
+// Timer = 63940 = 65536 - (16777216 / 10512), buf = 176
+// Timer = 64282 = 65536 - (16777216 / 13379), buf = 224
+// Timer = 64612 = 65536 - (16777216 / 18157), buf = 304
+// Timer = 64738 = 65536 - (16777216 / 21024), buf = 352
+// Timer = 64909 = 65536 - (16777216 / 26758), buf = 448
+// Timer = 65004 = 65536 - (16777216 / 31536), buf = 528
+// Timer = 65073 = 65536 - (16777216 / 36314), buf = 608
+// Timer = 65118 = 65536 - (16777216 / 40137), buf = 672
+// Timer = 65137 = 65536 - (16777216 / 42048), buf = 704
+//
+// Source: https://deku.gbadev.org/program/sound1.html
+#define AUDIO_FREQ    18157
+#define AUDIO_BUF_LEN 304
+#define AUDIO_TIMER   64612
+
+typedef struct Audio {
+    s8 mix_buffer[AUDIO_BUF_LEN * 2];
+    s8 *current_buffer;
+    u8 active_buffer;
+} Audio;
+
+typedef struct AudioChannel {
+    // Pointer to the raw data in the ROM.
+    u8 *data;
+    // Current position in the data (20.12 fixed-point).
+    u32 pos;
+    // Increment (20.12 fixed-point).
+    u32 inc;
+    // Volume (0-64, 1.6 fixed-point).
+    u32 vol;
+    // Sound length (20.12 fixed-point).
+    u32 length;
+    // Length of looped portion (20.12 fixed-point, 0 to disable looping).
+    u32 loop_length;
+    // Pitch encoded as a MIDI note.
+    u8 pitch;
+    // Keeping track of the original adsr values.
+    u16 adsr;
+    // The filter is built with the ADSR and has a maximum duration of
+    // 4 seconds. Each component can last up to 1 second.
+    u8 filter[240];
+    // Current position in the filter (0-60).
+    u8 filter_pos;
+    // Duration of the filter.
+    u8 filter_len;
+} AudioChannel;
+
+// Calculated as ((261.6 / 18157) << 17) for C4. If multiplied by sampling rate
+// we will have a u32 (15.17) fixed-point number. This should be enough to
+// accurately portray samples up to 75300 Hz.
+static u16 pitch_table[120] = {
+    59,    62,    66,    70,    74,    78,    83,    88,
+    93,    99,    105,   111,   118,   125,   132,   140,
+    148,   157,   166,   176,   187,   198,   210,   222,
+    236,   250,   264,   280,   297,   315,   333,   353,
+    374,   396,   420,   445,   472,   500,   529,   561,
+    594,   630,   667,   707,   749,   793,   841,   891,
+    944,   1000,  1059,  1122,  1189,  1260,  1335,  1414,
+    1498,  1587,  1682,  1782,  1888,  2000,  2119,  2245,
+    2379,  2520,  2670,  2829,  2997,  3175,  3364,  3564,
+    3776,  4001,  4239,  4491,  4758,  5041,  5341,  5658,
+    5995,  6351,  6729,  7129,  7553,  8002,  8478,  8982,
+    9517,  10083, 10682, 11317, 11990, 12703, 13459, 14259,
+    15107, 16005, 16957, 17965, 19034, 20166, 21365, 22635,
+    23981, 25407, 26918, 28519, 30215, 32011, 33915, 35931,
+    38068, 40332, 42730, 45271, 47963, 50815, 53837, 57038,
+};
+
+IWRAM_CODE
+void
+build_adsr(AudioChannel *chan, u16 adsr) {
+    chan->filter_pos = 0;
+    if (adsr == chan->adsr) {
+        return;
+    }
+
+    u8 a = (adsr >> 12);
+    u8 d = (adsr >> 8) & 0xF;
+    u8 s = (adsr >> 4) & 0xF;
+    u8 r = (adsr >> 0) & 0xF;
+
+    // Initialize the filter array.
+    dma_fill(chan->filter, 0, sizeof(chan->filter), 3);
+    u8 k = 0;
+
+    // Attack.
+    u32 interval = FP_DIV(1 << 6, (4 * a) << 6, 6);
+    for (u32 i = 0; i < 4 * a; ++i) {
+        chan->filter[k++] = FP_LERP(0, chan->vol, i * interval, 6);
+    }
+    // Decay.
+    interval = FP_DIV(1 << 6, (4 * d) << 6, 6);
+    for (u32 i = 0; i < 4 * d; ++i) {
+        chan->filter[k++] = FP_LERP(chan->vol, chan->vol / 2, i * interval, 6);
+    }
+    // Sustain.
+    for (u32 i = 0; i < 4 * s; ++i) {
+        chan->filter[k++] = chan->vol / 2;
+    }
+    // Release.
+    interval = FP_DIV(1 << 6, (4 * r) << 6, 6);
+    for (u32 i = 0; i < 4 * r; ++i) {
+        chan->filter[k++] = FP_LERP(chan->vol / 2, 0, i * interval, 6);
+    }
+
+    // Setup the channel vars.
+    chan->adsr = adsr;
+    chan->filter_len = k;
+}
+
+static Audio audio;
+
+#define POLYPHONY 4
+static AudioChannel channels[POLYPHONY];
+
+void
+init_sound(void) {
+    // Initialize audio buffers/channels.
+    audio = (Audio){0};
+    for (size_t i = 0; i < POLYPHONY; ++i) {
+        channels[i] = (AudioChannel){0};
+    }
+
+    // Enable the sound chip.
+    SOUND_STATUS = SOUND_ENABLE;
+
+    // Set max volume, left-right sound, fifo reset and use timer 0 for
+    // DirectSound A.
+    SOUND_DSOUND_MASTER = SOUND_DSOUND_RATIO_A
+        | SOUND_DSOUND_LEFT_A
+        | SOUND_DSOUND_RIGHT_A
+        | SOUND_DSOUND_RESET_A;
+
+    // The timer depends on the buffer length.
+    TIMER_DATA_0 = AUDIO_TIMER;
+    TIMER_CTRL_0 = TIMER_CTRL_ENABLE;
+}
+
+void
+sound_vsync() {
+    if(audio.active_buffer == 1) {
+        // Start playing and set the backbuffer.
+        dma_transfer_copy(SOUND_FIFO_A, audio.mix_buffer, 1, 1, DMA_DST_FIXED
+                | DMA_CHUNK_32 | DMA_REFRESH | DMA_REPEAT | DMA_ENABLE);
+        audio.current_buffer = audio.mix_buffer + AUDIO_BUF_LEN;
+        audio.active_buffer = 0;
+    } else {
+        // Flip front/backbuffer.
+        audio.current_buffer = audio.mix_buffer;
+        audio.active_buffer = 1;
+    }
+}
+
+IWRAM_CODE
+void
+update_channel(AudioChannel *c, u8 *data, u16 length, u8 pitch, u16 adsr,
+        u8 vol, bool loop) {
+    c->pos = 0;
+    c->length = length << 12;
+    c->data = data;
+    c->vol = vol;
+    c->pitch = pitch;
+
+    if (loop) {
+        c->loop_length = c->length;
+    } else {
+        c->loop_length = 0;
+    }
+
+    u32 sampling_rate = length;
+    if (length > 256) {
+        sampling_rate = 44100;
+    }
+    c->inc = (pitch_table[c->pitch] * sampling_rate) >> 5;
+
+    build_adsr(c, adsr);
+}
+
+IWRAM_CODE
+void
+sound_mix(void) {
+    // Clear mix_buffer.
+    u16 mix_buffer[AUDIO_BUF_LEN];
+    dma_fill(mix_buffer, 0, sizeof(mix_buffer), 3);
+
+    // Mix channels into the temporary buffer.
+    for (size_t j = 0; j < POLYPHONY; ++j) {
+        AudioChannel *ch = &channels[j];
+        // Check if channel is active.
+        if (ch->data == NULL || ch->pitch >= 108) {
+            continue;
+        }
+
+        u32 vol = ch->vol;
+        if (ch->adsr != 0) {
+            vol = ch->filter[ch->filter_pos++];
+            if (ch->filter_pos == ch->filter_len) {
+                continue;
+            }
+        }
+
+        for(size_t i = 0; i < AUDIO_BUF_LEN; i++) {
+            // Remember we are using fixed point values.
+            mix_buffer[i] += (0x80 ^ (s8)ch->data[ch->pos >> 12]) * vol;
+            ch->pos += ch->inc;
+
+            if (ch->pos >= ch->length) {
+                // If looping is not active disable the channel.
+                if (ch->loop_length == 0) {
+                    ch->data = NULL;
+                    break;
+                }
+
+                // Loop the sample.
+                while (ch->pos >= ch->length) {
+                    ch->pos -= ch->loop_length;
+                }
+            }
+        }
+    }
+
+    // Downsample and copy to the playing buffer (Vectorized).
+    u64 *mix_ptr = mix_buffer;
+    u32 *buf_ptr = audio.current_buffer;
+    for (size_t i = 0; i < AUDIO_BUF_LEN / 4; i++) {
+        u64 mix = mix_ptr[i];
+        buf_ptr[i] = ((mix >> 8) & 0xFF)
+            | ((mix >> 16) & 0xFF00)
+            | ((mix >> 24) & 0xFF0000)
+            | ((mix >> 32) & 0xFF000000);
+    }
+}