// Commander X16 Emulator

// Copyright (c) 2024 MooingLemur

// All rights reserved. License: 2-clause BSD

#include <pthread.h>

#include <stdio.h>

#include "glue.h"

#include "midi.h"

#include "audio.h"

#include "endian.h"

#ifdef _WIN32

    #include <windows.h>

    #define LIBRARY_TYPE HMODULE

    #define LOAD_LIBRARY(name) LoadLibrary(name)

    #define GET_FUNCTION(lib, name) (void *)GetProcAddress(lib, name)

    #define CLOSE_LIBRARY(lib) FreeLibrary(lib)

#else

    #include <dlfcn.h>

    #define LIBRARY_TYPE void*

    #define LOAD_LIBRARY(name) dlopen(name, RTLD_LAZY)

    #define GET_FUNCTION(lib, name) dlsym(lib, name)

    #define CLOSE_LIBRARY(lib) dlclose(lib)

#endif

#define ASSIGN_FUNCTION(lib, var, name) {\

    var = GET_FUNCTION(lib, name);\

    if (!var) { fprintf(stderr, "Unable to find symbol for '%s'\n", name); CLOSE_LIBRARY(handle); return; }\

}

enum MIDI_states {

    MSTATE_Normal,

    MSTATE_Param,

    MSTATE_SysEx,

};

struct midi_serial_regs

{

    LOW_HIGH_UNION(dl, dll, dlm);

    bool ier_erbi;

    bool ier_etbei;

    bool ier_elsi;

    bool ier_edssi;

    uint8_t iir;

    bool fcr_fifo_enable;

    uint8_t fcr_ififo_trigger_level_bytes;

    uint8_t lcr_word_length_bits;

    bool lcr_stb;

    bool lcr_pen;

    bool lcr_eps;

    bool lcr_stick;

    bool lcr_break;

    bool lcr_dlab;

    bool mcr_dtr;

    bool mcr_rts;

    bool mcr_out1;

    bool mcr_out2;

    bool mcr_loop;

    bool mcr_afe;

    bool lsr_oe;

    bool lsr_pe;

    bool lsr_fe;

    bool lsr_bi;

    bool lsr_eif;

    bool msr_dcts;

    bool msr_ddsr;

    bool msr_teri;

    bool msr_ddcd;

    bool msr_cts;

    bool msr_dsr;

    bool msr_ri;

    bool msr_dcd;

    uint8_t obyte_bits_remain;

    uint8_t ibyte_bits_remain;

    uint8_t rx_timeout;

    bool rx_timeout_enabled;

    bool thre_intr;

    uint8_t thre_bits_remain;

    uint8_t scratch;

    uint8_t ififo[16];

    uint8_t ifsz;

    uint8_t ofifo[16];

    uint8_t ofsz;

    int64_t clock; // 40.24 fixed point

    int32_t clockdec; // 8.24 fixed point

    time_t last_warning;

    uint8_t midi_event_fifo[256];

    int mfsz;

    uint8_t in_midi_last_command;

    pthread_mutex_t fifo_mutex;

    pthread_mutexattr_t fifo_mutex_attr;

};

struct midi_serial_regs mregs[2];

static bool serial_midi_mutexes_initialized = false;

void midi_serial_iir_check(uint8_t sel);

bool fs_midi_in_connect = false;

#ifdef HAS_FLUIDSYNTH

int handle_midi_event(void* data, fluid_midi_event_t* event);

static uint8_t sysex_buffer[1024];

static int sysex_bufptr;

static enum MIDI_states midi_state[2] = {MSTATE_Normal, MSTATE_Normal};

static uint8_t out_midi_last_command[2] = {0, 0};

static uint8_t out_midi_first_param[2];

static uint16_t out_midi_nrpn[2][16];

static uint16_t out_midi_rpn[2][16];

static bool out_midi_nrpn_active[2][16];

static bool midi_initialized = false;

static fluid_settings_t* fl_settings;

static fluid_midi_driver_t* fl_mdriver;

static fluid_synth_t* fl_synth;

static int fl_sf2id;

typedef fluid_settings_t* (*new_fluid_settings_f_t)(void);

typedef fluid_synth_t* (*new_fluid_synth_f_t)(fluid_settings_t*);

typedef fluid_audio_driver_t* (*new_fluid_audio_driver_f_t)(fluid_settings_t*, fluid_synth_t*);

typedef fluid_midi_driver_t* (*new_fluid_midi_driver_f_t)(fluid_settings_t*, handle_midi_event_func_t, void*);

