From 9562a20a6365aa2e7f99309398aa20116386d7f3 Mon Sep 17 00:00:00 2001 From: TC1995 Date: Wed, 1 Jan 2020 20:20:16 +0100 Subject: [PATCH] Initial commit of MIDI IN. --- src/config.c | 11 + src/device.h | 1 + src/plat_midi.h | 6 + src/sound/midi.c | 173 +++++- src/sound/midi.h | 40 +- src/sound/midi_input.h | 1 + src/sound/midi_system.c | 78 +++ src/sound/snd_audiopci.c | 120 +++- src/sound/snd_mpu401.c | 1173 ++++++++++++++++++++++++++++++-------- src/sound/snd_mpu401.h | 64 ++- src/sound/snd_sb.c | 47 ++ src/sound/snd_sb_dsp.c | 98 +++- src/sound/snd_sb_dsp.h | 18 +- src/sound/sound.c | 2 +- src/win/86Box.rc | 33 +- src/win/resource.h | 15 +- src/win/win_devconf.c | 34 ++ src/win/win_midi.c | 125 +++- src/win/win_settings.c | 72 ++- 19 files changed, 1752 insertions(+), 359 deletions(-) create mode 100644 src/sound/midi_input.h diff --git a/src/config.c b/src/config.c index 583605583..2b9026989 100644 --- a/src/config.c +++ b/src/config.c @@ -649,6 +649,12 @@ load_sound(void) else midi_device_current = 0; + p = config_get_string(cat, "midi_in_device", NULL); + if (p != NULL) + midi_input_device_current = midi_in_device_get_from_internal_name(p); + else + midi_input_device_current = 0; + mpu401_standalone_enable = !!config_get_int(cat, "mpu401_standalone", 0); SSI2001 = !!config_get_int(cat, "ssi2001", 0); @@ -1531,6 +1537,11 @@ save_sound(void) else config_set_string(cat, "midi_device", midi_device_get_internal_name(midi_device_current)); + if (!strcmp(midi_in_device_get_internal_name(midi_input_device_current), "none")) + config_delete_var(cat, "midi_in_device"); + else + config_set_string(cat, "midi_in_device", midi_in_device_get_internal_name(midi_input_device_current)); + if (mpu401_standalone_enable == 0) config_delete_var(cat, "mpu401_standalone"); else diff --git a/src/device.h b/src/device.h index e59952205..dbf9976a2 100644 --- a/src/device.h +++ b/src/device.h @@ -50,6 +50,7 @@ #define CONFIG_HEX16 7 #define CONFIG_HEX20 8 #define CONFIG_MAC 9 +#define CONFIG_MIDI_IN 10 enum { diff --git a/src/plat_midi.h b/src/plat_midi.h index 5070de68a..933e49ee6 100644 --- a/src/plat_midi.h +++ b/src/plat_midi.h @@ -7,3 +7,9 @@ extern int plat_midi_write(uint8_t val); extern int plat_midi_get_num_devs(void); extern void plat_midi_get_dev_name(int num, char *s); + +extern void plat_midi_input_init(void); +extern void plat_midi_input_close(void); + +extern int plat_midi_in_get_num_devs(void); +extern void plat_midi_in_get_dev_name(int num, char *s); diff --git a/src/sound/midi.c b/src/sound/midi.c index 1f5f0ed47..7648c8c92 100644 --- a/src/sound/midi.c +++ b/src/sound/midi.c @@ -8,7 +8,7 @@ * * MIDI device core module. * - * Version: @(#)midi.c 1.0.1 2018/10/10 + * Version: @(#)midi.c 1.0.2 2018/12/31 * * Authors: Sarah Walker, * Miran Grca, @@ -37,28 +37,22 @@ #ifdef USE_MUNT # include "midi_mt32.h" #endif +#include "midi_input.h" -#define SYSEX_SIZE 1024 -#define RAWBUF 1024 - int midi_device_current = 0; static int midi_device_last = 0; +int midi_input_device_current = 0; +static int midi_input_device_last = 0; +midi_t *midi = NULL; -typedef struct -{ - uint8_t midi_rt_buf[1024], midi_cmd_buf[1024], - midi_status, midi_sysex_data[1026]; - int midi_cmd_pos, midi_cmd_len; - unsigned int midi_sysex_start, midi_sysex_delay, - midi_pos; - midi_device_t* m_device; -} midi_t; +void (*input_msg)(uint8_t *msg); +int (*input_sysex)(uint8_t *buffer, uint32_t len, int abort); -static midi_t *midi = NULL; +uint8_t MIDI_InSysexBuf[SYSEX_SIZE]; -static uint8_t MIDI_evt_len[256] = { +uint8_t MIDI_evt_len[256] = { 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, /* 0x00 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, /* 0x10 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, /* 0x20 */ @@ -85,7 +79,7 @@ typedef struct { const char *name, *internal_name; const device_t *device; -} MIDI_DEVICE; +} MIDI_DEVICE, MIDI_IN_DEVICE; static const MIDI_DEVICE devices[] = { @@ -101,6 +95,12 @@ static const MIDI_DEVICE devices[] = {"", "", NULL} }; +static const MIDI_IN_DEVICE midi_in_devices[] = +{ + {"None", "none", NULL}, + {MIDI_INPUT_NAME, MIDI_INPUT_INTERNAL_NAME, &midi_input_device}, + {"", "", NULL} +}; int midi_device_available(int card) @@ -172,16 +172,39 @@ midi_init(midi_device_t* device) midi = (midi_t *) malloc(sizeof(midi_t)); memset(midi, 0, sizeof(midi_t)); - midi->m_device = device; + midi->m_out_device = device; +} + +void +midi_in_init(midi_device_t* device, midi_t **mididev) +{ + *mididev = (midi_t *)malloc(sizeof(midi_t)); + memset(*mididev, 0, sizeof(midi_t)); + + (*mididev)->m_in_device = device; } void midi_close(void) { - if (midi && midi->m_device) { - free(midi->m_device); - midi->m_device = NULL; + if (midi && midi->m_out_device) { + free(midi->m_out_device); + midi->m_out_device = NULL; + } + + if (midi) { + free(midi); + midi = NULL; + } +} + +void +midi_in_close(void) +{ + if (midi && midi->m_in_device) { + free(midi->m_in_device); + midi->m_in_device = NULL; } if (midi) { @@ -194,36 +217,119 @@ midi_close(void) void midi_poll(void) { - if (midi && midi->m_device && midi->m_device->poll) - midi->m_device->poll(); + if (midi && midi->m_out_device && midi->m_out_device->poll) + midi->m_out_device->poll(); } void play_msg(uint8_t *msg) { - if (midi->m_device->play_msg) - midi->m_device->play_msg(msg); + if (midi->m_out_device->play_msg) + midi->m_out_device->play_msg(msg); } void play_sysex(uint8_t *sysex, unsigned int len) { - if (midi->m_device->play_sysex) - midi->m_device->play_sysex(sysex, len); + if (midi->m_out_device->play_sysex) + midi->m_out_device->play_sysex(sysex, len); } +int +midi_in_device_available(int card) +{ + if (midi_in_devices[card].device) + return device_available(midi_in_devices[card].device); + + return 1; +} + +char * +midi_in_device_getname(int card) +{ + return (char *) midi_in_devices[card].name; +} + +const device_t * +midi_in_device_getdevice(int card) +{ + return midi_in_devices[card].device; +} + +int +midi_in_device_has_config(int card) +{ + if (!midi_in_devices[card].device) + return 0; + return midi_in_devices[card].device->config ? 1 : 0; +} + + +char * +midi_in_device_get_internal_name(int card) +{ + return (char *) midi_in_devices[card].internal_name; +} + + +int +midi_in_device_get_from_internal_name(char *s) +{ + int c = 0; + + while (strlen(midi_in_devices[c].internal_name)) { + if (!strcmp(midi_in_devices[c].internal_name, s)) + return c; + c++; + } + + return 0; +} + void -midi_write(uint8_t val) +midi_in_device_init() +{ + if (midi_in_devices[midi_input_device_current].device) + device_add(midi_in_devices[midi_input_device_current].device); + midi_input_device_last = midi_input_device_current; +} + +void +midi_raw_out_rt_byte(uint8_t val) +{ + if (!midi || !midi->m_out_device || !midi->m_in_device) + return; + + if (!midi->midi_realtime) + return; + + if ((!midi->midi_clockout && (val == 0xf8))) + return; + + midi->midi_cmd_r = val << 24; + pclog("Play RT Byte msg\n"); + play_msg((uint8_t *)&midi->midi_cmd_r); +} + +void +midi_raw_out_thru_rt_byte(uint8_t val) +{ + if (midi->thruchan) + midi_raw_out_rt_byte(val); +} + +void +midi_raw_out_byte(uint8_t val) { uint32_t passed_ticks; - if (!midi || !midi->m_device) + if (!midi || !midi->m_out_device) return; - if (midi->m_device->write && midi->m_device->write(val)) + if ((midi->m_out_device->write && midi->m_out_device->write(val))) return; if (midi->midi_sysex_start) { @@ -289,3 +395,12 @@ midi_write(uint8_t val) } } } + +void +midi_clear_buffer(void) +{ + midi->midi_pos = 0; + midi->midi_status = 0x00; + midi->midi_cmd_pos = 0; + midi->midi_cmd_len = 0; +} \ No newline at end of file diff --git a/src/sound/midi.h b/src/sound/midi.h index 6268a0e0c..21441646c 100644 --- a/src/sound/midi.h +++ b/src/sound/midi.h @@ -2,18 +2,34 @@ # define EMU_SOUND_MIDI_H -extern int midi_device_current; +#define SYSEX_SIZE 8192 +extern uint8_t MIDI_InSysexBuf[SYSEX_SIZE]; +extern uint8_t MIDI_evt_len[256]; + +extern int midi_device_current; +extern int midi_input_device_current; + +extern void (*input_msg)(uint8_t *msg); +extern int (*input_sysex)(uint8_t *buffer, uint32_t len, int abort); int midi_device_available(int card); +int midi_in_device_available(int card); char *midi_device_getname(int card); +char *midi_in_device_getname(int card); #ifdef EMU_DEVICE_H const device_t *midi_device_getdevice(int card); +const device_t *midi_in_device_getdevice(int card); #endif int midi_device_has_config(int card); +int midi_in_device_has_config(int card); char *midi_device_get_internal_name(int card); +char *midi_in_device_get_internal_name(int card); int midi_device_get_from_internal_name(char *s); +int midi_in_device_get_from_internal_name(char *s); void midi_device_init(); +void midi_in_device_init(); + typedef struct midi_device_t { @@ -23,9 +39,27 @@ typedef struct midi_device_t int (*write)(uint8_t val); } midi_device_t; +typedef struct midi_t +{ + uint8_t midi_rt_buf[8], midi_cmd_buf[8], + midi_status, midi_sysex_data[SYSEX_SIZE]; + int midi_cmd_pos, midi_cmd_len, midi_cmd_r, + midi_realtime, thruchan, midi_clockout; + unsigned int midi_sysex_start, midi_sysex_delay, + midi_pos; + midi_device_t *m_out_device, *m_in_device; +} midi_t; + +extern midi_t *midi; + void midi_init(midi_device_t* device); +void midi_in_init(midi_device_t* device, midi_t **mididev); void midi_close(); -void midi_write(uint8_t val); +void midi_in_close(void); +void midi_raw_out_rt_byte(uint8_t val); +void midi_raw_out_thru_rt_byte(uint8_t val); +void midi_raw_out_byte(uint8_t val); +void midi_clear_buffer(void); void midi_poll(); #if 0 @@ -41,5 +75,7 @@ void midi_poll(); #define SYSTEM_MIDI_INTERNAL_NAME "system_midi" #endif +#define MIDI_INPUT_NAME "MIDI Input Device" +#define MIDI_INPUT_INTERNAL_NAME "midi_in" #endif /*EMU_SOUND_MIDI_H*/ diff --git a/src/sound/midi_input.h b/src/sound/midi_input.h new file mode 100644 index 000000000..163d6fa91 --- /dev/null +++ b/src/sound/midi_input.h @@ -0,0 +1 @@ +extern const device_t midi_input_device; diff --git a/src/sound/midi_system.c b/src/sound/midi_system.c index d9a15c6a9..f3ace5c69 100644 --- a/src/sound/midi_system.c +++ b/src/sound/midi_system.c @@ -9,6 +9,7 @@ #include "../plat_midi.h" #include "midi.h" #include "midi_system.h" +#include "midi_input.h" void* system_midi_init(const device_t *info) @@ -16,6 +17,8 @@ void* system_midi_init(const device_t *info) midi_device_t* dev = malloc(sizeof(midi_device_t)); memset(dev, 0, sizeof(midi_device_t)); + pclog("MIDI Output\n"); + dev->play_msg = plat_midi_play_msg; dev->play_sysex = plat_midi_play_sysex; dev->write = plat_midi_write; @@ -27,6 +30,24 @@ void* system_midi_init(const device_t *info) return dev; } +void* midi_input_init(const device_t *info) +{ + midi_device_t* dev = malloc(sizeof(midi_device_t)); + memset(dev, 0, sizeof(midi_device_t)); + + pclog("MIDI Input\n"); + + plat_midi_input_init(); + + midi_in_init(dev, &midi); + + midi->midi_realtime = device_get_config_int("realtime"); + midi->thruchan = device_get_config_int("thruchan"); + midi->midi_clockout = device_get_config_int("clockout"); + + return dev; +} + void system_midi_close(void* p) { plat_midi_close(); @@ -34,11 +55,23 @@ void system_midi_close(void* p) midi_close(); } +void midi_input_close(void* p) +{ + plat_midi_input_close(); + + midi_close(); +} + int system_midi_available(void) { return plat_midi_get_num_devs(); } +int midi_input_available(void) +{ + return plat_midi_in_get_num_devs(); +} + static const device_config_t system_midi_config[] = { { @@ -52,6 +85,37 @@ static const device_config_t system_midi_config[] = } }; +static const device_config_t midi_input_config[] = +{ + { + .name = "midi_input", + .description = "MIDI in device", + .type = CONFIG_MIDI_IN, + .default_int = 0 + }, + { + .name = "realtime", + .description = "MIDI Real time", + .type = CONFIG_BINARY, + .default_int = 0 + }, + { + .name = "thruchan", + .description = "MIDI Thru", + .type = CONFIG_BINARY, + .default_int = 1 + }, + { + .name = "clockout", + .description = "MIDI Clockout", + .type = CONFIG_BINARY, + .default_int = 1 + }, + { + .type = -1 + } +}; + const device_t system_midi_device = { SYSTEM_MIDI_NAME, @@ -64,3 +128,17 @@ const device_t system_midi_device = NULL, system_midi_config }; + + +const device_t midi_input_device = +{ + MIDI_INPUT_NAME, + 0, 0, + midi_input_init, + midi_input_close, + NULL, + midi_input_available, + NULL, + NULL, + midi_input_config +}; \ No newline at end of file diff --git a/src/sound/snd_audiopci.c b/src/sound/snd_audiopci.c index c6bbefc6b..f24a383d3 100644 --- a/src/sound/snd_audiopci.c +++ b/src/sound/snd_audiopci.c @@ -13,6 +13,8 @@ #include "../pci.h" #include "../timer.h" #include "sound.h" +#include "midi.h" +#include "snd_mpu401.h" #include "snd_audiopci.h" @@ -23,6 +25,8 @@ static float low_fir_es1371_coef[ES1371_NCoef]; typedef struct { + mpu_t mpu; + uint8_t pci_command, pci_serr; uint32_t base_addr; @@ -116,14 +120,21 @@ typedef struct { #define INT_DAC1_EN (1<<6) #define INT_DAC2_EN (1<<5) +#define INT_UART_EN (1<<3) #define SI_P2_INTR_EN (1<<9) #define SI_P1_INTR_EN (1<<8) #define INT_STATUS_INTR (1<<31) +#define INT_STATUS_UART (1<<3) #define INT_STATUS_DAC1 (1<<2) #define INT_STATUS_DAC2 (1<<1) +#define UART_CTRL_TXINTEN (1<<5) + +#define UART_STATUS_TXINT (1<<2) +#define UART_STATUS_TXRDY (1<<1) + #define FORMAT_MONO_8 0 #define FORMAT_STEREO_8 1 #define FORMAT_MONO_16 2 @@ -164,8 +175,13 @@ static void es1371_update_irqs(es1371_t *es1371) if ((es1371->int_status & INT_STATUS_DAC1) && (es1371->si_cr & SI_P1_INTR_EN)) irq = 1; - if ((es1371->int_status & INT_STATUS_DAC2) && (es1371->si_cr & SI_P2_INTR_EN)) + if ((es1371->int_status & INT_STATUS_DAC2) && (es1371->si_cr & SI_P2_INTR_EN)) { irq = 1; + } + /*MIDI input is unsupported for now*/ + if ((es1371->int_status & INT_STATUS_UART) && (es1371->uart_status & UART_STATUS_TXINT)) { + irq = 1; + } if (irq) es1371->int_status |= INT_STATUS_INTR; @@ -219,10 +235,10 @@ static uint8_t es1371_inb(uint16_t port, void *p) case 0x07: ret = (es1371->int_status >> 24) & 0xff; break; - - + case 0x09: - ret = es1371->uart_status; + ret = es1371->uart_status & 0xc7; + audiopci_log("ES1371 UART Status = %02x\n", es1371->uart_status); break; case 0x0c: @@ -253,7 +269,7 @@ static uint8_t es1371_inb(uint16_t port, void *p) audiopci_log("Bad es1371_inb: port=%04x\n", port); } -// audiopci_log("es1371_inb: port=%04x ret=%02x\n", port, ret); + audiopci_log("es1371_inb: port=%04x ret=%02x\n", port, ret); // output = 3; return ret; } @@ -340,31 +356,51 @@ static uint32_t es1371_inl(uint16_t port, void *p) ret |= CODEC_READY; break; - case 0x34: - switch (es1371->mem_page) - { + case 0x30: + switch (es1371->mem_page) { + case 0xe: case 0xf: + audiopci_log("ES1371 0x30 read UART FIFO: val = %02x\n", ret & 0xff); + break; + } + break; + case 0x34: + switch (es1371->mem_page) { case 0xc: ret = es1371->dac[0].size | (es1371->dac[0].count << 16); break; case 0xd: - ret = es1371->adc.size | (es1371->adc.count << 16); break; + case 0xe: case 0xf: + audiopci_log("ES1371 0x34 read UART FIFO: val = %02x\n", ret & 0xff); + break; + default: audiopci_log("Bad es1371_inl: mem_page=%x port=%04x\n", es1371->mem_page, port); } break; + case 0x38: + switch (es1371->mem_page) { + case 0xe: case 0xf: + audiopci_log("ES1371 0x38 read UART FIFO: val = %02x\n", ret & 0xff); + break; + } + break; + case 0x3c: - switch (es1371->mem_page) - { + switch (es1371->mem_page) { case 0xc: ret = es1371->dac[1].size | (es1371->dac[1].count << 16); break; - + + case 0xe: case 0xf: + audiopci_log("ES1371 0x3c read UART FIFO: val = %02x\n", ret & 0xff); + break; + default: audiopci_log("Bad es1371_inl: mem_page=%x port=%04x\n", es1371->mem_page, port); } @@ -374,7 +410,7 @@ static uint32_t es1371_inl(uint16_t port, void *p) audiopci_log("Bad es1371_inl: port=%04x\n", port); } -// audiopci_log("es1371_inl: port=%04x ret=%08x %08x\n", port, ret, cpu_state.pc); + audiopci_log("es1371_inl: port=%04x ret=%08x\n", port, ret); return ret; } @@ -382,7 +418,7 @@ static void es1371_outb(uint16_t port, uint8_t val, void *p) { es1371_t *es1371 = (es1371_t *)p; -// audiopci_log("es1371_outb: port=%04x val=%02x %04x:%08x\n", port, val, cs, cpu_state.pc); + audiopci_log("es1371_outb: port=%04x val=%02x\n", port, val); switch (port & 0x3f) { case 0x00: @@ -412,8 +448,13 @@ static void es1371_outb(uint16_t port, uint8_t val, void *p) es1371->int_ctrl = (es1371->int_ctrl & 0x00ffffff) | (val << 24); break; + case 0x08: + midi_raw_out_byte(val); + break; + case 0x09: - es1371->uart_ctrl = val; + es1371->uart_ctrl = val & 0xe3; + audiopci_log("ES1371 UART Cntrl = %02x\n", es1371->uart_ctrl); break; case 0x0c: @@ -481,7 +522,7 @@ static void es1371_outl(uint16_t port, uint32_t val, void *p) { es1371_t *es1371 = (es1371_t *)p; -// audiopci_log("es1371_outl: port=%04x val=%08x %04x:%08x\n", port, val, CS, cpu_state.pc); + audiopci_log("es1371_outl: port=%04x val=%08x\n", port, val); switch (port & 0x3f) { case 0x04: @@ -593,6 +634,10 @@ static void es1371_outl(uint16_t port, uint32_t val, void *p) // audiopci_log("DAC1 addr %08x\n", val); break; + case 0xe: case 0xf: + audiopci_log("ES1371 0x30 write UART FIFO: val = %02x\n", val & 0xff); + break; + default: audiopci_log("Bad es1371_outl: mem_page=%x port=%04x val=%08x\n", es1371->mem_page, port, val); } @@ -615,6 +660,10 @@ static void es1371_outl(uint16_t port, uint32_t val, void *p) es1371->adc.count = val >> 16; break; + case 0xe: case 0xf: + audiopci_log("ES1371 0x34 write UART FIFO: val = %02x\n", val & 0xff); + break; + default: audiopci_log("Bad es1371_outl: mem_page=%x port=%04x val=%08x\n", es1371->mem_page, port, val); } @@ -633,6 +682,10 @@ static void es1371_outl(uint16_t port, uint32_t val, void *p) case 0xd: break; + + case 0xe: case 0xf: + audiopci_log("ES1371 0x38 write UART FIFO: val = %02x\n", val & 0xff); + break; default: audiopci_log("Bad es1371_outl: mem_page=%x port=%04x val=%08x\n", es1371->mem_page, port, val); @@ -649,6 +702,10 @@ static void es1371_outl(uint16_t port, uint32_t val, void *p) case 0xc: es1371->dac[1].size = val & 0xffff; es1371->dac[1].count = val >> 16; + break; + + case 0xe: case 0xf: + audiopci_log("ES1371 0x3c write UART FIFO: val = %02x\n", val & 0xff); break; default: @@ -1107,10 +1164,33 @@ static void es1371_poll(void *p) timer_advance_u64(&es1371->dac[1].timer, es1371->dac[1].latch); - es1371_update(es1371); - - if (es1371->int_ctrl & INT_DAC1_EN) - { + es1371_update(es1371); + + if (es1371->int_ctrl & INT_UART_EN) { + audiopci_log("UART INT Enabled\n"); + if (es1371->uart_ctrl & 0x80) { /*We currently don't implement MIDI Input.*/ + /*But if anything sets MIDI Input and Output together we'd have to take account + of the MIDI Output case, and disable IRQ's and RX bits when MIDI Input is enabled as well but not in the MIDI Output portion*/ + if (es1371->uart_ctrl & UART_CTRL_TXINTEN) + es1371->int_status |= INT_STATUS_UART; + else + es1371->int_status &= ~INT_STATUS_UART; + } else if (!(es1371->uart_ctrl & 0x80) && ((es1371->uart_ctrl & UART_CTRL_TXINTEN))) { /*Or enable the UART IRQ and the respective TX bits only when the MIDI Output is enabled*/ + es1371->int_status |= INT_STATUS_UART; + } + + if (es1371->uart_ctrl & 0x80) { + if (es1371->uart_ctrl & UART_CTRL_TXINTEN) + es1371->uart_status |= (UART_STATUS_TXINT | UART_STATUS_TXRDY); + else + es1371->uart_status &= ~(UART_STATUS_TXINT | UART_STATUS_TXRDY); + } else + es1371->uart_status |= (UART_STATUS_TXINT | UART_STATUS_TXRDY); + + es1371_update_irqs(es1371); + } + + if (es1371->int_ctrl & INT_DAC1_EN) { int frac = es1371->dac[0].ac & 0x7fff; int idx = es1371->dac[0].ac >> 15; int samp1_l = es1371->dac[0].filtered_l[idx]; diff --git a/src/sound/snd_mpu401.c b/src/sound/snd_mpu401.c index 15105268f..f30517a2c 100644 --- a/src/sound/snd_mpu401.c +++ b/src/sound/snd_mpu401.c @@ -29,6 +29,7 @@ #define HAVE_STDARG_H #include "../86box.h" #include "../device.h" +#include "../plat.h" #include "../io.h" #include "../machine/machine.h" #include "../mca.h" @@ -38,6 +39,8 @@ #include "snd_mpu401.h" #include "midi.h" +static uint32_t MPUClockBase[8] = {48,72,96,120,144,168,192}; +static uint8_t cth_data[16] = {0,0,0,0,1,0,0,0,1,0,1,0,1,1,1,0}; enum { STATUS_OUTPUT_NOT_READY = 0x40, @@ -48,8 +51,13 @@ enum { int mpu401_standalone_enable = 0; static void MPU401_WriteCommand(mpu_t *mpu, uint8_t val); +static void MPU401_IntelligentOut(mpu_t *mpu, uint8_t track); +static void MPU401_EOIHandler(void *priv); static void MPU401_EOIHandlerDispatch(void *p); +static void MPU401_NotesOff(mpu_t *mpu, int i); +static mpu_t *mpuin; +static mutex_t *mpu_lock; #ifdef ENABLE_MPU401_LOG int mpu401_do_log = ENABLE_MPU401_LOG; @@ -71,8 +79,69 @@ mpu401_log(const char *fmt, ...) #endif +void +mpu401_set_midi_in(mpu_t *src_mpu_in) +{ + mpuin = src_mpu_in; +} + static void -QueueByte(mpu_t *mpu, uint8_t data) +MPU401_ReCalcClock(mpu_t *mpu) +{ + int32_t maxtempo = 240, mintempo = 16; + + if (mpu->clock.timebase >= 168) + maxtempo = 179; + if (mpu->clock.timebase == 144) + maxtempo = 208; + if (mpu->clock.timebase >= 120) + maxtempo = 8; + + mpu->clock.freq = ((uint32_t)(mpu->clock.tempo * 2 * mpu->clock.tempo_rel)) >> 6; + mpu->clock.freq = mpu->clock.timebase * (mpu->clock.freq < (mintempo * 2) ? mintempo : + ((mpu->clock.freq / 2) < maxtempo ? (mpu->clock.freq / 2) : maxtempo)); + + if (mpu->state.sync_in) { + int32_t freq = (int32_t)((float)(mpu->clock.freq) * mpu->clock.freq_mod); + if ((freq > (mpu->clock.timebase * mintempo)) && (freq < (mpu->clock.timebase * maxtempo))) + mpu->clock.freq = freq; + } +} + +static void +MPU401_StartClock(mpu_t *mpu) +{ + if (mpu->clock.active) + return; + if (!(mpu->state.clock_to_host || mpu->state.playing || (mpu->state.rec == M_RECON))) + return; + + mpu->clock.active = 1; + timer_set_delay_u64(&mpu->mpu401_event_callback, (MPU401_TIMECONSTANT / mpu->clock.freq) * 1000 * TIMER_USEC); +} + +static void +MPU401_StopClock(mpu_t *mpu) +{ + if (mpu->state.clock_to_host || mpu->state.playing || (mpu->state.rec == M_RECON)) + return; + mpu->clock.active = 0; + timer_disable(&mpu->mpu401_event_callback); +} + +static void +MPU401_RunClock(mpu_t *mpu) +{ + if (!mpu->clock.active) { + timer_disable(&mpu->mpu401_event_callback); + return; + } + timer_set_delay_u64(&mpu->mpu401_event_callback, (MPU401_TIMECONSTANT / mpu->clock.freq) * 1000 * TIMER_USEC); + mpu401_log("Next event after %i us (time constant: %i)\n", (uint64_t) ((MPU401_TIMECONSTANT/mpu->clock.freq) * 1000 * TIMER_USEC), (int) MPU401_TIMECONSTANT); +} + +static void +MPU401_QueueByte(mpu_t *mpu, uint8_t data) { if (mpu->state.block_ack) { mpu->state.block_ack = 0; @@ -88,22 +157,73 @@ QueueByte(mpu_t *mpu, uint8_t data) if (mpu->queue_pos >= MPU401_QUEUE) mpu->queue_pos -= MPU401_QUEUE; - if (pos>=MPU401_QUEUE) pos-=MPU401_QUEUE; mpu->queue_used++; mpu->queue[pos] = data; - } else - mpu401_log("MPU401:Data queue full\n"); + } } +static void +MPU401_RecQueueBuffer(mpu_t *mpu, uint8_t *buf, uint32_t len, int block) +{ + uint32_t cnt; + + if (block) { + if (mpu_lock) + thread_wait_mutex(mpu_lock); + else + return; + } + + cnt = 0; + while (cnt < len) { + if (mpu->rec_queue_used < MPU401_INPUT_QUEUE) { + int pos = mpu->rec_queue_used + mpu->rec_queue_pos; + if (pos >= MPU401_INPUT_QUEUE) + pos -= MPU401_INPUT_QUEUE; + mpu->rec_queue[pos] = buf[cnt]; + mpu->rec_queue_used++; + if ((!mpu->state.sysex_in_finished) && (buf[cnt] == MSG_EOX)) { /*finish sysex*/ + mpu->state.sysex_in_finished = 1; + break; + } + cnt++; + } + } + + if (mpu->queue_used == 0) { + if (mpu->state.rec_copy || mpu->state.irq_pending) { + if (block && mpu_lock) + thread_release_mutex(mpu_lock); + if (mpu->state.irq_pending) { + picintc(1 << mpu->irq); + mpu->state.irq_pending = 0; + } + return; + } + mpu->state.rec_copy = 1; + if (mpu->rec_queue_pos >= MPU401_INPUT_QUEUE) + mpu->rec_queue_pos -= MPU401_INPUT_QUEUE; + MPU401_QueueByte(mpu, mpu->rec_queue[mpu->rec_queue_pos]); + mpu->rec_queue_used--; + mpu->rec_queue_pos++; + } + + if (block && mpu_lock) + thread_release_mutex(mpu_lock); +} static void -ClrQueue(mpu_t *mpu) +MPU401_ClrQueue(mpu_t *mpu) { - mpu->queue_used=0; - mpu->queue_pos=0; + mpu->queue_used = 0; + mpu->queue_pos = 0; + mpu->rec_queue_used = 0; + mpu->rec_queue_pos = 0; + mpu->state.sysex_in_finished = 1; + mpu->state.irq_pending = 0; } @@ -116,8 +236,10 @@ MPU401_Reset(mpu_t *mpu) picintc(1 << mpu->irq); mpu->state.irq_pending = 0; } - + mpu->mode = M_INTELLIGENT; + mpu->midi_thru = 0; + mpu->state.rec = M_RECOFF; mpu->state.eoi_scheduled = 0; mpu->state.wsd = 0; mpu->state.wsm = 0; @@ -129,27 +251,64 @@ MPU401_Reset(mpu_t *mpu) mpu->state.cmask = 0xff; mpu->state.amask = mpu->state.tmask = 0; mpu->state.midi_mask = 0xffff; - mpu->state.data_onoff = 0; mpu->state.command_byte = 0; mpu->state.block_ack = 0; mpu->clock.tempo = mpu->clock.old_tempo = 100; mpu->clock.timebase = mpu->clock.old_timebase = 120; - mpu->clock.tempo_rel = mpu->clock.old_tempo_rel = 40; + mpu->clock.tempo_rel = mpu->clock.old_tempo_rel = 0x40; + mpu->clock.freq_mod = 1.0; mpu->clock.tempo_grad = 0; - mpu->clock.clock_to_host = 0; - mpu->clock.cth_rate = 60; + MPU401_StopClock(mpu); + MPU401_ReCalcClock(mpu); + + for (i = 0; i < 4; i++) + mpu->clock.cth_rate[i] = 60; + mpu->clock.cth_counter = 0; + mpu->clock.midimetro = 12; + mpu->clock.metromeas = 8; + mpu->filter.rec_measure_end = 1; + mpu->filter.rt_out = 1; + mpu->filter.rt_affection = 1; + mpu->filter.allnotesoff_out = 1; + mpu->filter.all_thru = 1; + mpu->filter.midi_thru = 1; + mpu->filter.commonmsgs_thru = 1; - ClrQueue(mpu); + /*reset channel reference and input tables*/ + for (i = 0; i < 4; i++) { + mpu->chanref[i].on = 1; + mpu->chanref[i].chan = i; + mpu->ch_toref[i] = i; + } + + for (i = 0; i < 16; i++) { + mpu->inputref[i].on = 1; + mpu->inputref[i].chan = i; + if (i > 3) + mpu->ch_toref[i] = 4;/*dummy reftable*/ + } + + MPU401_ClrQueue(mpu); + mpu->state.data_onoff = -1; mpu->state.req_mask = 0; - mpu->condbuf.counter = 0; + mpu->condbuf.counter = 0; mpu->condbuf.type = T_OVERFLOW; for (i=0;i<8;i++) { mpu->playbuf[i].type = T_OVERFLOW; mpu->playbuf[i].counter = 0; } + + /*clear MIDI buffers, terminate notes*/ + midi_clear_buffer(); + + for (i = 0xb0; i <= 0xbf; i++) { + midi_raw_out_byte(i); + midi_raw_out_byte(0x7b); + midi_raw_out_byte(0); + } } @@ -163,6 +322,7 @@ MPU401_ResetDone(void *priv) timer_disable(&mpu->mpu401_reset_callback); mpu->state.reset = 0; + if (mpu->state.cmd_pending) { MPU401_WriteCommand(mpu, mpu->state.cmd_pending - 1); mpu->state.cmd_pending = 0; @@ -173,160 +333,281 @@ MPU401_ResetDone(void *priv) static void MPU401_WriteCommand(mpu_t *mpu, uint8_t val) { - uint8_t i, was_uart; + uint8_t i, j, was_uart; if (mpu->state.reset) mpu->state.cmd_pending = val + 1; if ((val != 0x3f) && (val != 0xff) && !mpu->intelligent) - return; + return; - if (val <= 0x2f) { - switch (val&3) { /* MIDI stop, start, continue */ - case 1: - midi_write(0xfc); - break; + thread_wait_mutex(mpu_lock); - case 2: - midi_write(0xfa); - break; + /*hack:enable midi through after the first mpu401 command is written*/ + mpu->midi_thru = 1; - case 3: - midi_write(0xfb); - break; + if (val <= 0x2f) { /* Sequencer state */ + int send_prchg = 0; + if ((val & 0xf) < 0xc) { + switch (val & 3) { /* MIDI realtime messages */ + case 1: + mpu->state.last_rtcmd = 0xfc; + if (mpu->filter.rt_out) + midi_raw_out_rt_byte(0xfc); + mpu->clock.meas_old = mpu->clock.measure_counter; + mpu->clock.cth_old = mpu->clock.cth_counter; + break; + case 2: + mpu->state.last_rtcmd = 0xfa; + if (mpu->filter.rt_out) + midi_raw_out_rt_byte(0xfb); + mpu->clock.measure_counter = mpu->clock.meas_old = 0; + mpu->clock.cth_counter = mpu->clock.cth_old = 0; + break; + case 3: + mpu->state.last_rtcmd = 0xfc; + if (mpu->filter.rt_out) + midi_raw_out_rt_byte(0xfa); + mpu->clock.measure_counter = mpu->clock.meas_old; + mpu->clock.cth_counter = mpu->clock.cth_old; + break; + } + switch (val & 0xc) { /* Playing */ + case 0x4: /* Stop */ + mpu->state.playing = 0; + MPU401_StopClock(mpu); + for (i = 0; i < 16; i++) + MPU401_NotesOff(mpu, i); + mpu->filter.prchg_mask = 0; + break; + case 0x8: /* Start */ + mpu->state.playing = 1; + MPU401_StartClock(mpu); + break; + } + switch (val & 0x30) { /* Recording */ + case 0: /* check if it waited for MIDI RT command */ + if (((val & 3) < 2) || !mpu->filter.rt_affection || (mpu->state.rec != M_RECSTB)) + break; + mpu->state.rec = M_RECON; + MPU401_StartClock(mpu); + if (mpu->filter.prchg_mask) + send_prchg = 1; + break; + case 0x10: /* Stop */ + mpu->state.rec = M_RECOFF; + MPU401_StopClock(mpu); + MPU401_QueueByte(mpu, MSG_MPU_ACK); + MPU401_QueueByte(mpu, mpu->clock.rec_counter); + MPU401_QueueByte(mpu, MSG_MPU_END); + mpu->filter.prchg_mask = 0; + mpu->clock.rec_counter = 0; + thread_release_mutex(mpu_lock); + return; + case 0x20: /* Start */ + if (!(mpu->state.rec == M_RECON)) { + mpu->clock.rec_counter = 0; + mpu->state.rec = M_RECSTB; + } + if ((mpu->state.last_rtcmd == 0xfa) || (mpu->state.last_rtcmd == 0xfb)) { + mpu->clock.rec_counter = 0; + mpu->state.rec = M_RECON; + if (mpu->filter.prchg_mask) + send_prchg = 1; + MPU401_StartClock(mpu); + } + } } - - switch (val & 0xc) { - case 0x4: /* Stop */ - mpu->state.playing = 0; - timer_disable(&mpu->mpu401_event_callback); - - for (i = 0xb0; i < 0xbf; i++) { - /* All notes off */ - midi_write(i); - midi_write(0x7b); - midi_write(0); - } - break; - - case 0x8: /* Play */ - mpu->state.playing = 1; - timer_set_delay_u64(&mpu->mpu401_event_callback, (MPU401_TIMECONSTANT / (mpu->clock.tempo*mpu->clock.timebase)) * 1000 * TIMER_USEC); - ClrQueue(mpu); - break; + MPU401_QueueByte(mpu, MSG_MPU_ACK); + /* record counter hack: needed by Prism, but sent only on cmd 0x20/0x26 (or breaks Ballade) */ + uint8_t rec_cnt = mpu->clock.rec_counter; + if (((val == 0x20) || (val == 0x26)) && (mpu->state.rec == M_RECON)) + MPU401_RecQueueBuffer(mpu, &rec_cnt, 1, 0); + + if (send_prchg) for (i = 0; i < 16; i++) + if (mpu->filter.prchg_mask & (1 << i)) { + uint8_t recmsg[3] = {mpu->clock.rec_counter, 0xc0 | i, mpu->filter.prchg_buf[i]}; + MPU401_RecQueueBuffer(mpu, recmsg, 3, 0); + mpu->filter.prchg_mask &= ~(1 << i); } + thread_release_mutex(mpu_lock); } else if ((val >= 0xa0) && (val <= 0xa7)) { /* Request play counter */ - if (mpu->state.cmask & (1 << (val&7))) - QueueByte(mpu, mpu->playbuf[val&7].counter); + MPU401_QueueByte(mpu, mpu->playbuf[val & 7].counter); } else if ((val >= 0xd0) && (val <= 0xd7)) { /* Send data */ - mpu->state.old_chan = mpu->state.channel; - mpu->state.channel= val & 7; + mpu->state.old_track = mpu->state.track; + mpu->state.track= val & 7; mpu->state.wsd = 1; mpu->state.wsm = 0; mpu->state.wsd_start = 1; + } else if ((val < 0x80) && (val >= 0x40)) { /* Set reference table channel */ + mpu->chanref[(val >> 4) - 4].on = 1; + mpu->chanref[(val >> 4) - 4].chan = val & 0x0f; + mpu->chanref[(val >> 4) - 4].trmask = 0; + for (i = 0; i < 4; i++) + mpu->chanref[(val >> 4) - 4].key[i] = 0; + for (i = 0; i < 16; i++) { + if (mpu->ch_toref[i] == ((val >> 4) - 4)) + mpu->ch_toref[i] = 4; + } + mpu->ch_toref[val & 0x0f] = (val >> 4) - 4; } else switch (val) { - case 0xdf: /* Send system message */ - mpu->state.wsd = 0; - mpu->state.wsm = 1; - mpu->state.wsd_start = 1; + case 0x30: /* Configuration 0x30 - 0x39 */ + mpu->filter.allnotesoff_out = 0; break; - - case 0x8e: /* Conductor */ - mpu->state.cond_set = 0; + case 0x32: + mpu->filter.rt_out = 0; break; - - case 0x8f: - mpu->state.cond_set = 1; + case 0x33: + mpu->filter.all_thru = 0; + mpu->filter.commonmsgs_thru = 0; + mpu->filter.midi_thru = 0; + for (i = 0; i < 16; i++) { + mpu->inputref[i].on = 0; + for (j = 0; i < 4; j++) + mpu->inputref[i].key[j] = 0; + } + break; + case 0x34: + mpu->filter.timing_in_stop = 1; + break; + case 0x35: + mpu->filter.modemsgs_in = 1; + break; + case 0x37: + mpu->filter.sysex_thru = 1; + break; + case 0x38: + mpu->filter.commonmsgs_in = 1; + break; + case 0x39: + mpu->filter.rt_in = 1; + break; + case 0x3f: /* UART mode */ + mpu401_log("MPU-401:Set UART mode %X\n",val); + MPU401_QueueByte(mpu, MSG_MPU_ACK); + mpu->mode = M_UART; + return; + case 0x80: /* Internal clock */ + if (mpu->clock.active && mpu->state.sync_in) { + timer_set_delay_u64(&mpu->mpu401_event_callback, (MPU401_TIMECONSTANT / mpu->clock.freq) * 1000 * TIMER_USEC); + mpu->clock.freq_mod = 1.0; + } + mpu->state.sync_in = 0; + break; + case 0x81: /* Sync to tape signal */ + case 0x82: /* Sync to MIDI */ + mpu->clock.ticks_in = 0; + mpu->state.sync_in = 1; + break; + case 0x86: case 0x87: /* Bender */ + mpu->filter.bender_in = !!(val & 1); + break; + case 0x88: case 0x89: /* MIDI through */ + mpu->filter.midi_thru = !!(val & 1); + for (i = 0; i < 16; i++) { + mpu->inputref[i].on = mpu->filter.midi_thru; + if (!(val & 1)) { + for (j = 0; j < 4; j++) + mpu->inputref[i].key[j] = 0; + } + } + break; + case 0x8a: case 0x8b: /* Data in stop */ + mpu->filter.data_in_stop = !!(val & 1); + break; + case 0x8c: case 0x8d: /* Send measure end */ + mpu->filter.rec_measure_end = !!(val & 1); + break; + case 0x8e: case 0x8f: /* Conductor */ + mpu->state.cond_set = !!(val & 1); + break; + case 0x90: case 0x91: /* Realtime affection */ + mpu->filter.rt_affection = !!(val & 1); break; - case 0x94: /* Clock to host */ - mpu->clock.clock_to_host = 0; + mpu->state.clock_to_host = 0; + MPU401_StopClock(mpu); break; - case 0x95: - mpu->clock.clock_to_host = 1; + mpu->state.clock_to_host = 1; + MPU401_StartClock(mpu); break; - - case 0xc2: /* Internal timebase */ - mpu->clock.timebase = 48; + case 0x96: case 0x97: /* Sysex input allow */ + mpu->filter.sysex_in = !!(val & 1); + if (val & 1) + mpu->filter.sysex_thru = 0; break; - - case 0xc3: - mpu->clock.timebase = 72; + case 0x98: case 0x99: case 0x9a: case 0x9b: /* Reference tables on/off */ + case 0x9c: case 0x9d: case 0x9e: case 0x9f: + mpu->chanref[(val - 0x98) / 2].on = !!(val & 1); break; - - case 0xc4: - mpu->clock.timebase = 96; - break; - - case 0xc5: - mpu->clock.timebase = 120; - break; - - case 0xc6: - mpu->clock.timebase = 144; - break; - - case 0xc7: - mpu->clock.timebase = 168; - break; - case 0xc8: - mpu->clock.timebase = 192; - break; - - /* Commands with data byte */ - case 0xe0: case 0xe1: case 0xe2: case 0xe4: case 0xe6: - case 0xe7: case 0xec: case 0xed: case 0xee: case 0xef: - mpu->state.command_byte = val; - break; - /* Commands 0xa# returning data */ case 0xab: /* Request and clear recording counter */ - QueueByte(mpu, MSG_MPU_ACK); - QueueByte(mpu, 0); + MPU401_QueueByte(mpu, MSG_MPU_ACK); + MPU401_QueueByte(mpu, 0); + thread_release_mutex(mpu_lock); return; - case 0xac: /* Request version */ - QueueByte(mpu, MSG_MPU_ACK); - QueueByte(mpu, MPU401_VERSION); + MPU401_QueueByte(mpu, MSG_MPU_ACK); + MPU401_QueueByte(mpu, MPU401_VERSION); + thread_release_mutex(mpu_lock); return; - case 0xad: /* Request revision */ - QueueByte(mpu, MSG_MPU_ACK); - QueueByte(mpu, MPU401_REVISION); + MPU401_QueueByte(mpu, MSG_MPU_ACK); + MPU401_QueueByte(mpu, MPU401_REVISION); + thread_release_mutex(mpu_lock); return; - case 0xaf: /* Request tempo */ - QueueByte(mpu, MSG_MPU_ACK); - QueueByte(mpu, mpu->clock.tempo); + MPU401_QueueByte(mpu, MSG_MPU_ACK); + MPU401_QueueByte(mpu, mpu->clock.tempo); + thread_release_mutex(mpu_lock); return; - case 0xb1: /* Reset relative tempo */ mpu->clock.old_tempo_rel = mpu->clock.tempo_rel; - mpu->clock.tempo_rel = 40; + mpu->clock.tempo_rel = 0x40; break; - - case 0xb9: /* Clear play map */ case 0xb8: /* Clear play counters */ - for (i = 0xb0; i < 0xbf; i++) { - /* All notes off */ - midi_write(i); - midi_write(0x7b); - midi_write(0); - } + mpu->state.last_rtcmd = 0; for (i = 0; i < 8; i++) { mpu->playbuf[i].counter = 0; mpu->playbuf[i].type = T_OVERFLOW; } mpu->condbuf.counter = 0; mpu->condbuf.type = T_OVERFLOW; - if (!(mpu->state.conductor=mpu->state.cond_set)) - mpu->state.cond_req = 0; mpu->state.amask = mpu->state.tmask; - mpu->state.req_mask = 0; - mpu->state.irq_pending = 1; + mpu->state.conductor = mpu->state.cond_set; + mpu->clock.cth_counter = mpu->clock.cth_old = 0; + mpu->clock.measure_counter = mpu->clock.meas_old = 0; + break; + case 0xb9: /* Clear play map */ + for (i = 0; i < 16; i++) + MPU401_NotesOff(mpu, i); + for (i = 0; i < 8; i++) { + mpu->playbuf[i].counter = 0; + mpu->playbuf[i].type = T_OVERFLOW; + } + mpu->state.last_rtcmd = 0; + mpu->clock.cth_counter = mpu->clock.cth_old = 0; + mpu->clock.measure_counter = mpu->clock.meas_old = 0; + break; + case 0xba: /* Clear record counter */ + mpu->clock.rec_counter = 0; + break; + case 0xc2: case 0xc3: case 0xc4: /* Internal timebase */ + case 0xc5: case 0xc6: case 0xc7: case 0xc8: + mpu->clock.timebase = MPUClockBase[val-0xc2]; + MPU401_ReCalcClock(mpu); + break; + case 0xdf: /* Send system message */ + mpu->state.wsd = 0; + mpu->state.wsm = 1; + mpu->state.wsd_start = 1; + break; + /* Commands with data byte */ + case 0xe0: case 0xe1: case 0xe2: case 0xe4: case 0xe6: + case 0xe7: case 0xec: case 0xed: case 0xee: case 0xef: + mpu->state.command_byte = val; break; - case 0xff: /* Reset MPU-401 */ mpu401_log("MPU-401:Reset %X\n",val); timer_set_delay_u64(&mpu->mpu401_reset_callback, MPU401_RESETBUSY * 33LL * TIMER_USEC); @@ -337,27 +618,23 @@ MPU401_WriteCommand(mpu_t *mpu, uint8_t val) return; /* do not send ack in UART mode */ break; - case 0x3f: /* UART mode */ - mpu401_log("MPU-401:Set UART mode %X\n",val); - QueueByte(mpu, MSG_MPU_ACK); - mpu->mode = M_UART; - return; - /* default: mpu401_log("MPU-401:Unhandled command %X",val); */ } - QueueByte(mpu, MSG_MPU_ACK); + MPU401_QueueByte(mpu, MSG_MPU_ACK); + thread_release_mutex(mpu_lock); } static void MPU401_WriteData(mpu_t *mpu, uint8_t val) { - static int length, cnt, posd; + static int length, cnt; + uint8_t i; if (mpu->mode == M_UART) { - midi_write(val); + midi_raw_out_byte(val); return; } @@ -369,39 +646,55 @@ MPU401_WriteData(mpu_t *mpu, uint8_t val) switch (mpu->state.command_byte) { /* 0xe# command data */ case 0x00: break; - case 0xe0: /* Set tempo */ mpu->state.command_byte = 0; - mpu->clock.tempo = val; + if (mpu->clock.tempo < 8) + mpu->clock.tempo = 8; + else if (mpu->clock.tempo > 250) + mpu->clock.tempo = 250; + else + mpu->clock.tempo = val; + MPU401_ReCalcClock(mpu); return; - case 0xe1: /* Set relative tempo */ mpu->state.command_byte = 0; mpu->clock.old_tempo_rel = mpu->clock.tempo_rel; mpu->clock.tempo_rel = val; + MPU401_ReCalcClock(mpu); return; - + case 0xe2: /* Set gradation for relative tempo */ + mpu->clock.tempo_grad = val; + MPU401_ReCalcClock(mpu); + return; + case 0xe4: /* Set MIDI clocks for metronome ticks */ + mpu->state.command_byte = 0; + mpu->clock.midimetro = val; + return; + case 0xe6: /* Set metronome ticks per measure */ + mpu->state.command_byte = 0; + mpu->clock.metromeas = val; + return; case 0xe7: /* Set internal clock to host interval */ mpu->state.command_byte = 0; - mpu->clock.cth_rate = val >> 2; + if (!val) + val = 64; + for (i = 0; i < 4; i++) + mpu->clock.cth_rate[i] = (val >> 2) + cth_data[(val & 3) * 4 + i]; + mpu->clock.cth_mode = 0; return; - case 0xec: /* Set active track mask */ mpu->state.command_byte = 0; mpu->state.tmask = val; return; - case 0xed: /* Set play counter mask */ mpu->state.command_byte = 0; mpu->state.cmask = val; return; - case 0xee: /* Set 1-8 MIDI channel mask */ mpu->state.command_byte = 0; mpu->state.midi_mask &= 0xff00; mpu->state.midi_mask |= val; return; - case 0xef: /* Set 9-16 MIDI channel mask */ mpu->state.command_byte = 0; mpu->state.midi_mask &= 0x00ff; @@ -413,53 +706,49 @@ MPU401_WriteData(mpu_t *mpu, uint8_t val) return; } - if (mpu->state.wsd) { + if (mpu->state.wsd && !mpu->state.track_req && !mpu->state.cond_req) { /* Directly send MIDI message */ if (mpu->state.wsd_start) { mpu->state.wsd_start = 0; cnt = 0; switch (val & 0xf0) { case 0xc0: case 0xd0: - mpu->playbuf[mpu->state.channel].value[0] = val; - length = 2; + length = mpu->playbuf[mpu->state.track].length = 2; + mpu->playbuf[mpu->state.track].type = T_MIDI_NORM; break; - case 0x80: case 0x90: case 0xa0: case 0xb0:case 0xe0: - mpu->playbuf[mpu->state.channel].value[0] = val; - length = 3; + length = mpu->playbuf[mpu->state.track].length = 3; + mpu->playbuf[mpu->state.track].type = T_MIDI_NORM; break; case 0xf0: /* mpu401_log("MPU-401:Illegal WSD byte\n"); */ mpu->state.wsd = 0; - mpu->state.channel = mpu->state.old_chan; + mpu->state.track = mpu->state.old_track; return; default: /* MIDI with running status */ cnt++; - midi_write(mpu->playbuf[mpu->state.channel].value[0]); + length = mpu->playbuf[mpu->state.track].length; + mpu->playbuf[mpu->state.track].type = T_MIDI_NORM; } } if (cnt < length) { - midi_write(val); + mpu->playbuf[mpu->state.track].value[cnt] = val; cnt++; } if (cnt == length) { + MPU401_IntelligentOut(mpu, mpu->state.track); mpu->state.wsd = 0; - mpu->state.channel = mpu->state.old_chan; + mpu->state.track = mpu->state.old_track; } return; } - if (mpu->state.wsm) { /* Directly send system message */ - if (val == MSG_EOX) { - midi_write(MSG_EOX); - mpu->state.wsm = 0; - return; - } + if (mpu->state.wsm && !mpu->state.track_req && !mpu->state.cond_req) { /* Send system message */ if (mpu->state.wsd_start) { mpu->state.wsd_start = 0; cnt = 0; @@ -481,12 +770,17 @@ MPU401_WriteData(mpu_t *mpu, uint8_t val) break; default: - length = 0; + mpu->state.wsm = 0; + return; } + } else if (val & 0x80) { + midi_raw_out_byte(MSG_EOX); + mpu->state.wsm = 0; + return; } if (!length || (cnt < length)) { - midi_write(val); + midi_raw_out_byte(val); cnt++; } @@ -496,130 +790,179 @@ MPU401_WriteData(mpu_t *mpu, uint8_t val) return; } + thread_wait_mutex(mpu_lock); + if (mpu->state.cond_req) { /* Command */ switch (mpu->state.data_onoff) { case -1: + thread_release_mutex(mpu_lock); return; - case 0: /* Timing byte */ - mpu->condbuf.vlength = 0; + mpu->condbuf.length = 0; if (val < 0xf0) mpu->state.data_onoff++; else { + mpu->state.cond_req = 0; mpu->state.data_onoff = -1; MPU401_EOIHandlerDispatch(mpu); - return; + break; } - mpu->state.send_now = !val ? 1 : 0; mpu->condbuf.counter = val; break; - case 1: /* Command byte #1 */ mpu->condbuf.type = T_COMMAND; - if ((val == 0xf8) || (val == 0xf9)) + if ((val == 0xf8) || (val == 0xf9) || (val == 0xfc)) mpu->condbuf.type = T_OVERFLOW; - mpu->condbuf.value[mpu->condbuf.vlength] = val; - mpu->condbuf.vlength++; - if ((val & 0xf0) != 0xe0) - MPU401_EOIHandlerDispatch(mpu); - else + mpu->condbuf.value[mpu->condbuf.length] = val; + mpu->condbuf.length++; + if ((val & 0xf0) != 0xe0) { /*no cmd data byte*/ + MPU401_EOIHandler(mpu); + mpu->state.data_onoff = -1; + mpu->state.cond_req = 0; + } else mpu->state.data_onoff++; break; case 2:/* Command byte #2 */ - mpu->condbuf.value[mpu->condbuf.vlength]=val; - mpu->condbuf.vlength++; - MPU401_EOIHandlerDispatch(mpu); + mpu->condbuf.value[mpu->condbuf.length]=val; + mpu->condbuf.length++; + MPU401_EOIHandler(mpu); + mpu->state.data_onoff = -1; + mpu->state.cond_req = 0; break; } + thread_release_mutex(mpu_lock); return; } switch (mpu->state.data_onoff) { /* Data */ case -1: - return; - + break; case 0: /* Timing byte */ if (val < 0xf0) - mpu->state.data_onoff = 1; + mpu->state.data_onoff++; else { mpu->state.data_onoff = -1; MPU401_EOIHandlerDispatch(mpu); + mpu->state.track_req = 0; + thread_release_mutex(mpu_lock); return; } mpu->state.send_now = !val ? 1 : 0; - mpu->playbuf[mpu->state.channel].counter = val; + mpu->playbuf[mpu->state.track].counter = val; break; - case 1: /* MIDI */ - mpu->playbuf[mpu->state.channel].vlength++; - posd=mpu->playbuf[mpu->state.channel].vlength; - if (posd == 1) switch (val&0xf0) { + cnt = 0; + mpu->state.data_onoff++; + switch (val & 0xf0) { + case 0xc0: case 0xd0: /* MIDI Message */ + length = mpu->playbuf[mpu->state.track].length = 2; + mpu->playbuf[mpu->state.track].type = T_MIDI_NORM; + break; + case 0x80: case 0x90: case 0xa0: case 0xb0: case 0xe0: + length = mpu->playbuf[mpu->state.track].length = 3; + mpu->playbuf[mpu->state.track].type = T_MIDI_NORM; + break; case 0xf0: /* System message or mark */ + mpu->playbuf[mpu->state.track].sys_val = val; if (val > 0xf7) { - mpu->playbuf[mpu->state.channel].type = T_MARK; - mpu->playbuf[mpu->state.channel].sys_val = val; + mpu->playbuf[mpu->state.track].type = T_MARK; + if (val == 0xf9) + mpu->clock.measure_counter = 0; } else { /* mpu401_log("MPU-401:Illegal message"); */ - mpu->playbuf[mpu->state.channel].type = T_MIDI_SYS; - mpu->playbuf[mpu->state.channel].sys_val = val; + mpu->playbuf[mpu->state.track].type = T_OVERFLOW; } - length = 1; - break; - - case 0xc0: case 0xd0: /* MIDI Message */ - mpu->playbuf[mpu->state.channel].type = T_MIDI_NORM; - length = mpu->playbuf[mpu->state.channel].length = 2; - break; - - case 0x80: case 0x90: case 0xa0: case 0xb0: case 0xe0: - mpu->playbuf[mpu->state.channel].type = T_MIDI_NORM; - length = mpu->playbuf[mpu->state.channel].length = 3; - break; - - default: /* MIDI data with running status */ - posd++; - mpu->playbuf[mpu->state.channel].vlength++; - mpu->playbuf[mpu->state.channel].type = T_MIDI_NORM; - length = mpu->playbuf[mpu->state.channel].length; + mpu->state.data_onoff = -1; + MPU401_EOIHandler(mpu); + mpu->state.track_req = 0; + thread_release_mutex(mpu_lock); + return; + default: /* MIDI with running status */ + cnt++; + length = mpu->playbuf[mpu->state.track].length; + mpu->playbuf[mpu->state.track].type = T_MIDI_NORM; break; } - - if (!((posd == 1) && (val >= 0xf0))) - mpu->playbuf[mpu->state.channel].value[posd-1] = val; - if (posd == length) - MPU401_EOIHandlerDispatch(mpu); + break; + case 2: + if (cnt < length) { + mpu->playbuf[mpu->state.track].value[cnt] = val; + cnt++; + } + if (cnt == length) { + mpu->state.data_onoff = -1; + mpu->state.track_req = 0; + MPU401_EOIHandler(mpu); + } + break; } + + thread_release_mutex(mpu_lock); + return; } static void -MPU401_IntelligentOut(mpu_t *mpu, uint8_t chan) +MPU401_IntelligentOut(mpu_t *mpu, uint8_t track) { - uint8_t val; + uint8_t chan, chrefnum, key, msg; + int send, retrigger; uint8_t i; - switch (mpu->playbuf[chan].type) { + switch (mpu->playbuf[track].type) { case T_OVERFLOW: break; case T_MARK: - val=mpu->playbuf[chan].sys_val; - if (val==0xfc) { - midi_write(val); - mpu->state.amask &= ~(1<state.req_mask &= ~(1<playbuf[track].sys_val == 0xfc) { + midi_raw_out_rt_byte(mpu->playbuf[track].sys_val); + mpu->state.amask&=~(1<playbuf[chan].vlength; i++) - midi_write(mpu->playbuf[chan].value[i]); + chan = mpu->playbuf[track].value[0] & 0xf; + key = mpu->playbuf[track].value[1] & 0x7f; + chrefnum = mpu->ch_toref[chan]; + send = 1; + retrigger = 0; + switch (msg = mpu->playbuf[track].value[0] & 0xf0) { + case 0x80: /* note off */ + if (mpu->inputref[chan].on && (mpu->inputref[chan].M_GETKEY)) + send = 0; + if (mpu->chanref[chrefnum].on && (!(mpu->chanref[chrefnum].M_GETKEY))) + send = 0; + mpu->chanref[chrefnum].M_DELKEY; + break; + case 0x90: /* note on */ + if (mpu->inputref[chan].on && (mpu->inputref[chan].M_GETKEY)) + retrigger = 1; + if (mpu->chanref[chrefnum].on && (!(mpu->chanref[chrefnum].M_GETKEY))) + retrigger = 1; + mpu->chanref[chrefnum].M_SETKEY; + break; + case 0xb0: + if (mpu->playbuf[track].value[1] == 123) { /* All notes off */ + MPU401_NotesOff(mpu, mpu->playbuf[track].value[0] & 0xf); + return; + } + break; + } + if (retrigger) { + midi_raw_out_byte(0x80 | chan); + midi_raw_out_byte(key); + midi_raw_out_byte(0); + } + if (send) { + for (i = 0; i < mpu->playbuf[track].length; i++) + midi_raw_out_byte(mpu->playbuf[track].value[i]); + } break; - + default: break; } @@ -627,15 +970,14 @@ MPU401_IntelligentOut(mpu_t *mpu, uint8_t chan) static void -UpdateTrack(mpu_t *mpu, uint8_t chan) +UpdateTrack(mpu_t *mpu, uint8_t track) { - MPU401_IntelligentOut(mpu, chan); + MPU401_IntelligentOut(mpu, track); - if (mpu->state.amask&(1<playbuf[chan].vlength = 0; - mpu->playbuf[chan].type = T_OVERFLOW; - mpu->playbuf[chan].counter = 0xf0; - mpu->state.req_mask |= (1 << chan); + if (mpu->state.amask&(1<playbuf[track].type = T_OVERFLOW; + mpu->playbuf[track].counter = 0xf0; + mpu->state.req_mask |= (1 << track); } else { if ((mpu->state.amask == 0) && !mpu->state.conductor) mpu->state.req_mask |= (1 << 12); @@ -643,6 +985,7 @@ UpdateTrack(mpu_t *mpu, uint8_t chan) } +#if 0 static void UpdateConductor(mpu_t *mpu) { @@ -659,6 +1002,7 @@ UpdateConductor(mpu_t *mpu) mpu->condbuf.counter = 0xf0; mpu->state.req_mask |= (1 << 9); } +#endif /* Updates counters and requests new data on "End of Input" */ @@ -674,19 +1018,24 @@ MPU401_EOIHandler(void *priv) mpu->state.eoi_scheduled = 0; if (mpu->state.send_now) { mpu->state.send_now = 0; - if (mpu->state.cond_req) UpdateConductor(mpu); - else UpdateTrack(mpu, mpu->state.channel); + if (mpu->state.cond_req) { + mpu->condbuf.counter = 0xf0; + mpu->state.req_mask |= (1 << 9); + } else UpdateTrack(mpu, mpu->state.track); } + if (mpu->state.rec_copy || !mpu->state.sysex_in_finished) + return; + mpu->state.irq_pending = 0; - if (!mpu->state.playing || !mpu->state.req_mask) + if (!(mpu->state.req_mask && mpu->clock.active)) return; i = 0; do { if (mpu->state.req_mask & (1 << i)) { - QueueByte(mpu, 0xf0 + i); + MPU401_QueueByte(mpu, 0xf0 + i); mpu->state.req_mask &= ~(1 << i); break; } @@ -702,7 +1051,7 @@ MPU401_EOIHandlerDispatch(void *priv) mpu401_log("EOI handler dispatch\n"); if (mpu->state.send_now) { mpu->state.eoi_scheduled = 1; - timer_advance_u64(&mpu->mpu401_eoi_callback, 60 * TIMER_USEC); /* Possibly a bit longer */ + timer_advance_u64(&mpu->mpu401_eoi_callback, 60LL * TIMER_USEC); /* Possibly a bit longer */ } else if (!mpu->state.eoi_scheduled) MPU401_EOIHandler(mpu); } @@ -721,6 +1070,8 @@ MPU401_ReadData(mpu_t *mpu) uint8_t ret; ret = MSG_MPU_ACK; + thread_wait_mutex(mpu_lock); + if (mpu->queue_used) { if (mpu->queue_pos >= MPU401_QUEUE) mpu->queue_pos -= MPU401_QUEUE; @@ -734,11 +1085,29 @@ MPU401_ReadData(mpu_t *mpu) if (mpu->state.irq_pending) { picintc(1 << mpu->irq); mpu->state.irq_pending = 0; + thread_release_mutex(mpu_lock); } return ret; } + if (mpu->state.rec_copy && !mpu->rec_queue_used) { + mpu->state.rec_copy = 0; + MPU401_EOIHandler(mpu); + thread_release_mutex(mpu_lock); + return ret; + } + + /*copy from recording buffer*/ + if (!mpu->queue_used && mpu->rec_queue_used) { + mpu->state.rec_copy = 1; + if (mpu->rec_queue_pos >= MPU401_INPUT_QUEUE) + mpu->rec_queue_pos -= MPU401_INPUT_QUEUE; + MPU401_QueueByte(mpu, mpu->rec_queue[mpu->rec_queue_pos]); + mpu->rec_queue_pos++; + mpu->rec_queue_used--; + } + if (mpu->queue_used == 0) { picintc(1 << mpu->irq); mpu->state.irq_pending = 0; @@ -746,9 +1115,10 @@ MPU401_ReadData(mpu_t *mpu) if ((ret >= 0xf0) && (ret <= 0xf7)) { /* MIDI data request */ - mpu->state.channel = ret & 7; + mpu->state.track = ret & 7; mpu->state.data_onoff = 0; mpu->state.cond_req = 0; + mpu->state.track_req = 1; } if (ret == MSG_MPU_COMMAND_REQ) { @@ -759,15 +1129,16 @@ MPU401_ReadData(mpu_t *mpu) MPU401_WriteCommand(mpu, mpu->condbuf.value[0]); if (mpu->state.command_byte) MPU401_WriteData(mpu, mpu->condbuf.value[1]); + mpu->condbuf.type = T_OVERFLOW; } - mpu->condbuf.type = T_OVERFLOW; } - if ((ret == MSG_MPU_END) || (ret == MSG_MPU_CLOCK) || (ret == MSG_MPU_ACK)) { - mpu->state.data_onoff = -1; + if ((ret == MSG_MPU_END) || (ret == MSG_MPU_CLOCK) || (ret == MSG_MPU_ACK) || (ret == MSG_MPU_OVERFLOW)) { MPU401_EOIHandlerDispatch(mpu); } + thread_release_mutex(mpu_lock); + return(ret); } @@ -822,7 +1193,6 @@ static void MPU401_Event(void *priv) { mpu_t *mpu = (mpu_t *)priv; - int new_time; uint8_t i; mpu401_log("MPU-401 event callback\n"); @@ -833,7 +1203,8 @@ MPU401_Event(void *priv) } if (mpu->state.irq_pending) goto next_event; - + + if (mpu->state.playing) { for (i = 0; i < 8; i++) { /* Decrease counters */ if (mpu->state.amask & (1 << i)) { mpu->playbuf[i].counter--; @@ -843,29 +1214,326 @@ MPU401_Event(void *priv) if (mpu->state.conductor) { mpu->condbuf.counter--; - if (mpu->condbuf.counter <= 0) UpdateConductor(mpu); + if (mpu->condbuf.counter <= 0) { + mpu->condbuf.counter = 0xf0; + mpu->state.req_mask |= (1 << 9); + } } + } - if (mpu->clock.clock_to_host) { + if (mpu->state.clock_to_host) { mpu->clock.cth_counter++; - if (mpu->clock.cth_counter >= mpu->clock.cth_rate) { + if (mpu->clock.cth_counter >= mpu->clock.cth_rate[mpu->clock.cth_mode]) { mpu->clock.cth_counter = 0; + mpu->clock.cth_mode= (++mpu->clock.cth_mode) % 4; mpu->state.req_mask |= (1 << 13); } } - if (!mpu->state.irq_pending && mpu->state.req_mask) + if (mpu->state.rec==M_RECON) { /* recording */ + mpu->clock.rec_counter++; + if (mpu->clock.rec_counter>=240) { + mpu->clock.rec_counter=0; + mpu->state.req_mask|=(1<<8); + } + } + + if (mpu->state.playing || (mpu->state.rec == M_RECON)) { + int max_meascnt = (mpu->clock.timebase * mpu->clock.midimetro * mpu->clock.metromeas) / 24; + if (max_meascnt != 0) { /* measure end */ + if (++mpu->clock.measure_counter >= max_meascnt) { + if (mpu->filter.rt_out) + midi_raw_out_rt_byte(0xf8); + mpu->clock.measure_counter = 0; + if (mpu->filter.rec_measure_end && (mpu->state.rec == M_RECON)) + mpu->state.req_mask |= (1 << 12); + } + } + } + if (!mpu->state.irq_pending && mpu->state.req_mask) { + thread_wait_mutex(mpu_lock); MPU401_EOIHandler(mpu); + thread_release_mutex(mpu_lock); + } next_event: - new_time = ((mpu->clock.tempo * mpu->clock.timebase * mpu->clock.tempo_rel) / 0x40); - if (new_time == 0) { - timer_disable(&mpu->mpu401_event_callback); - return; - } else { - timer_advance_u64(&mpu->mpu401_event_callback, (MPU401_TIMECONSTANT / new_time) * 1000 * TIMER_USEC); - mpu401_log("Next event after %i us (time constant: %i)\n", (uint64_t) ((MPU401_TIMECONSTANT/new_time) * 1000 * TIMER_USEC), (int) MPU401_TIMECONSTANT); - } + MPU401_RunClock(mpu); + if (mpu->state.sync_in) + mpu->clock.ticks_in++; +} + +static void +MPU401_NotesOff(mpu_t *mpu, int i) +{ + int j; + uint8_t key; + + if (mpu->filter.allnotesoff_out && !(mpu->inputref[i].on && + (mpu->inputref[i].key[0]|mpu->inputref[i].key[1]| + mpu->inputref[i].key[2]|mpu->inputref[i].key[3]))) { + for (j=0;j<4;j++) + mpu->chanref[mpu->ch_toref[i]].key[j]=0; + midi_raw_out_byte(0xb0|i); + midi_raw_out_byte(123); + midi_raw_out_byte(0); + } else if (mpu->chanref[mpu->ch_toref[i]].on) { + for (key=0;key<128;key++) { + if ((mpu->chanref[mpu->ch_toref[i]].M_GETKEY) && + !(mpu->inputref[i].on && (mpu->inputref[i].M_GETKEY))) { + midi_raw_out_byte(0x80|i); + midi_raw_out_byte(key); + midi_raw_out_byte(0); + } + mpu->chanref[mpu->ch_toref[i]].M_DELKEY; + } + } +} + +/*Input handler for SysEx */ +static int +MPU401_InputSysex(uint8_t *buffer, uint32_t len, int abort) +{ + pclog("MPU401 Input Sysex\n"); + + int i; + + if (mpuin->filter.sysex_in) { + if (abort) { + mpuin->state.sysex_in_finished=1; + mpuin->rec_queue_used=0;/*reset also the input queue*/ + return 0; + } + if (mpuin->state.sysex_in_finished) { + if (mpuin->rec_queue_used>=MPU401_INPUT_QUEUE) + return len; + uint8_t val_ff=0xff; + MPU401_RecQueueBuffer(mpuin,&val_ff,1,1); + mpuin->state.sysex_in_finished=0; + mpuin->clock.rec_counter=0; + } + if (mpuin->rec_queue_used>=MPU401_INPUT_QUEUE) + return len; + int available=MPU401_INPUT_QUEUE-mpuin->rec_queue_used; + + if (available>=len) { + MPU401_RecQueueBuffer(mpuin,buffer,len,1); + return 0; + } + else { + MPU401_RecQueueBuffer(mpuin,buffer,available,1); + if (mpuin->state.sysex_in_finished) + return 0; + return (len-available); + } + } + else if (mpuin->filter.sysex_thru && mpuin->midi_thru) { + midi_raw_out_byte(0xf0); + for (i=0;istate.sysex_in_finished) { + pclog("SYSEX in progress\n"); + return; + } + + int i; + static uint8_t old_msg=0; + uint8_t len=msg[3]; + int send=1; + int send_thru=0; + int retrigger_thru=0; + int midistatus=0; + if (mpuin->mode==M_INTELLIGENT) { + if (msg[0]<0x80) { /* Expand running status */ + midistatus=1; + msg[2]=msg[1];msg[1]=msg[0];msg[0]=old_msg; + } + old_msg=msg[0]; + int chan=msg[0]&0xf; + int chrefnum=mpuin->ch_toref[chan]; + uint8_t key=msg[1]&0x7f; + if (msg[0]<0xf0) { //if non-system msg + if (!(mpuin->state.midi_mask&(1<filter.all_thru) + send_thru=1; + else if (mpuin->filter.midi_thru) + send_thru=1; + switch (msg[0]&0xf0) { + case 0x80: /*note off*/ + if (send_thru) { + if (mpuin->chanref[chrefnum].on && (mpuin->chanref[chrefnum].M_GETKEY)) + send_thru=0; + if (!mpuin->filter.midi_thru) + break; + if (!(mpuin->inputref[chan].M_GETKEY)) + send_thru=0; + mpuin->inputref[chan].M_DELKEY; + } + break; + case 0x90: /*note on*/ + if (send_thru) { + if (mpuin->chanref[chrefnum].on && (mpuin->chanref[chrefnum].M_GETKEY)) + retrigger_thru=1; + if (!mpuin->filter.midi_thru) + break; + if (mpuin->inputref[chan].M_GETKEY) + retrigger_thru=1; + mpuin->inputref[chan].M_SETKEY; + } + break; + case 0xb0: + if (msg[1]>=120) { + send_thru=0; + if (msg[1]==123) { /* All notes off */ + for (key=0;key<128;key++) { + if (!(mpuin->chanref[chrefnum].on && (mpuin->chanref[chrefnum].M_GETKEY))) + if (mpuin->inputref[chan].on && mpuin->inputref[chan].M_GETKEY) { + midi_raw_out_byte(0x80|chan); + midi_raw_out_byte(key); + midi_raw_out_byte(0); + } + mpuin->inputref[chan].M_DELKEY; + } + } + } + break; + } + } + if (msg[0]>=0xf0 || (mpuin->state.midi_mask&(1<filter.bender_in) + send=0; + break; + case 0xb0: /*control change*/ + if (!mpuin->filter.bender_in && msg[1]<64) + send=0; + if (msg[1]>=120) { + if (mpuin->filter.modemsgs_in) + send=1; + } + break; + case 0xc0: /*program change*/ + if ((mpuin->state.rec!=M_RECON) && !mpuin->filter.data_in_stop) { + mpuin->filter.prchg_buf[chan]=msg[1]; + mpuin->filter.prchg_mask|=1<filter.bender_in) + send=0; + break; + case 0xf0: //system message + if (msg[0]==0xf8) { + send=0; + if (mpuin->clock.active && mpuin->state.sync_in) { + send = 0;/*don't pass to host in this mode?*/ + int tick=mpuin->clock.timebase/24; + if (mpuin->clock.ticks_in!=tick) { + if (!mpuin->clock.ticks_in || (mpuin->clock.ticks_in>tick*2)) + mpuin->clock.freq_mod*=2.0; + else { + if (ABS(mpuin->clock.ticks_in-tick)==1) + mpuin->clock.freq_mod/=mpuin->clock.ticks_in/(float)(tick*2); + else + mpuin->clock.freq_mod/=mpuin->clock.ticks_in/(float)(tick); + } + MPU401_ReCalcClock(mpuin); + } + mpuin->clock.ticks_in=0; + } + } + else if (msg[0]>0xf8) { /*realtime*/ + if (!(mpuin->filter.rt_in && msg[0]<=0xfc && msg[0]>=0xfa)) { + uint8_t recdata[2]={0xff,msg[0]}; + MPU401_RecQueueBuffer(mpuin,recdata,2,1); + send=0; + } + } + else { /*common or system*/ + send=0; + if (msg[0]==0xf2 || msg[0]==0xf3 || msg[0]==0xf6) { + if (mpuin->filter.commonmsgs_in) + send=1; + if (mpuin->filter.commonmsgs_thru) + for (i=0;ifilter.rt_affection) switch(msg[0]) { + case 0xf2:case 0xf3: + mpuin->state.block_ack=1; + MPU401_WriteCommand(mpuin,0xb8);/*clear play counters*/ + break; + case 0xfa: + mpuin->state.block_ack=1; + MPU401_WriteCommand(mpuin,0xa);/*start,play*/ + if (mpuin->filter.rt_out) + midi_raw_out_rt_byte(msg[0]); + break; + case 0xfb: + mpuin->state.block_ack=1; + MPU401_WriteCommand(mpuin,0xb);/*continue,play*/ + if (mpuin->filter.rt_out) + midi_raw_out_rt_byte(msg[0]); + break; + case 0xfc: + mpuin->state.block_ack=1; + MPU401_WriteCommand(mpuin,0xd);/*stop: play,rec,midi*/ + if (mpuin->filter.rt_out) + midi_raw_out_rt_byte(msg[0]); + break; + } + return; + } + if (send_thru && mpuin->midi_thru) { + if (retrigger_thru) { + midi_raw_out_byte(0x80|(msg[0]&0xf)); + midi_raw_out_byte(msg[1]); + midi_raw_out_byte(msg[2]); + } + for (i=0/*((midistatus && !retrigger_thru)? 1:0)*/;istate.rec==M_RECON) { + uint8_t recmsg[4]={mpuin->clock.rec_counter,msg[0],msg[1],msg[2]}; + MPU401_RecQueueBuffer(mpuin,recmsg,len+1,1); + mpuin->clock.rec_counter=0; + } + else if (mpuin->filter.data_in_stop) { + if (mpuin->filter.timing_in_stop) { + uint8_t recmsg[4]={0,msg[0],msg[1],msg[2]}; + MPU401_RecQueueBuffer(mpuin,recmsg,len+1,1); + } + else { + uint8_t recmsg[4]={msg[0],msg[1],msg[2],0}; + MPU401_RecQueueBuffer(mpuin,recmsg,len,1); + } + } + } + return; + } + /*UART mode input*/ + thread_wait_mutex(mpu_lock); + for (i=0;i * DOSBox Team, @@ -22,10 +22,16 @@ #define MPU401_VERSION 0x15 #define MPU401_REVISION 0x01 -#define MPU401_QUEUE 32 +#define MPU401_QUEUE 64 +#define MPU401_INPUT_QUEUE 1024 #define MPU401_TIMECONSTANT (60000000/1000.0f) #define MPU401_RESETBUSY 27.0f +/*helpers*/ +#define M_GETKEY key[key/32]&(1<<(key%32)) +#define M_SETKEY key[key/32]|=(1<<(key%32)) +#define M_DELKEY key[key/32]&=~(1<<(key%32)) + typedef enum MpuMode { M_UART, @@ -43,6 +49,13 @@ typedef enum MpuDataType T_COMMAND } MpuDataType; +typedef enum RecState +{ + M_RECOFF, + M_RECSTB, + M_RECON +} RecState; + /* Messages sent to MPU-401 from host */ #define MSG_EOX 0xf7 #define MSG_OVERFLOW 0xf8 @@ -57,6 +70,7 @@ typedef enum MpuDataType typedef struct mpu_t { + int midi_thru; int uart_mode, intelligent, irq, queue_pos, queue_used; @@ -64,10 +78,13 @@ typedef struct mpu_t status, queue[MPU401_QUEUE], pos_regs[8]; MpuMode mode; + uint8_t rec_queue[MPU401_INPUT_QUEUE]; + int rec_queue_pos, rec_queue_used; + uint32_t ch_toref[16]; struct track { int counter; - uint8_t value[8], sys_val, + uint8_t value[3], sys_val, vlength,length; MpuDataType type; } playbuf[8], condbuf; @@ -77,23 +94,50 @@ typedef struct mpu_t playing, reset, wsd, wsm, wsd_start, run_irq, irq_pending, + track_req, send_now, eoi_scheduled, - data_onoff; + data_onoff, clock_to_host, + sync_in, sysex_in_finished, + rec_copy; + RecState rec; uint8_t tmask, cmask, amask, - channel, old_chan; + last_rtcmd; uint16_t midi_mask, req_mask; - uint32_t command_byte, cmd_pending; + uint32_t command_byte, cmd_pending, + track, old_track; } state; struct { uint8_t timebase, old_timebase, tempo, old_tempo, tempo_rel, old_tempo_rel, - tempo_grad, - cth_rate, cth_counter; - int clock_to_host,cth_active; + tempo_grad, cth_rate[4], + cth_mode, midimetro, + metromeas; + uint32_t cth_counter, cth_old, + rec_counter; + int32_t measure_counter, meas_old, + freq; + int ticks_in, active; + float freq_mod; } clock; - + struct { + int all_thru, midi_thru, + sysex_thru, commonmsgs_thru, + modemsgs_in, commonmsgs_in, + bender_in, sysex_in, + allnotesoff_out, rt_affection, + rt_out, rt_in, + timing_in_stop, data_in_stop, + rec_measure_end; + uint8_t prchg_buf[16]; + uint16_t prchg_mask; + } filter; + struct { + int on; + uint8_t chan, trmask; + uint32_t key[4]; + } chanref[5], inputref[16]; pc_timer_t mpu401_event_callback, mpu401_eoi_callback, mpu401_reset_callback; } mpu_t; diff --git a/src/sound/snd_sb.c b/src/sound/snd_sb.c index b927e54e4..23f5812a9 100644 --- a/src/sound/snd_sb.c +++ b/src/sound/snd_sb.c @@ -32,6 +32,7 @@ #include "../rom.h" #include "../device.h" #include "sound.h" +#include "midi.h" #include "filters.h" #include "snd_emu8k.h" #include "snd_mpu401.h" @@ -188,6 +189,12 @@ sb_log(const char *fmt, ...) #endif +static void +sb_dsp_set_midi_in(sb_dsp_t *src_dsp_midi_in) +{ + dspin = src_dsp_midi_in; +} + /* sb 1, 1.5, 2, 2 mvc do not have a mixer, so signal is hardwired */ static void sb_get_buffer_sb2(int32_t *buffer, int len, void *p) { @@ -1041,6 +1048,11 @@ void *sb_1_init() io_sethandler(0x0388, 0x0002, opl2_read, NULL, NULL, opl2_write, NULL, NULL, &sb->opl); } sound_add_handler(sb_get_buffer_sb2, sb); + + sb_dsp_set_midi_in(&sb->dsp); + input_msg = sb_dsp_input_msg; + input_sysex = sb_dsp_input_sysex; + return sb; } void *sb_15_init() @@ -1067,6 +1079,11 @@ void *sb_15_init() io_sethandler(0x0388, 0x0002, opl2_read, NULL, NULL, opl2_write, NULL, NULL, &sb->opl); } sound_add_handler(sb_get_buffer_sb2, sb); + + sb_dsp_set_midi_in(&sb->dsp); + input_msg = sb_dsp_input_msg; + input_sysex = sb_dsp_input_sysex; + return sb; } @@ -1090,6 +1107,11 @@ void *sb_mcv_init() mca_add(sb_mcv_read, sb_mcv_write, sb_mcv_feedb, sb); sb->pos_regs[0] = 0x84; sb->pos_regs[1] = 0x50; + + sb_dsp_set_midi_in(&sb->dsp); + input_msg = sb_dsp_input_msg; + input_sysex = sb_dsp_input_sysex; + return sb; } void *sb_2_init() @@ -1137,6 +1159,10 @@ void *sb_2_init() else sound_add_handler(sb_get_buffer_sb2, sb); + sb_dsp_set_midi_in(&sb->dsp); + input_msg = sb_dsp_input_msg; + input_sysex = sb_dsp_input_sysex; + return sb; } @@ -1170,6 +1196,10 @@ void *sb_pro_v1_init() io_sethandler(addr+4, 0x0002, sb_ct1345_mixer_read, NULL, NULL, sb_ct1345_mixer_write, NULL, NULL, sb); sound_add_handler(sb_get_buffer_sbpro, sb); + sb_dsp_set_midi_in(&sb->dsp); + input_msg = sb_dsp_input_msg; + input_sysex = sb_dsp_input_sysex; + return sb; } @@ -1202,6 +1232,10 @@ void *sb_pro_v2_init() io_sethandler(addr+4, 0x0002, sb_ct1345_mixer_read, NULL, NULL, sb_ct1345_mixer_write, NULL, NULL, sb); sound_add_handler(sb_get_buffer_sbpro, sb); + sb_dsp_set_midi_in(&sb->dsp); + input_msg = sb_dsp_input_msg; + input_sysex = sb_dsp_input_sysex; + return sb; } @@ -1227,6 +1261,10 @@ void *sb_pro_mcv_init() sb->pos_regs[0] = 0x03; sb->pos_regs[1] = 0x51; + sb_dsp_set_midi_in(&sb->dsp); + input_msg = sb_dsp_input_msg; + input_sysex = sb_dsp_input_sysex; + return sb; } @@ -1261,6 +1299,11 @@ void *sb_16_init() } else sb->mpu = NULL; + + sb_dsp_set_midi_in(&sb->dsp); + input_msg = sb_dsp_input_msg; + input_sysex = sb_dsp_input_sysex; + return sb; } @@ -1305,6 +1348,10 @@ void *sb_awe32_init() sb->mpu = NULL; emu8k_init(&sb->emu8k, emu_addr, onboard_ram); + sb_dsp_set_midi_in(&sb->dsp); + input_msg = sb_dsp_input_msg; + input_sysex = sb_dsp_input_sysex; + return sb; } diff --git a/src/sound/snd_sb_dsp.c b/src/sound/snd_sb_dsp.c index 35aeb7ee7..51188ee03 100644 --- a/src/sound/snd_sb_dsp.c +++ b/src/sound/snd_sb_dsp.c @@ -119,7 +119,7 @@ uint8_t adjustMap2[24] = { }; float low_fir_sb16_coef[SB16_NCoef]; - +sb_dsp_t *dspin; #ifdef ENABLE_SB_DSP_LOG int sb_dsp_do_log = ENABLE_SB_DSP_LOG; @@ -147,7 +147,6 @@ sinc(double x) return sin(M_PI * x) / (M_PI * x); } - static void recalc_sb16_filter(int playback_freq) { @@ -207,6 +206,8 @@ sb_irqc(sb_dsp_t *dsp, int irq8) void sb_dsp_reset(sb_dsp_t *dsp) { + midi_clear_buffer(); + timer_disable(&dsp->output_timer); timer_disable(&dsp->input_timer); @@ -218,7 +219,7 @@ sb_dsp_reset(sb_dsp_t *dsp) sb_irqc(dsp, 0); sb_irqc(dsp, 1); dsp->sb_16_pause = 0; - dsp->sb_read_wp = dsp->sb_read_rp = 0; + dsp->sb_read_wp = dsp->sb_read_rp = 0; dsp->sb_data_stat = -1; dsp->sb_speaker = 0; dsp->sb_pausetime = -1LL; @@ -393,7 +394,6 @@ sb_dsp_setdma16(sb_dsp_t *dsp, int dma) dsp->sb_16_dmanum = dma; } - void sb_exec_command(sb_dsp_t *dsp) { @@ -457,19 +457,35 @@ sb_exec_command(sb_dsp_t *dsp) if (dsp->sb_type >= SB15) sb_start_dma_i(dsp, 1, 1, 0, dsp->sb_data[0] + (dsp->sb_data[1] << 8)); break; - case 0x30: case 0x31: + case 0x30: /* MIDI Polling mode input */ + pclog("MIDI polling mode input\n"); + dsp->midi_in_poll = 1; + dsp->uart_irq = 0; break; - case 0x34: /* MIDI (UART mode) */ + case 0x31: /* MIDI Interrupt mode input */ + pclog("MIDI interrupt mode input\n"); + dsp->midi_in_poll = 0; + dsp->uart_irq = 1; + break; + case 0x34: /* MIDI In poll */ + if (dsp->sb_type < SB2) + break; + pclog("MIDI poll in\n"); + dsp->midi_in_poll = 1; dsp->uart_midi = 1; dsp->uart_irq = 0; break; - case 0x35: /* MIDI (UART mode) */ + case 0x35: /* MIDI In irq */ + if (dsp->sb_type < SB2) + break; + pclog("MIDI irq in\n"); + dsp->midi_in_poll = 0; dsp->uart_midi = 1; dsp->uart_irq = 1; break; - case 0x36: case 0x37: + case 0x36: case 0x37: /* MIDI timestamps */ break; - case 0x38: /* MIDI (Normal mode) */ + case 0x38: /* Write to SB MIDI Output (Raw) */ dsp->onebyte_midi = 1; break; case 0x40: /* Set time constant */ @@ -724,17 +740,22 @@ sb_write(uint16_t a, uint8_t v, void *priv) switch (a & 0xF) { case 6: /* Reset */ - if (!(v & 1) && (dsp->sbreset & 1)) { - sb_dsp_reset(dsp); - sb_add_data(dsp, 0xAA); + if (!dsp->uart_midi) { + if (!(v & 1) && (dsp->sbreset & 1)) { + sb_dsp_reset(dsp); + sb_add_data(dsp, 0xAA); + } + dsp->sbreset = v; } - dsp->sbreset = v; + dsp->uart_midi = 0; + dsp->uart_irq = 0; + dsp->onebyte_midi = 0; return; case 0xC: /* Command/data write */ - if (dsp->uart_midi || dsp->onebyte_midi) { - midi_write(v); + if (dsp->uart_midi || dsp->onebyte_midi ) { + midi_raw_out_byte(v); dsp->onebyte_midi = 0; - return; + return; } timer_set_delay_u64(&dsp->wb_timer, TIMER_USEC * 1); if (dsp->asp_data_len) { @@ -768,9 +789,9 @@ sb_read(uint16_t a, void *priv) switch (a & 0xf) { case 0xA: /* Read data */ - if (mpu && dsp->uart_midi) + if (mpu && dsp->uart_midi) { ret = MPU401_ReadData(mpu); - else { + } else { dsp->sbreaddat = dsp->sb_read_data[dsp->sb_read_rp]; if (dsp->sb_read_rp != dsp->sb_read_wp) { dsp->sb_read_rp++; @@ -814,6 +835,47 @@ sb_dsp_set_mpu(mpu_t *src_mpu) mpu = src_mpu; } +void +sb_dsp_input_msg(uint8_t *msg) +{ + pclog("MIDI in sysex = %d, uart irq = %d, midi in = %d\n", dspin->midi_in_sysex, dspin->uart_irq, dspin->midi_in_poll); + + if (dspin->midi_in_sysex) { + return; + } + + uint8_t len = msg[3]; + uint8_t i = 0; + if (dspin->uart_irq) { + for (i=0;isb_irq8) sb_irq(dspin, 1); + } else if (dspin->midi_in_poll) { + for (i=0;imidi_in_sysex = 0; + return 0; + } + dspin->midi_in_sysex = 1; + for (i=0;isb_read_rp == dspin->sb_read_wp) { + pclog("Length sysex SB = %d\n", len-i); + return (len-i); + } + sb_add_data(dspin, buffer[i]); + } + dspin->midi_in_sysex = 0; + return 0; +} void sb_dsp_init(sb_dsp_t *dsp, int type) diff --git a/src/sound/snd_sb_dsp.h b/src/sound/snd_sb_dsp.h index 2772e2254..2c7022912 100644 --- a/src/sound/snd_sb_dsp.h +++ b/src/sound/snd_sb_dsp.h @@ -9,14 +9,18 @@ typedef struct sb_dsp_t int sb_pausetime; uint8_t sb_read_data[256]; - int sb_read_wp, sb_read_rp; + int sb_read_wp, sb_read_rp; int sb_speaker; int muted; int sb_data_stat; - int uart_midi; - int uart_irq; - int onebyte_midi; + + int midi_in_sysex; + int midi_in_poll; + int uart_midi; + int uart_irq; + int onebyte_midi; + int midi_in_timestamp; int sb_irqnum; @@ -72,6 +76,12 @@ typedef struct sb_dsp_t int pos; } sb_dsp_t; +extern sb_dsp_t *dspin; + +void sb_dsp_input_msg(uint8_t *msg); + +int sb_dsp_input_sysex(uint8_t *buffer, uint32_t len, int abort); + void sb_dsp_set_mpu(mpu_t *src_mpu); void sb_dsp_init(sb_dsp_t *dsp, int type); diff --git a/src/sound/sound.c b/src/sound/sound.c index 12875f4f1..d3de46351 100644 --- a/src/sound/sound.c +++ b/src/sound/sound.c @@ -107,7 +107,6 @@ static const SOUND_CARD sound_cards[] = { "[MCA] Sound Blaster MCV", "sbmcv", &sb_mcv_device }, { "[MCA] Sound Blaster Pro MCV", "sbpromcv", &sb_pro_mcv_device }, { "[PCI] Ensoniq AudioPCI (ES1371)", "es1371", &es1371_device }, - { "[PCI] Sound Blaster PCI 128", "sbpci128", &es1371_device }, { "", "", NULL } }; @@ -442,6 +441,7 @@ sound_reset(void) sound_realloc_buffers(); midi_device_init(); + midi_in_device_init(); inital(); timer_add(&sound_poll_timer, sound_poll, NULL, 1); diff --git a/src/win/86Box.rc b/src/win/86Box.rc index 294e813b9..43c2c0f7c 100644 --- a/src/win/86Box.rc +++ b/src/win/86Box.rc @@ -380,34 +380,39 @@ BEGIN LTEXT "MIDI Out Device:",IDT_1712,7,26,59,10 PUSHBUTTON "Configure",IDC_CONFIGURE_MIDI,214,25,46,12 + COMBOBOX IDC_COMBO_MIDI_IN,71,43,140,120,CBS_DROPDOWNLIST | WS_VSCROLL | + WS_TABSTOP + LTEXT "MIDI In Device:",IDT_1713,7,44,59,10 + PUSHBUTTON "Configure",IDC_CONFIGURE_MIDI_IN,214,43,46,12 + CONTROL "Standalone MPU-401",IDC_CHECK_MPU401,"Button", - BS_AUTOCHECKBOX | WS_TABSTOP,7,45,199,10 - PUSHBUTTON "Configure",IDC_CONFIGURE_MPU401,214,44,46,12 + BS_AUTOCHECKBOX | WS_TABSTOP,7,65,199,10 + PUSHBUTTON "Configure",IDC_CONFIGURE_MPU401,214,64,46,12 CONTROL "Innovation SSI-2001",IDC_CHECK_SSI,"Button", - BS_AUTOCHECKBOX | WS_TABSTOP,7,63,94,10 + BS_AUTOCHECKBOX | WS_TABSTOP,7,83,94,10 CONTROL "CMS / Game Blaster",IDC_CHECK_CMS,"Button", - BS_AUTOCHECKBOX | WS_TABSTOP,147,63,94,10 + BS_AUTOCHECKBOX | WS_TABSTOP,147,83,94,10 CONTROL "Gravis Ultrasound",IDC_CHECK_GUS,"Button", - BS_AUTOCHECKBOX | WS_TABSTOP,7,81,94,10 + BS_AUTOCHECKBOX | WS_TABSTOP,7,101,94,10 CONTROL "Use FLOAT32 sound",IDC_CHECK_FLOAT,"Button", - BS_AUTOCHECKBOX | WS_TABSTOP,147,81,94,10 + BS_AUTOCHECKBOX | WS_TABSTOP,147,101,94,10 END DLG_CFG_NETWORK DIALOG DISCARDABLE 97, 0, 267, 63 STYLE DS_CONTROL | WS_CHILD FONT 9, "Segoe UI" BEGIN - LTEXT "Network type:",IDT_1713,7,8,59,10 + LTEXT "Network type:",IDT_1714,7,8,59,10 COMBOBOX IDC_COMBO_NET_TYPE,71,7,189,120,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP - LTEXT "PCap device:",IDT_1714,7,26,59,10 + LTEXT "PCap device:",IDT_1715,7,26,59,10 COMBOBOX IDC_COMBO_PCAP,71,25,189,120,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP - LTEXT "Network adapter:",IDT_1715,7,44,59,10 + LTEXT "Network adapter:",IDT_1716,7,44,59,10 COMBOBOX IDC_COMBO_NET,71,43,140,120,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP PUSHBUTTON "Configure",IDC_CONFIGURE_NET,214,43,46,12 @@ -417,15 +422,15 @@ DLG_CFG_PORTS DIALOG DISCARDABLE 97, 0, 267, 117 STYLE DS_CONTROL | WS_CHILD FONT 9, "Segoe UI" BEGIN - LTEXT "LPT1 Device:",IDT_1716,7,8,61,10 + LTEXT "LPT1 Device:",IDT_1717,7,8,61,10 COMBOBOX IDC_COMBO_LPT1,71,7,189,120,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP - LTEXT "LPT2 Device:",IDT_1717,7,27,61,10 + LTEXT "LPT2 Device:",IDT_1718,7,27,61,10 COMBOBOX IDC_COMBO_LPT2,71,26,189,120,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP - LTEXT "LPT3 Device:",IDT_1718,7,46,61,10 + LTEXT "LPT3 Device:",IDT_1719,7,46,61,10 COMBOBOX IDC_COMBO_LPT3,71,45,189,120,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP @@ -446,12 +451,12 @@ DLG_CFG_PERIPHERALS DIALOG DISCARDABLE 97, 0, 267, 200 STYLE DS_CONTROL | WS_CHILD FONT 9, "Segoe UI" BEGIN - LTEXT "SCSI Controller:",IDT_1716,7,8,48,10 + LTEXT "SCSI Controller:",IDT_1717,7,8,48,10 COMBOBOX IDC_COMBO_SCSI,64,7,155,120,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP PUSHBUTTON "Configure",IDC_CONFIGURE_SCSI,222,7,38,12 - LTEXT "HD Controller:",IDT_1717,7,26,48,10 + LTEXT "HD Controller:",IDT_1718,7,26,48,10 COMBOBOX IDC_COMBO_HDC,64,25,155,120,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP PUSHBUTTON "Configure",IDC_CONFIGURE_HDC,222,25,38,12 diff --git a/src/win/resource.h b/src/win/resource.h index e34f6a1be..49ba9679e 100644 --- a/src/win/resource.h +++ b/src/win/resource.h @@ -54,12 +54,13 @@ #define IDT_1710 1710 /* Joystick: */ #define IDT_1711 1711 /* Sound card: */ #define IDT_1712 1712 /* MIDI Out Device: */ -#define IDT_1713 1713 /* Network type: */ -#define IDT_1714 1714 /* PCap device: */ -#define IDT_1715 1715 /* Network adapter: */ -#define IDT_1716 1716 /* SCSI Controller: */ -#define IDT_1717 1717 /* HD Controller: */ -#define IDT_1718 1718 +#define IDT_1713 1713 /* MIDI In Device: */ +#define IDT_1714 1714 /* Network type: */ +#define IDT_1715 1715 /* PCap device: */ +#define IDT_1716 1716 /* Network adapter: */ +#define IDT_1717 1717 /* SCSI Controller: */ +#define IDT_1718 1718 /* HD Controller: */ +#define IDT_1719 1719 #define IDT_1720 1720 /* Hard disks: */ #define IDT_1721 1721 /* Bus: */ #define IDT_1722 1722 /* Channel: */ @@ -149,6 +150,7 @@ #define IDC_CONFIGURE_MPU401 1077 #define IDC_CHECK_FLOAT 1078 #define IDC_CHECK_GUSMAX 1079 +#define IDC_COMBO_MIDI_IN 1080 #define IDC_COMBO_NET_TYPE 1090 /* network config */ #define IDC_COMBO_PCAP 1091 @@ -241,6 +243,7 @@ #define IDC_CONFIGURE_PCAP 1306 #define IDC_CONFIGURE_NET 1307 #define IDC_CONFIGURE_MIDI 1308 +#define IDC_CONFIGURE_MIDI_IN 1309 #define IDC_JOY1 1310 #define IDC_JOY2 1311 #define IDC_JOY3 1312 diff --git a/src/win/win_devconf.c b/src/win/win_devconf.c index a0a1e5018..e5e379d6c 100644 --- a/src/win/win_devconf.c +++ b/src/win/win_devconf.c @@ -108,6 +108,21 @@ deviceconfig_dlgproc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam) id += 2; break; + case CONFIG_MIDI_IN: + val_int = config_get_int((char *) config_device.name, + (char *) config->name, config->default_int); + + num = plat_midi_in_get_num_devs(); + for (c = 0; c < num; c++) { + plat_midi_in_get_dev_name(c, s); + mbstowcs(lptsTemp, s, strlen(s) + 1); + SendMessage(h, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)lptsTemp); + if (val_int == c) + SendMessage(h, CB_SETCURSEL, c, 0); + } + + id += 2; + break; case CONFIG_SPINNER: val_int = config_get_int((char *) config_device.name, (char *) config->name, config->default_int); @@ -205,6 +220,17 @@ deviceconfig_dlgproc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam) c = SendMessage(h, CB_GETCURSEL, 0, 0); + if (val_int != c) + changed = 1; + + id += 2; + break; + case CONFIG_MIDI_IN: + val_int = config_get_int((char *) config_device.name, + (char *) config->name, config->default_int); + + c = SendMessage(h, CB_GETCURSEL, 0, 0); + if (val_int != c) changed = 1; @@ -302,6 +328,12 @@ deviceconfig_dlgproc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam) c = SendMessage(h, CB_GETCURSEL, 0, 0); config_set_int((char *) config_device.name, (char *) config->name, c); + id += 2; + break; + case CONFIG_MIDI_IN: + c = SendMessage(h, CB_GETCURSEL, 0, 0); + config_set_int((char *) config_device.name, (char *) config->name, c); + id += 2; break; case CONFIG_FNAME: @@ -358,6 +390,7 @@ deviceconfig_dlgproc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam) break; case CONFIG_SELECTION: case CONFIG_MIDI: + case CONFIG_MIDI_IN: case CONFIG_SPINNER: id += 2; break; @@ -478,6 +511,7 @@ deviceconfig_inst_open(HWND hwnd, const device_t *device, int inst) case CONFIG_SELECTION: case CONFIG_MIDI: + case CONFIG_MIDI_IN: case CONFIG_HEX16: case CONFIG_HEX20: /*Combo box*/ diff --git a/src/win/win_midi.c b/src/win/win_midi.c index 706db3acb..239fd7a77 100644 --- a/src/win/win_midi.c +++ b/src/win/win_midi.c @@ -13,13 +13,15 @@ typedef struct { - int midi_id; + int midi_id, midi_input_id; HANDLE m_event; + HANDLE m_callback; HMIDIOUT midi_out_device; + HMIDIIN midi_in_device; - MIDIHDR m_hdr; + MIDIHDR m_hdr, m_hdr_in; } plat_midi_t; plat_midi_t *pm = NULL; @@ -39,6 +41,7 @@ plat_midi_init(void) pm->m_event = CreateEvent(NULL, TRUE, TRUE, NULL); + pclog("Plat MIDI Out init\n"); hr = midiOutOpen(&pm->midi_out_device, pm->midi_id, (uintptr_t) pm->m_event, 0, CALLBACK_EVENT); if (hr != MMSYSERR_NOERROR) { @@ -65,7 +68,7 @@ plat_midi_close(void) midiOutClose(pm->midi_out_device); CloseHandle(pm->m_event); } - + free(pm); pm = NULL; } @@ -135,3 +138,119 @@ plat_midi_write(uint8_t val) { return 0; } + +void CALLBACK +plat_midi_in_callback(HMIDIIN hMidiIn, UINT wMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2) { + pclog("MIDI: wMsg:%x %x %x\n",wMsg, dwParam1, dwParam2); + uint8_t msg[4] = {((dwParam1&0xff)),(((dwParam1&0xff00)>>8)), + (((dwParam1&0xff0000)>>16)),MIDI_evt_len[((dwParam1&0xff))]}; + uint8_t *sysex; + int len; + int cnt; + MIDIHDR *t_hdr; + switch (wMsg) { + case MM_MIM_DATA: /* 0x3C3 - midi message */ + input_msg(msg); + break; + case MM_MIM_OPEN: /* 0x3C1 */ + break; + case MM_MIM_CLOSE: /* 0x3C2 */ + break; + case MM_MIM_LONGDATA: /* 0x3C4 - sysex */ + pclog("MIDI sysex\n"); + t_hdr = (MIDIHDR *)dwParam1; + sysex = (uint8_t *)t_hdr->lpData; + len = (unsigned int)t_hdr->dwBytesRecorded; + cnt = 5; + while (cnt) { /*abort if timed out*/ + int ret = input_sysex(sysex, len, 0); + if (!ret) { + len = 0; + break; + } + if (len==ret) + cnt--; + else + cnt = 5; + sysex += len-ret; + len = ret; + Sleep(5);/*msec*/ + } + if (len) + input_sysex(sysex, 0, 0); + + midiInUnprepareHeader(hMidiIn, t_hdr, sizeof(*t_hdr)); + t_hdr->dwBytesRecorded = 0; + midiInPrepareHeader(hMidiIn, t_hdr, sizeof(*t_hdr)); + break; + case MM_MIM_ERROR: + case MM_MIM_LONGERROR: + break; + default: + break; + } +} + +void +plat_midi_input_init(void) +{ + MMRESULT hr; + + pm = (plat_midi_t *) malloc(sizeof(plat_midi_t)); + memset(pm, 0, sizeof(plat_midi_t)); + + pclog("Plat MIDI Input init\n"); + + pm->midi_input_id = config_get_int(MIDI_INPUT_NAME, "midi_input", 0); + + hr = midiInOpen(&pm->midi_in_device, pm->midi_input_id, + (uintptr_t) plat_midi_in_callback, 0, CALLBACK_FUNCTION); + if (hr != MMSYSERR_NOERROR) { + pclog("midiInOpen error - %08X\n", hr); + pm->midi_input_id = 0; + hr = midiInOpen(&pm->midi_in_device, pm->midi_input_id, + (uintptr_t) plat_midi_in_callback, 0, CALLBACK_FUNCTION); + if (hr != MMSYSERR_NOERROR) { + pclog("midiInOpen error - %08X\n", hr); + return; + } + } + + pm->m_hdr_in.lpData = (char*)&MIDI_InSysexBuf[0]; + pm->m_hdr_in.dwBufferLength = SYSEX_SIZE; + pm->m_hdr_in.dwBytesRecorded = 0 ; + pm->m_hdr_in.dwUser = 0; + pclog("Prepare MIDI In\n"); + midiInPrepareHeader(pm->midi_in_device,&pm->m_hdr_in,sizeof(pm->m_hdr_in)); + midiInStart(pm->midi_in_device); +} + +void +plat_midi_input_close(void) +{ + if (pm) { + if (pm->midi_in_device != NULL) { + midiInStop(pm->midi_in_device); + midiInClose(pm->midi_in_device); + } + + free(pm); + pm = NULL; + } +} + +int +plat_midi_in_get_num_devs(void) +{ + return midiInGetNumDevs(); +} + + +void +plat_midi_in_get_dev_name(int num, char *s) +{ + MIDIINCAPS caps; + + midiInGetDevCaps(num, &caps, sizeof(caps)); + strcpy(s, caps.szPname); +} \ No newline at end of file diff --git a/src/win/win_settings.c b/src/win/win_settings.c index f2a716a8c..1a2605a07 100644 --- a/src/win/win_settings.c +++ b/src/win/win_settings.c @@ -84,7 +84,7 @@ static int temp_gfxcard, temp_voodoo; static int temp_mouse, temp_joystick; /* Sound category */ -static int temp_sound_card, temp_midi_device, temp_mpu401, temp_SSI2001, temp_GAMEBLASTER, temp_GUS; +static int temp_sound_card, temp_midi_device, temp_midi_input_device, temp_mpu401, temp_SSI2001, temp_GAMEBLASTER, temp_GUS; static int temp_float; /* Network category */ @@ -123,6 +123,7 @@ extern int is486; static int listtomachine[256], machinetolist[256]; static int settings_device_to_list[2][20], settings_list_to_device[2][20]; static int settings_midi_to_list[20], settings_list_to_midi[20]; +static int settings_midi_in_to_list[20], settings_list_to_midi_in[20]; static int max_spt = 63, max_hpc = 255, max_tracks = 266305; static uint64_t mfm_tracking, esdi_tracking, xta_tracking, ide_tracking, scsi_tracking[2]; @@ -218,6 +219,7 @@ win_settings_init(void) /* Sound category */ temp_sound_card = sound_card_current; temp_midi_device = midi_device_current; + temp_midi_input_device = midi_input_device_current; temp_mpu401 = mpu401_standalone_enable; temp_SSI2001 = SSI2001; temp_GAMEBLASTER = GAMEBLASTER; @@ -329,6 +331,7 @@ win_settings_changed(void) /* Sound category */ i = i || (sound_card_current != temp_sound_card); i = i || (midi_device_current != temp_midi_device); + i = i || (midi_input_device_current != temp_midi_input_device); i = i || (mpu401_standalone_enable != temp_mpu401); i = i || (SSI2001 != temp_SSI2001); i = i || (GAMEBLASTER != temp_GAMEBLASTER); @@ -431,6 +434,7 @@ win_settings_save(void) /* Sound category */ sound_card_current = temp_sound_card; midi_device_current = temp_midi_device; + midi_input_device_current = temp_midi_input_device; mpu401_standalone_enable = temp_mpu401; SSI2001 = temp_SSI2001; GAMEBLASTER = temp_GAMEBLASTER; @@ -1100,12 +1104,13 @@ mpu401_present(void) int mpu401_standalone_allow(void) { - char *md; + char *md, *mdin; md = midi_device_get_internal_name(temp_midi_device); + mdin = midi_in_device_get_internal_name(temp_midi_input_device); if (md != NULL) { - if (!strcmp(md, "none")) + if (!strcmp(md, "none") && !strcmp(mdin, "none")) return 0; } @@ -1195,12 +1200,45 @@ win_settings_sound_proc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam) else EnableWindow(h, FALSE); + h = GetDlgItem(hdlg, IDC_COMBO_MIDI_IN); + c = d = 0; + while (1) { + s = midi_in_device_getname(c); + + if (!s[0]) + break; + + settings_midi_in_to_list[c] = d; + + if (midi_in_device_available(c)) { + if (c == 0) + SendMessage(h, CB_ADDSTRING, 0, win_get_string(IDS_2112)); + else { + mbstowcs(lptsTemp, s, strlen(s) + 1); + SendMessage(h, CB_ADDSTRING, 0, (LPARAM) lptsTemp); + } + settings_list_to_midi_in[d] = c; + d++; + } + + c++; + } + SendMessage(h, CB_SETCURSEL, settings_midi_in_to_list[temp_midi_input_device], 0); + + h = GetDlgItem(hdlg, IDC_CONFIGURE_MIDI_IN); + if (midi_in_device_has_config(temp_midi_input_device)) + EnableWindow(h, TRUE); + else + EnableWindow(h, FALSE); + + h = GetDlgItem(hdlg, IDC_CHECK_MPU401); SendMessage(h, BM_SETCHECK, temp_mpu401, 0); EnableWindow(h, mpu401_standalone_allow() ? TRUE : FALSE); h = GetDlgItem(hdlg, IDC_CONFIGURE_MPU401); EnableWindow(h, (mpu401_standalone_allow() && temp_mpu401) ? TRUE : FALSE); + h=GetDlgItem(hdlg, IDC_CHECK_CMS); SendMessage(h, BM_SETCHECK, temp_GAMEBLASTER, 0); @@ -1270,6 +1308,31 @@ win_settings_sound_proc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam) temp_deviceconfig |= deviceconfig_open(hdlg, (void *)midi_device_getdevice(temp_midi_device)); break; + case IDC_COMBO_MIDI_IN: + h = GetDlgItem(hdlg, IDC_COMBO_MIDI_IN); + temp_midi_input_device = settings_list_to_midi_in[SendMessage(h, CB_GETCURSEL, 0, 0)]; + + h = GetDlgItem(hdlg, IDC_CONFIGURE_MIDI_IN); + if (midi_in_device_has_config(temp_midi_input_device)) + EnableWindow(h, TRUE); + else + EnableWindow(h, FALSE); + + h = GetDlgItem(hdlg, IDC_CHECK_MPU401); + SendMessage(h, BM_SETCHECK, temp_mpu401, 0); + EnableWindow(h, mpu401_standalone_allow() ? TRUE : FALSE); + + h = GetDlgItem(hdlg, IDC_CONFIGURE_MPU401); + EnableWindow(h, (mpu401_standalone_allow() && temp_mpu401) ? TRUE : FALSE); + break; + + case IDC_CONFIGURE_MIDI_IN: + h = GetDlgItem(hdlg, IDC_COMBO_MIDI_IN); + temp_midi_input_device = settings_list_to_midi_in[SendMessage(h, CB_GETCURSEL, 0, 0)]; + + temp_deviceconfig |= deviceconfig_open(hdlg, (void *)midi_in_device_getdevice(temp_midi_input_device)); + break; + case IDC_CHECK_MPU401: h = GetDlgItem(hdlg, IDC_CHECK_MPU401); temp_mpu401 = SendMessage(h, BM_GETCHECK, 0, 0); @@ -1292,6 +1355,9 @@ win_settings_sound_proc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam) h = GetDlgItem(hdlg, IDC_COMBO_MIDI); temp_midi_device = settings_list_to_midi[SendMessage(h, CB_GETCURSEL, 0, 0)]; + h = GetDlgItem(hdlg, IDC_COMBO_MIDI_IN); + temp_midi_input_device = settings_list_to_midi_in[SendMessage(h, CB_GETCURSEL, 0, 0)]; + h = GetDlgItem(hdlg, IDC_CHECK_MPU401); temp_mpu401 = SendMessage(h, BM_GETCHECK, 0, 0);