Different approach to CM-32L emulation, fixes it and MT-32.

src/SOUND/midi.c

@@ -138,18 +138,18 @@ void midi_close()
 
 void midi_poll()
 {
-        if (m_device && m_device->poll) m_device->poll(m_device);
+        if (m_device && m_device->poll) m_device->poll();
 }
 
 void play_msg(uint8_t *msg)
 {
-        if (m_device->play_msg) m_device->play_msg(m_device, msg);
+        if (m_device->play_msg) m_device->play_msg(msg);
 }
 
 
 void play_sysex(uint8_t *sysex, unsigned int len)
 {
-        if (m_device->play_sysex) m_device->play_sysex(m_device, sysex, len);
+        if (m_device->play_sysex) m_device->play_sysex(sysex, len);
 }
 
 #define SYSEX_SIZE 1024
@@ -159,7 +159,7 @@ void midi_write(uint8_t val)
 {
         if (!m_device) return;
 
-        if (m_device->write && m_device->write(m_device, val)) return;
+        if (m_device->write && m_device->write(val)) return;
 
         uint32_t passed_ticks;
 

src/SOUND/midi.h

@@ -10,11 +10,10 @@ void midi_device_init();
 
 typedef struct midi_device_t
 {
-        void (*play_sysex)(struct midi_device_t* p, uint8_t *sysex, unsigned int len);
+        void (*play_sysex)(uint8_t *sysex, unsigned int len);
-        void (*play_msg)(struct midi_device_t* p, uint8_t *msg);
+        void (*play_msg)(uint8_t *msg);
-        void (*poll)(struct midi_device_t* p);
+        void (*poll)();
-        int (*write)(struct midi_device_t* p, uint8_t val);
+        int (*write)(uint8_t val);
-        void* data;
 } midi_device_t;
 
 void midi_init(midi_device_t* device);

src/SOUND/midi_mt32.c

@@ -3,7 +3,6 @@
 #include <string.h>
 #include "munt/c_interface/c_interface.h"
 #include "../WIN/plat_thread.h"
-#include "../WIN/plat_ticks.h"
 #include "../ibm.h"
 #include "../device.h"
 #include "../mem.h"
@@ -12,40 +11,9 @@
 #include "midi.h"
 #include "sound.h"
 
-#define RENDER_RATE 30
-#define MESSAGE_HIDE 10000
-
 extern void givealbuffer_midi(void *buf, uint32_t size);
 extern void pclog(const char *format, ...);
 extern void al_set_midi(int freq, int buf_size);
-extern int soundon;
-
-typedef struct mt32_t
-{
-        mt32emu_context context;
-        char message[MT32EMU_SYSEX_BUFFER_SIZE];
-        unsigned int message_shown;
-        thread_t* thread_h;
-        event_t* event;
-
-        uint32_t samplerate;
-        int buf_size;
-        float* buffer;
-        int16_t* buffer_int16;
-        int midi_pos;
-
-        int status_show_instruments;
-
-        char model_name[50];
-} mt32_t;
-
-void showLCDMessage(void *instance_data, const char *message)
-{
-        mt32_t* data = (mt32_t*)instance_data;
-        strncpy(data->message, message, 999);
-        data->message[999] = 0;
-        data->message_shown = get_ticks();
-}
 
 static const mt32emu_report_handler_i_v0 handler_v0 = {
         /** Returns the actual interface version ID */
@@ -57,7 +25,7 @@ static const mt32emu_report_handler_i_v0 handler_v0 = {
         NULL, //void (*onErrorControlROM)(void *instance_data);
         NULL, //void (*onErrorPCMROM)(void *instance_data);
         /** Callback for reporting about displaying a new custom message on LCD */
-        showLCDMessage, //void (*showLCDMessage)(void *instance_data, const char *message);
+        NULL, //void (*showLCDMessage)(void *instance_data, const char *message);
         /** Callback for reporting actual processing of a MIDI message */
         NULL, //void (*onMIDIMessagePlayed)(void *instance_data);
         /**
@@ -85,7 +53,8 @@ static const mt32emu_report_handler_i_v0 handler_v0 = {
 
 static const mt32emu_report_handler_i handler = { &handler_v0 };
 
-static int roms_present[] = { -1, -1 };
+static mt32emu_context context = NULL;
+static int roms_present[2] = {-1, -1};
 
 mt32emu_return_code mt32_check(const char* func, mt32emu_return_code ret, mt32emu_return_code expected)
 {
@@ -111,106 +80,99 @@ int cm32l_available()
         return roms_present[1];
 }
 
-void mt32_stream(mt32emu_context context, float* stream, int len)
+static thread_t *thread_h = NULL;
+static event_t *event = NULL;
+
+#define RENDER_RATE 30
+
+static uint32_t samplerate = 44100;
+static int buf_size = 0;
+static float* buffer = NULL;
+static int16_t* buffer_int16 = NULL;
+static int midi_pos = 0;
+
+void mt32_stream(float* stream, int len)
 {
         if (context) mt32emu_render_float(context, stream, len);
 }
 
-void mt32_stream_int16(mt32emu_context context, int16_t* stream, int len)
+void mt32_stream_int16(int16_t* stream, int len)
 {
         if (context) mt32emu_render_bit16s(context, stream, len);
 }
 
-void mt32_poll(midi_device_t *device)
+void mt32_poll()
 {
-	mt32_t *data = (mt32_t *) device->data;
+        midi_pos++;
-        data->midi_pos++;
+        if (midi_pos == 48000/RENDER_RATE)
-        if (data->midi_pos == 48000/RENDER_RATE)
         {
-                data->midi_pos = 0;
+                midi_pos = 0;
-                thread_set_event(data->event);
+                thread_set_event(event);
         }
-	if (get_ticks() > data->message_shown+MESSAGE_HIDE)
-		data->message[0] = 0;
 }
 
+extern int soundon;
+
 static void mt32_thread(void *param)
 {
-	mt32_t *data = (mt32_t *) param;
         while (1)
         {
-                thread_wait_event(data->event, -1);
+                thread_wait_event(event, -1);
 		if (sound_is_float)
 		{
-	                memset(data->buffer, 0, data->buf_size);
+	                memset(buffer, 0, buf_size * sizeof(float));
-	                mt32_stream(data->context, data->buffer, data->buf_size / (sizeof(float) << 1));
+	                mt32_stream(buffer, (samplerate/RENDER_RATE));
 	                if (soundon)
-				givealbuffer_midi(data->buffer, data->buf_size);
+				givealbuffer_midi(buffer, buf_size);
 		}
 		else
 		{
-	                memset(data->buffer_int16, 0, data->buf_size);
+	                memset(buffer_int16, 0, buf_size * sizeof(int16_t));
-	                mt32_stream_int16(data->context, data->buffer_int16, data->buf_size / (sizeof(int16_t) << 1));
+	                mt32_stream_int16(buffer_int16, (samplerate/RENDER_RATE));
 	                if (soundon)
-				givealbuffer_midi(data->buffer_int16, data->buf_size);
+				givealbuffer_midi(buffer_int16, buf_size);
 		}
         }
 }
 
-void mt32_msg(midi_device_t *device, uint8_t* val)
+void mt32_msg(uint8_t* val)
 {
-	mt32emu_context context = ((mt32_t *)device->data)->context;
         if (context) mt32_check("mt32emu_play_msg", mt32emu_play_msg(context, *(uint32_t*)val), MT32EMU_RC_OK);
 }
 
-void mt32_sysex(midi_device_t *device, uint8_t* data, unsigned int len)
+void mt32_sysex(uint8_t* data, unsigned int len)
 {
-	mt32emu_context context = ((mt32_t *)device->data)->context;
         if (context) mt32_check("mt32emu_play_sysex", mt32emu_play_sysex(context, data, len), MT32EMU_RC_OK);
 }
 
-static mt32emu_return_code mt32emu_add_rom_file_ex(mt32emu_context context, wchar_t *s)
+void* mt32emu_init(wchar_t *control_rom, wchar_t *pcm_rom)
-{
-	char fn[512];
-	wcstombs(fn, s, (wcslen(s) << 1) + 2);
-	return mt32emu_add_rom_file(context, fn);
-}
-
-static void* mt32emu_init(wchar_t* control_rom, wchar_t* pcm_rom)
 {
         wchar_t s[512];
+        char fn[512];
+        context = mt32emu_create_context(handler, NULL);
+        if (!rom_getfile(control_rom, s, 512)) return 0;
+	wcstombs(fn, s, (wcslen(s) << 1) + 2);
+        if (!mt32_check("mt32emu_add_rom_file", mt32emu_add_rom_file(context, fn), MT32EMU_RC_ADDED_CONTROL_ROM)) return 0;
+        if (!rom_getfile(pcm_rom, s, 512)) return 0;
+	wcstombs(fn, s, (wcslen(s) << 1) + 2);
+        if (!mt32_check("mt32emu_add_rom_file", mt32emu_add_rom_file(context, fn), MT32EMU_RC_ADDED_PCM_ROM)) return 0;
 
-        mt32_t* data = malloc(sizeof(mt32_t));
+        if (!mt32_check("mt32emu_open_synth", mt32emu_open_synth(context), MT32EMU_RC_OK)) return 0;
-        memset(data, 0, sizeof(mt32_t));
-        mt32emu_context context = mt32emu_create_context(handler, data);
 
-	if (
+        event = thread_create_event();
-	        !rom_getfile(control_rom, s, 512) ||
+        thread_h = thread_create(mt32_thread, 0);
-	        !mt32_check("mt32emu_add_rom_file", mt32emu_add_rom_file_ex(context, s), MT32EMU_RC_ADDED_CONTROL_ROM) ||
+        samplerate = mt32emu_get_actual_stereo_output_samplerate(context);
-	        !rom_getfile(pcm_rom, s, 512) ||
+        buf_size = samplerate/RENDER_RATE*2;
-		!mt32_check("mt32emu_add_rom_file", mt32emu_add_rom_file_ex(context, s), MT32EMU_RC_ADDED_PCM_ROM) ||
-		!mt32_check("mt32emu_open_synth", mt32emu_open_synth(context), MT32EMU_RC_OK))
-	{
-		free(data);
-		return 0;
-	}
-
-        data->samplerate = mt32emu_get_actual_stereo_output_samplerate(context);
 	if (sound_is_float)
 	{
-	        data->buf_size = data->samplerate/RENDER_RATE*(sizeof(float) << 1);
+	        buffer = malloc(buf_size * sizeof(float));
-	        data->buffer = malloc(data->buf_size);
+		buffer_int16 = NULL;
-		data->buffer_int16 = NULL;
 	}
 	else
 	{
-	        data->buf_size = data->samplerate/RENDER_RATE*(sizeof(int16_t) << 1);
+	        buffer = NULL;
-	        data->buffer = NULL;
+		buffer_int16 = malloc(buf_size * sizeof(int16_t));
-		data->buffer_int16 = malloc(data->buf_size);
 	}
-        data->event = thread_create_event();
-        data->thread_h = thread_create(mt32_thread, data);
-        data->status_show_instruments = device_get_config_int("status_show_instruments");
 
         mt32emu_set_output_gain(context, device_get_config_int("output_gain")/100.0f);
         mt32emu_set_reverb_enabled(context, device_get_config_int("reverb"));
@@ -222,12 +184,9 @@ static void* mt32emu_init(wchar_t* control_rom, wchar_t* pcm_rom)
         pclog("mt32 reverb: %d\n", mt32emu_is_reverb_enabled(context));
         pclog("mt32 reversed stereo: %d\n", mt32emu_is_reversed_stereo_enabled(context));
 
-        al_set_midi(data->samplerate, data->buf_size);
+        al_set_midi(samplerate, buf_size);
 
-        pclog("mt32 (Munt %s) initialized, samplerate %d, buf_size %d\n", mt32emu_get_library_version_string(), data->samplerate, data->buf_size);
+        pclog("mt32 (Munt %s) initialized, samplerate %d, buf_size %d\n", mt32emu_get_library_version_string(), samplerate, buf_size);
-
-	data->context = context;
-	data->message[0] = 0;
 
         midi_device_t* dev = malloc(sizeof(midi_device_t));
         memset(dev, 0, sizeof(midi_device_t));
@@ -235,96 +194,55 @@ static void* mt32emu_init(wchar_t* control_rom, wchar_t* pcm_rom)
         dev->play_msg = mt32_msg;
         dev->play_sysex = mt32_sysex;
         dev->poll = mt32_poll;
-        dev->data = data;
 
         midi_init(dev);
 
         return dev;
 }
 
-void* mt32_init()
+void *mt32_init()
 {
-        midi_device_t* dev = mt32emu_init(L"roms/mt32/mt32_control.rom", L"roms/mt32/mt32_pcm.rom");
+	return mt32emu_init(L"roms/mt32/mt32_control.rom", L"roms/mt32/mt32_pcm.rom");
-        if (dev)
-                strcpy(((mt32_t*)dev->data)->model_name, "MT-32");
-        return dev;
 }
 
-void* cm32l_init()
+void *cm32l_init()
 {
-        midi_device_t* dev = mt32emu_init(L"roms/cm32l/cm32l_control.rom", L"roms/cm32l/cm32l_pcm.rom");
+	return mt32emu_init(L"roms/cm32l/cm32l_control.rom", L"roms/cm32l/cm32l_pcm.rom");
-        if (dev)
-                strcpy(((mt32_t*)dev->data)->model_name, "CM-32L");
-        return dev;
 }
 
 void mt32_close(void* p)
 {
         if (!p) return;
 
-        midi_device_t* device = (midi_device_t*)p;
+        if (thread_h)
+                thread_kill(thread_h);
+        if (event)
+                thread_destroy_event(event);
+        event = NULL;
+        thread_h = NULL;
 
-        mt32_t* data = (mt32_t*)device->data;
+        if (context)
-
-        if (data->thread_h)
-                thread_kill(data->thread_h);
-        if (data->event)
-                thread_destroy_event(data->event);
-
-        if (data->context)
         {
-                mt32emu_close_synth(data->context);
+                mt32emu_close_synth(context);
-                mt32emu_free_context(data->context);
+                mt32emu_free_context(context);
         }
+        context = NULL;
 
-        if (data->buffer)
+        if (buffer)
-                free(data->buffer);
+                free(buffer);
+        buffer = NULL;
 
-        if (data->buffer_int16)
+        if (buffer_int16)
-                free(data->buffer_int16);
+                free(buffer_int16);
+        buffer_int16 = NULL;
 
         midi_close();
 
-	free(data);
         free((midi_device_t*)p);
 
         pclog("mt32 closed\n");
 }
 
-void mt32_add_status_info(char *s, int max_len, void *p)
-{
-        int i;
-        char temps[MT32EMU_SYSEX_BUFFER_SIZE];
-        midi_device_t* dev = (midi_device_t*)p;
-        mt32_t* data = (mt32_t*)dev->data;
-        mt32emu_context context = data->context;
-        if (strlen(data->message))
-        {
-                sprintf(temps, "%s message: %s\n", data->model_name, data->message);
-                strncat(s, temps, max_len);
-        }
-        if (mt32emu_is_active(context))
-        {
-                sprintf(temps, "%s playback frequency: %iHz\n", data->model_name, data->samplerate);
-                strncat(s, temps, max_len);
-                if (data->status_show_instruments)
-                {
-                        for (i = 0; i < 8; ++i)
-                        {
-                                const char* patch_name = mt32emu_get_patch_name(context, i);
-                                sprintf(temps, "%s inst. %d: %s\n", data->model_name, i+1, patch_name);
-                                strncat(s, temps, max_len);
-                        }
-                }
-                strncat(s, "\n", max_len);
-        }
-        else
-        {
-                strncat(s, data->model_name, max_len);
-                strncat(s, " playback stopped\n\n", max_len);
-        }
-}
-
 static device_config_t mt32_config[] =
 {
         {
@@ -403,12 +321,6 @@ static device_config_t mt32_config[] =
                 .type = CONFIG_BINARY,
                 .default_int = 0
         },
-        {
-                .name = "status_show_instruments",
-                .description = "(Status) Show instruments",
-                .type = CONFIG_BINARY,
-                .default_int = 0
-        },
         {
                 .type = -1
         }
@@ -423,7 +335,7 @@ device_t mt32_device =
         mt32_available,
         NULL,
         NULL,
-        mt32_add_status_info,
+        NULL,
         mt32_config
 };
 
@@ -436,6 +348,6 @@ device_t cm32l_device =
         cm32l_available,
         NULL,
         NULL,
-        mt32_add_status_info,
+        NULL,
         mt32_config
 };

src/SOUND/midi_system.c

@@ -3,9 +3,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include "../device.h"
+#include "../WIN/plat_midi.h"
 #include "midi_system.h"
 #include "midi.h"
-#include "../WIN/plat_midi.h"
 
 void* system_midi_init()
 {
@@ -15,7 +15,8 @@ void* system_midi_init()
         dev->play_msg = plat_midi_play_msg;
         dev->play_sysex = plat_midi_play_sysex;
         dev->write = plat_midi_write;
-	dev->data = plat_midi_init();
+
+        plat_midi_init();
 
         midi_init(dev);
 
@@ -24,9 +25,7 @@ void* system_midi_init()
 
 void system_midi_close(void* p)
 {
-	midi_device_t *dev = (midi_device_t *)p;
+        plat_midi_close();
-        plat_midi_close(dev->data);
-	free(dev);
 
         midi_close();
 }
@@ -36,11 +35,6 @@ int system_midi_available()
         return plat_midi_get_num_devs();
 }
 
-void system_midi_add_status_info(char *s, int max_len, void *p)
-{
-        plat_midi_add_status_info(s, max_len, (midi_device_t*)p);
-}
-
 static device_config_t system_midi_config[] =
 {
         {
@@ -63,6 +57,6 @@ device_t system_midi_device =
         system_midi_available,
         NULL,
         NULL,
-        system_midi_add_status_info,
+        NULL,
         system_midi_config
 };

src/WIN/plat_midi.h

@@ -1,8 +1,7 @@
-void* plat_midi_init();
+void plat_midi_init();
-void plat_midi_close(void* p);
+void plat_midi_close();
-void plat_midi_play_msg(struct midi_device_t* device, uint8_t* val);
+void plat_midi_play_msg(uint8_t* val);
-void plat_midi_play_sysex(struct midi_device_t* device, uint8_t* data, unsigned int len);
+void plat_midi_play_sysex(uint8_t* data, unsigned int len);
-int plat_midi_write(struct midi_device_t* device, uint8_t val);
+int plat_midi_write(uint8_t val);
 int plat_midi_get_num_devs();
 void plat_midi_get_dev_name(int num, char *s);
-void plat_midi_add_status_info(char *s, int max_len, struct midi_device_t* device);

src/WIN/win.c

@@ -42,7 +42,6 @@
 #include "../video/video.h"
 #include "../video/vid_ega.h"
 #include "../mouse.h"
-#include "../sound/midi.h"
 #include "../sound/sound.h"
 #include "../sound/snd_dbopl.h"
 #include "plat_keyboard.h"

src/WIN/win_deviceconfig.c

@@ -18,7 +18,6 @@
 #include "../ibm.h"
 #include "../config.h"
 #include "../device.h"
-#include "../sound/midi.h"
 #include "plat_midi.h"
 #define NO_UNICODE		/*FIXME: not Unicode? */
 #include "win.h"

src/WIN/win_midi.c

@@ -5,68 +5,70 @@
 #include "../SOUND/midi.h"
 #include "plat_midi.h"
 
-typedef struct plat_midi_t
+int midi_id = 0;
-{
+static HMIDIOUT midi_out_device = NULL;
-        int id;
-        char name[512];
-        HMIDIOUT midi_out_device;
-        HANDLE event;
-        MIDIHDR hdr;
-} plat_midi_t;
 
-void* plat_midi_init()
+HANDLE m_event;
-{
-        plat_midi_t* data = malloc(sizeof(plat_midi_t));
-        memset(data, 0, sizeof(plat_midi_t));
 
+static uint8_t midi_rt_buf[1024];
+static uint8_t midi_cmd_buf[1024];
+static int midi_cmd_pos = 0;
+static int midi_cmd_len = 0;
+static uint8_t midi_status = 0;
+static unsigned int midi_sysex_start = 0;
+static unsigned int midi_sysex_delay = 0;
+
+void plat_midi_init()
+{
 	/* This is for compatibility with old configuration files. */
-	data->id = config_get_int("Sound", "midi_host_device", -1);
+	midi_id = config_get_int("Sound", "midi_host_device", -1);
-	if (data->id == -1)
+	if (midi_id == -1)
 	{
-		data->id = config_get_int(SYSTEM_MIDI_NAME, "midi", 0);
+		midi_id = config_get_int(SYSTEM_MIDI_NAME, "midi", 0);
 	}
 	else
 	{
 		config_delete_var("Sound", "midi_host_device");
-		config_set_int(SYSTEM_MIDI_NAME, "midi", data->id);
+		config_set_int(SYSTEM_MIDI_NAME, "midi", midi_id);
 	}
 
         MMRESULT hr = MMSYSERR_NOERROR;
 
-	data->event = CreateEvent(NULL, TRUE, TRUE, NULL);
+	memset(midi_rt_buf, 0, sizeof(midi_rt_buf));
+	memset(midi_cmd_buf, 0, sizeof(midi_cmd_buf));
 
-        hr = midiOutOpen(&data->midi_out_device, data->id, (DWORD) data->event,
+	midi_cmd_pos = midi_cmd_len = 0;
+	midi_status = 0;
+
+	midi_sysex_start = midi_sysex_delay = 0;
+
+	m_event = CreateEvent(NULL, TRUE, TRUE, NULL);
+
+        hr = midiOutOpen(&midi_out_device, midi_id, (DWORD) m_event,
 		   0, CALLBACK_EVENT);
         if (hr != MMSYSERR_NOERROR) {
                 printf("midiOutOpen error - %08X\n",hr);
-                data->id = 0;
+                midi_id = 0;
-                hr = midiOutOpen(&data->midi_out_device, data->id, (DWORD) data->event,
+                hr = midiOutOpen(&midi_out_device, midi_id, (DWORD) m_event,
         		   0, CALLBACK_EVENT);
                 if (hr != MMSYSERR_NOERROR) {
                         printf("midiOutOpen error - %08X\n",hr);
-                        free(data);
+                        return;
-                        return 0;
                 }
         }
 
-        plat_midi_get_dev_name(data->id, data->name);
+        midiOutReset(midi_out_device);
-
-        midiOutReset(data->midi_out_device);
-
-        return data;
 }
 
-void plat_midi_close(void* p)
+void plat_midi_close()
 {
-        plat_midi_t* data = (plat_midi_t*)p;
+        if (midi_out_device != NULL)
-        if (data->midi_out_device != NULL)
         {
-                midiOutReset(data->midi_out_device);
+                midiOutReset(midi_out_device);
-                midiOutClose(data->midi_out_device);
+                midiOutClose(midi_out_device);
                 /* midi_out_device = NULL; */
-		CloseHandle(data->event);
+		CloseHandle(m_event);
         }
-        free(data);
 }
 
 int plat_midi_get_num_devs()
@@ -81,50 +83,43 @@ void plat_midi_get_dev_name(int num, char *s)
         strcpy(s, caps.szPname);
 }
 
-void plat_midi_play_msg(midi_device_t* device, uint8_t *msg)
+void plat_midi_play_msg(uint8_t *msg)
 {
-        plat_midi_t* data = (plat_midi_t*)device->data;
+	midiOutShortMsg(midi_out_device, *(uint32_t *) msg);
-	midiOutShortMsg(data->midi_out_device, *(uint32_t *) msg);
 }
 
-void plat_midi_play_sysex(midi_device_t* device, uint8_t *sysex, unsigned int len)
+MIDIHDR m_hdr;
+
+void plat_midi_play_sysex(uint8_t *sysex, unsigned int len)
 {
-        plat_midi_t* data = (plat_midi_t*)device->data;
 	MMRESULT result;
 
-	if (WaitForSingleObject(data->event, 2000) == WAIT_TIMEOUT)
+	if (WaitForSingleObject(m_event, 2000) == WAIT_TIMEOUT)
 	{
 		pclog("Can't send MIDI message\n");
 		return;
 	}
 
-	midiOutUnprepareHeader(data->midi_out_device, &data->hdr, sizeof(data->hdr));
+	midiOutUnprepareHeader(midi_out_device, &m_hdr, sizeof(m_hdr));
 
-	data->hdr.lpData = (char *) sysex;
+	m_hdr.lpData = (char *) sysex;
-	data->hdr.dwBufferLength = len;
+	m_hdr.dwBufferLength = len;
-	data->hdr.dwBytesRecorded = len;
+	m_hdr.dwBytesRecorded = len;
-	data->hdr.dwUser = 0;
+	m_hdr.dwUser = 0;
 
-	result = midiOutPrepareHeader(data->midi_out_device, &data->hdr, sizeof(data->hdr));
+	result = midiOutPrepareHeader(midi_out_device, &m_hdr, sizeof(m_hdr));
 
 	if (result != MMSYSERR_NOERROR)  return;
-	ResetEvent(data->event);
+	ResetEvent(m_event);
-	result = midiOutLongMsg(data->midi_out_device, &data->hdr, sizeof(data->hdr));
+	result = midiOutLongMsg(midi_out_device, &m_hdr, sizeof(m_hdr));
 	if (result != MMSYSERR_NOERROR)
 	{
-		SetEvent(data->event);
+		SetEvent(m_event);
 		return;
 	}
 }
 
-int plat_midi_write(midi_device_t* device, uint8_t val)
+int plat_midi_write(uint8_t val)
 {
 	return 0;
 }
-
-void plat_midi_add_status_info(char *s, int max_len, struct midi_device_t* device)
-{
-        char temps[512];
-        sprintf(temps, "MIDI out device: %s\n\n", ((plat_midi_t*)device->data)->name);
-        strncat(s, temps, max_len);
-}

src/config.c

@@ -28,8 +28,8 @@
 #include "nvr.h"
 #include "scsi.h"
 #include "win/plat_joystick.h"
-#include "sound/midi.h"
 #include "win/plat_midi.h"
+#include "sound/midi.h"
 #include "sound/snd_dbopl.h"
 #include "sound/snd_mpu401.h"
 #include "sound/snd_opl.h"