typedef int (*fluid_settings_setnum_f_t)(fluid_settings_t*,const char*, double);

typedef int (*fluid_settings_setint_f_t)(fluid_settings_t*,const char*, int);

typedef int (*fluid_settings_setstr_f_t)(fluid_settings_t*,const char*, const char*);

typedef int (*fluid_synth_sfload_f_t)(fluid_synth_t*, const char *, int);

typedef int (*fluid_synth_program_change_f_t)(fluid_synth_t*, int, int);

typedef int (*fluid_synth_channel_pressure_f_t)(fluid_synth_t*, int, int);

typedef int (*fluid_synth_system_reset_f_t)(fluid_synth_t*);

typedef int (*fluid_synth_noteoff_f_t)(fluid_synth_t*, int, int);

typedef int (*fluid_synth_noteon_f_t)(fluid_synth_t*, int, int, int);

typedef int (*fluid_synth_key_pressure_f_t)(fluid_synth_t*, int, int, int);

typedef int (*fluid_synth_cc_f_t)(fluid_synth_t*, int, int, int);

typedef int (*fluid_synth_pitch_bend_f_t)(fluid_synth_t*, int, int);

typedef int (*fluid_synth_sysex_f_t)(fluid_synth_t*, const char*, int, char*, int*, int*, int);

typedef int (*fluid_synth_write_s16_f_t)(fluid_synth_t*, int, void*, int, int, void*, int, int);

typedef int (*fluid_midi_event_get_channel_f_t)(const fluid_midi_event_t*);

typedef int (*fluid_midi_event_get_control_f_t)(const fluid_midi_event_t*);

typedef int (*fluid_midi_event_get_key_f_t)(const fluid_midi_event_t*);

typedef int (*fluid_midi_event_get_lyrics_f_t)(const fluid_midi_event_t*, void**, int*);

typedef int (*fluid_midi_event_get_pitch_f_t)(const fluid_midi_event_t*);

typedef int (*fluid_midi_event_get_program_f_t)(const fluid_midi_event_t*);

typedef int (*fluid_midi_event_get_text_f_t)(const fluid_midi_event_t*, void**, int*);

typedef int (*fluid_midi_event_get_type_f_t)(const fluid_midi_event_t*);

typedef int (*fluid_midi_event_get_value_f_t)(const fluid_midi_event_t*);

typedef int (*fluid_midi_event_get_velocity_f_t)(const fluid_midi_event_t*);

typedef int (*fluid_midi_event_set_type_f_t)(fluid_midi_event_t*, int);

static new_fluid_settings_f_t dl_new_fluid_settings;

static new_fluid_synth_f_t dl_new_fluid_synth;

static new_fluid_audio_driver_f_t dl_new_fluid_audio_driver;

static new_fluid_midi_driver_f_t dl_new_fluid_midi_driver;

static fluid_settings_setnum_f_t dl_fluid_settings_setnum;

static fluid_settings_setint_f_t dl_fluid_settings_setint;

static fluid_settings_setstr_f_t dl_fluid_settings_setstr;

static fluid_synth_sfload_f_t dl_fs_sfload;

static fluid_synth_program_change_f_t dl_fs_program_change;

static fluid_synth_channel_pressure_f_t dl_fs_channel_pressure;

static fluid_synth_system_reset_f_t dl_fs_system_reset;

static fluid_synth_noteoff_f_t dl_fs_noteoff;

static fluid_synth_noteon_f_t dl_fs_noteon;

static fluid_synth_key_pressure_f_t dl_fs_key_pressure;

static fluid_synth_cc_f_t dl_fs_cc;

static fluid_synth_pitch_bend_f_t dl_fs_pitch_bend;

static fluid_synth_sysex_f_t dl_fs_sysex;

static fluid_synth_write_s16_f_t dl_fs_write_s16;

static fluid_midi_event_get_channel_f_t dl_fluid_midi_event_get_channel;

static fluid_midi_event_get_control_f_t dl_fluid_midi_event_get_control;

static fluid_midi_event_get_key_f_t dl_fluid_midi_event_get_key;

static fluid_midi_event_get_lyrics_f_t dl_fluid_midi_event_get_lyrics;

static fluid_midi_event_get_pitch_f_t dl_fluid_midi_event_get_pitch;

static fluid_midi_event_get_program_f_t dl_fluid_midi_event_get_program;

static fluid_midi_event_get_text_f_t dl_fluid_midi_event_get_text;

static fluid_midi_event_get_type_f_t dl_fluid_midi_event_get_type;

static fluid_midi_event_get_value_f_t dl_fluid_midi_event_get_value;

static fluid_midi_event_get_velocity_f_t dl_fluid_midi_event_get_velocity;

static fluid_midi_event_set_type_f_t dl_fluid_midi_event_set_type;

void midi_init()

{

    if (midi_initialized) {

        return;

    }

#ifdef _WIN32

    LIBRARY_TYPE handle = LOAD_LIBRARY("libfluidsynth-3.dll");

#elif __APPLE__

    LIBRARY_TYPE handle = LOAD_LIBRARY("libfluidsynth.dylib");

#else

    LIBRARY_TYPE handle = LOAD_LIBRARY("libfluidsynth.so.3");

#endif

    if (!handle) {

        // Handle the error on both platforms

#ifdef _WIN32

        fprintf(stderr, "Could not load MIDI synth library: error code %lu\n", GetLastError());

#else

        fprintf(stderr, "Could not load MIDI synth library: %s\n", dlerror());

#endif

        return;

    }

#ifndef _WIN32

    dlerror();

#endif

    ASSIGN_FUNCTION(handle, dl_new_fluid_settings, "new_fluid_settings");

    ASSIGN_FUNCTION(handle, dl_new_fluid_synth, "new_fluid_synth");

    ASSIGN_FUNCTION(handle, dl_new_fluid_audio_driver, "new_fluid_audio_driver");

    ASSIGN_FUNCTION(handle, dl_new_fluid_midi_driver, "new_fluid_midi_driver");

    ASSIGN_FUNCTION(handle, dl_fluid_settings_setnum, "fluid_settings_setnum");

    ASSIGN_FUNCTION(handle, dl_fluid_settings_setint, "fluid_settings_setint");

    ASSIGN_FUNCTION(handle, dl_fluid_settings_setstr, "fluid_settings_setstr");

    ASSIGN_FUNCTION(handle, dl_fs_sfload, "fluid_synth_sfload");

    ASSIGN_FUNCTION(handle, dl_fs_program_change, "fluid_synth_program_change");

    ASSIGN_FUNCTION(handle, dl_fs_channel_pressure, "fluid_synth_channel_pressure");

    ASSIGN_FUNCTION(handle, dl_fs_system_reset, "fluid_synth_system_reset");

    ASSIGN_FUNCTION(handle, dl_fs_noteoff, "fluid_synth_noteoff");

    ASSIGN_FUNCTION(handle, dl_fs_noteon, "fluid_synth_noteon");

    ASSIGN_FUNCTION(handle, dl_fs_key_pressure, "fluid_synth_key_pressure");

    ASSIGN_FUNCTION(handle, dl_fs_cc, "fluid_synth_cc");

    ASSIGN_FUNCTION(handle, dl_fs_pitch_bend, "fluid_synth_pitch_bend");

    ASSIGN_FUNCTION(handle, dl_fs_sysex, "fluid_synth_sysex");

    ASSIGN_FUNCTION(handle, dl_fs_write_s16, "fluid_synth_write_s16");

    ASSIGN_FUNCTION(handle, dl_fluid_midi_event_get_channel, "fluid_midi_event_get_channel");

    ASSIGN_FUNCTION(handle, dl_fluid_midi_event_get_control, "fluid_midi_event_get_control");

    ASSIGN_FUNCTION(handle, dl_fluid_midi_event_get_key, "fluid_midi_event_get_key");

    ASSIGN_FUNCTION(handle, dl_fluid_midi_event_get_lyrics, "fluid_midi_event_get_lyrics");

    ASSIGN_FUNCTION(handle, dl_fluid_midi_event_get_pitch, "fluid_midi_event_get_pitch");

    ASSIGN_FUNCTION(handle, dl_fluid_midi_event_get_program, "fluid_midi_event_get_program");

    ASSIGN_FUNCTION(handle, dl_fluid_midi_event_get_text, "fluid_midi_event_get_text");

    ASSIGN_FUNCTION(handle, dl_fluid_midi_event_get_type, "fluid_midi_event_get_type");

    ASSIGN_FUNCTION(handle, dl_fluid_midi_event_get_value, "fluid_midi_event_get_value");

    ASSIGN_FUNCTION(handle, dl_fluid_midi_event_get_velocity, "fluid_midi_event_get_velocity");

    ASSIGN_FUNCTION(handle, dl_fluid_midi_event_set_type, "fluid_midi_event_set_type");

    fl_settings = dl_new_fluid_settings();

    dl_fluid_settings_setnum(fl_settings, "synth.sample-rate", 

    AUDIO_SAMPLERATE);

    dl_fluid_settings_setnum(fl_settings, "synth.gain", FL_DEFAULT_GAIN);

    dl_fluid_settings_setstr(fl_settings, "midi.portname", "Commander X16 Emulator");

    dl_fluid_settings_setint(fl_settings, "midi.autoconnect", fs_midi_in_connect);

    fl_synth = dl_new_fluid_synth(fl_settings);

    if (fs_midi_in_connect) {

        fl_mdriver = dl_new_fluid_midi_driver(fl_settings, handle_midi_event, &mregs[0]);

    }

    midi_initialized = true;

    fprintf(stderr, "Initialized MIDI synth at $%04X.\n", midi_card_addr);

}

void midi_load_sf2(uint8_t* filename)

{

    if (!midi_initialized) return;

    fl_sf2id = dl_fs_sfload(fl_synth, (const char *)filename, true);

    if (fl_sf2id == FLUID_FAILED) {

        fprintf(stderr, "Unable to load soundfont.\n");

    }

}

// Receive a byte from client

// Store state, or dispatch event

void midi_byte_out(uint8_t sel, uint8_t b)

{

    uint8_t chan = out_midi_last_command[sel] & 0xf;

    if (!midi_initialized) return;

    switch (midi_state[sel]) {

        case MSTATE_Normal:

            if (b < 0x80) {

                if ((out_midi_last_command[sel] & 0xf0) == 0xc0) { // patch change

                    dl_fs_program_change(fl_synth, out_midi_last_command[sel] & 0xf, b);

                } else if ((out_midi_last_command[sel] & 0xf0) == 0xd0) { // channel pressure

                    dl_fs_channel_pressure(fl_synth, out_midi_last_command[sel] & 0xf, b);

                } else if (out_midi_last_command[sel] >= 0x80) { // two-param command

                    out_midi_first_param[sel] = b;

                    midi_state[sel] = MSTATE_Param;

                }

            } else {

                if (b < 0xf0) {

                    out_midi_last_command[sel] = b;

                } else if (b == 0xf0) {

                    sysex_bufptr = 0;

                    midi_state[sel] = MSTATE_SysEx;

                    out_midi_last_command[sel] = 0;

                } else if (b == 0xff) {

                    dl_fs_system_reset(fl_synth);

                    out_midi_last_command[sel] = 0;

                } else if (b < 0xf8) {

                    out_midi_last_command[sel] = 0;

                }

            }

            break;

        case MSTATE_Param:

            switch (out_midi_last_command[sel] & 0xf0) {

                case 0x80: // note off

                    dl_fs_noteoff(fl_synth, chan, out_midi_first_param[sel]); // no release velocity

                    break;

                case 0x90: // note on

                    if (b == 0) {

                        dl_fs_noteoff(fl_synth, chan, out_midi_first_param[sel]);

                    } else {

                        dl_fs_noteon(fl_synth, chan, out_midi_first_param[sel], b);

                    }

                    break;

                case 0xa0: // aftertouch

                    dl_fs_key_pressure(fl_synth, chan, out_midi_first_param[sel], b);

                    break;

                case 0xb0: // controller

                    switch (out_midi_first_param[sel]) {

                        case 98:

                            out_midi_nrpn_active[sel][chan] = true;

                            out_midi_nrpn[sel][chan] = (out_midi_nrpn[sel][chan] & 0x00ff) | (b << 8);

                            break;

                        case 99:

                            out_midi_nrpn_active[sel][chan] = true;

                            out_midi_nrpn[sel][chan] = (out_midi_nrpn[sel][chan] & 0xff00) | b;

                            break;

                        case 100:

                            out_midi_nrpn_active[sel][chan] = false;

                            out_midi_rpn[sel][chan] = (out_midi_rpn[sel][chan] & 0x00ff) | (b << 8);

                            break;

                        case 101:

                            out_midi_nrpn_active[sel][chan] = false;

                            out_midi_rpn[sel][chan] = (out_midi_rpn[sel][chan] & 0xff00) | b;

                            break;

                    }

                    dl_fs_cc(fl_synth, chan, out_midi_first_param[sel], b);

                    if (out_midi_nrpn_active[sel][chan] && out_midi_nrpn[sel][chan] == 0x0121 && out_midi_first_param[sel] == 6) {

                        dl_fs_cc(fl_synth, chan, 71, b); // Translate NRPN 0x0121 -> Controller 71 (Timbre/Resonance)

                    }

                    break;

                case 0xe0: // pitch bend

                    dl_fs_pitch_bend(fl_synth, chan, ((uint16_t)out_midi_first_param[sel]) | (uint16_t)b << 7);

                    break;

            }

            midi_state[sel] = MSTATE_Normal;

            break;

        case MSTATE_SysEx:

            if (b & 0x80) { // any command byte can terminate a SYSEX, not just 0xf7

                if (sysex_bufptr < (sizeof(sysex_buffer) / sizeof(sysex_buffer[0]))-1) { // only if buffer didn't fill

                    sysex_buffer[sysex_bufptr] = 0;

                    if (!strncmp((char *)sysex_buffer, "\x7F\x7F\x04\x01\x00", sysex_bufptr-1)) {

                        // Handle Master Volume SysEx

                        dl_fluid_settings_setnum(fl_settings, "synth.gain", FL_DEFAULT_GAIN*((float)sysex_buffer[sysex_bufptr-1]/127));

                    } else if (!strncmp((char *)sysex_buffer, "\x7E\x7F\x09\x01", sysex_bufptr)) {

                        // Handle General MIDI reset SysEx

                        dl_fs_system_reset(fl_synth);

                    } else {

                        dl_fs_sysex(fl_synth, (char *)sysex_buffer, sysex_bufptr, NULL, NULL, NULL, 0);

                    }

                }

                midi_state[sel] = MSTATE_Normal;

                return midi_byte_out(sel, b);

            } else {

                sysex_buffer[sysex_bufptr] = b;

                // we can't do much about a runaway sysex other than continue to absorb it

                // but we throw it all away later if the buffer filled

                if (sysex_bufptr < (sizeof(sysex_buffer) / sizeof(sysex_buffer[0]))-1) {

                    sysex_bufptr++;

                }

            }

            break;

    }

}

void midi_synth_render(int16_t* buf, int len)

{

    if (midi_initialized) {

        dl_fs_write_s16(fl_synth, len, buf, 0, 2, buf, 1, 2);

    } else {

        memset(buf, 0, len * 2 * sizeof(int16_t));

    }

}

void midi_event_enqueue_byte(struct midi_serial_regs* mrp, uint8_t val)

{

    if (mrp->mfsz >= 256) return;

    mrp->midi_event_fifo[mrp->mfsz++] = val;

}

void midi_event_enqueue_short(struct midi_serial_regs* mrp, uint8_t cmd, uint8_t val)

{

    if (mrp->mfsz >= 255) {

        mrp->in_midi_last_command = 0;

        return;

    }

    if (mrp->in_midi_last_command != cmd) {

        mrp->midi_event_fifo[mrp->mfsz++] = cmd;

        mrp->in_midi_last_command = cmd;

    }

    mrp->midi_event_fifo[mrp->mfsz++] = val;

}

void midi_event_enqueue_normal(struct midi_serial_regs* mrp, uint8_t cmd, uint8_t key, uint8_t val)

{

    if (mrp->mfsz >= 254) {

        mrp->in_midi_last_command = 0;

        return;

    }

    if (mrp->in_midi_last_command != cmd) {

        mrp->midi_event_fifo[mrp->mfsz++] = cmd;

        mrp->in_midi_last_command = cmd;

    }

    mrp->midi_event_fifo[mrp->mfsz++] = key;

    mrp->midi_event_fifo[mrp->mfsz++] = val;

}

void midi_event_enqueue_sysex(struct midi_serial_regs* mrp, uint8_t *bufptr, int buflen)

{

    int i;

    mrp->in_midi_last_command = 0;

    if (mrp->mfsz >= 255L - (buflen + 2)) { // too full

        return;

    }

    mrp->midi_event_fifo[mrp->mfsz++] = 0xf0;

    for (i = 0; i < buflen; i++) {

        mrp->midi_event_fifo[mrp->mfsz++] = bufptr[i];

    }

    mrp->midi_event_fifo[mrp->mfsz++] = 0xf7;

}

int handle_midi_event(void* data, fluid_midi_event_t* event)

{

    struct midi_serial_regs* mrp = (struct midi_serial_regs*)data;

    pthread_mutex_lock(&mrp->fifo_mutex);

    uint8_t type = dl_fluid_midi_event_get_type(event);

    uint8_t chan = dl_fluid_midi_event_get_channel(event);

    uint8_t cmd = (type < 0x80 || type >= 0xf0) ? type : (type | (chan & 0xf));

    uint8_t key, val;

    uint8_t *bufptr;

    int buflen;

    switch (type) {

        case FS_NOTE_OFF:

        case FS_NOTE_ON:

            key = dl_fluid_midi_event_get_key(event);

            val = dl_fluid_midi_event_get_velocity(event);

            midi_event_enqueue_normal(mrp, cmd, key, val);

            break;

        case FS_KEY_PRESSURE:

            key = dl_fluid_midi_event_get_key(event);

            val = dl_fluid_midi_event_get_value(event);

            midi_event_enqueue_normal(mrp, cmd, key, val);

            break;

        case FS_CONTROL_CHANGE:

            key = dl_fluid_midi_event_get_control(event);

            val = dl_fluid_midi_event_get_value(event);

            midi_event_enqueue_normal(mrp, cmd, key, val);

            break;

        case FS_PITCH_BEND:

            key = dl_fluid_midi_event_get_pitch(event) & 0x7f;

            val = (dl_fluid_midi_event_get_pitch(event) >> 7) & 0x7f;

            midi_event_enqueue_normal(mrp, cmd, key, val);

            break;

        case FS_PROGRAM_CHANGE:

        case FS_CHANNEL_PRESSURE:

            val = dl_fluid_midi_event_get_program(event);

            midi_event_enqueue_short(mrp, cmd, val);

            break;

        case FS_MIDI_TIME_CODE:

            val = dl_fluid_midi_event_get_value(event);

            midi_event_enqueue_short(mrp, type, val);

            mrp->in_midi_last_command = 0;

            break;

        case FS_MIDI_TUNE_REQUEST:

        case 0xF4:

        case 0xF5:

            midi_event_enqueue_byte(mrp, type);

            mrp->in_midi_last_command = 0;

            break;

        case FS_MIDI_SYNC:

        case FS_MIDI_TICK:

        case FS_MIDI_START:

        case FS_MIDI_CONTINUE:

        case FS_MIDI_STOP:

        case FS_MIDI_ACTIVE_SENSING:

        case FS_MIDI_SYSTEM_RESET:

            midi_event_enqueue_byte(mrp, type);

            break;

        case FS_MIDI_SYSEX:

            // FluidSynth doesn't offer a get_sysex function, but internally

            // a text event is equivalent to a sysex event, in terms of what

            // parts of the event structure are populated

            //

            // Unfortunately that means we have to fool it in order to

            // access the data.

            dl_fluid_midi_event_set_type(event, FS_MIDI_TEXT);

            if (dl_fluid_midi_event_get_text(event, (void **)&bufptr, &buflen) == FLUID_OK && bufptr != NULL) {

                midi_event_enqueue_sysex(mrp, bufptr, buflen);

            }

            break;

    }

    //fprintf(stderr, "Debug: MIDI IN: Type: %02X Chan: %02X\n", type, chan);

    pthread_mutex_unlock(&mrp->fifo_mutex);

    return FLUID_OK;

}

#else

void midi_load_sf2(uint8_t* filename)

{

    // no-op

}

void midi_init()

{

    fprintf(stderr, "No FluidSynth support.\n");

}

void midi_byte_out(uint8_t sel, uint8_t b)

{

    // no-op

}

void midi_synth_render(int16_t* buf, int len)

{

    // no synth, return zeroed buffer

    memset(buf, 0, len * 2 * sizeof(int16_t));

}

#endif

void midi_serial_init()

{

    uint8_t sel;

    for (sel=0; sel<2; sel++) {

        mregs[sel].ier_erbi = false;

        mregs[sel].ier_etbei = false;

        mregs[sel].ier_elsi = false;

        mregs[sel].ier_edssi = false;

        mregs[sel].iir = 0x01;

        mregs[sel].fcr_fifo_enable = false;

        mregs[sel].fcr_ififo_trigger_level_bytes = 1;

        mregs[sel].lcr_word_length_bits = 5;

        mregs[sel].lcr_stb = false;

        mregs[sel].lcr_pen = false;

        mregs[sel].lcr_eps = false;

        mregs[sel].lcr_stick = false;

        mregs[sel].lcr_break = false;

        mregs[sel].lcr_dlab = false;

        mregs[sel].mcr_dtr = false;

        mregs[sel].mcr_rts = false;

        mregs[sel].mcr_out1 = false;

        mregs[sel].mcr_out2 = false;