claunia/86Box
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
OBattler
2017-07-15 20:07:38 +02:00
parent 7c54006355
commit cc63eafce0
9 changed files with 145 additions and 248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/SOUND/midi.c
View File

@@ -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;

9
src/SOUND/midi.h
View File

@@ -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_msg)(struct midi_device_t* p, uint8_t *msg);
void (*poll)(struct midi_device_t* p);
int (*write)(struct midi_device_t* p, uint8_t val);
void* data;
void (*play_sysex)(uint8_t *sysex, unsigned int len);
void (*play_msg)(uint8_t *msg);
void (*poll)();
int (*write)(uint8_t val);
} midi_device_t;
void midi_init(midi_device_t* device);

236
src/SOUND/midi_mt32.c
View File

@@ -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;
data->midi_pos++;
if (data->midi_pos == 48000/RENDER_RATE)
midi_pos++;
if (midi_pos == 48000/RENDER_RATE)
{
data->midi_pos = 0;
thread_set_event(data->event);
midi_pos = 0;
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);
mt32_stream(data->context, data->buffer, data->buf_size / (sizeof(float) << 1));
memset(buffer, 0, buf_size * sizeof(float));
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);
mt32_stream_int16(data->context, data->buffer_int16, data->buf_size / (sizeof(int16_t) << 1));
memset(buffer_int16, 0, buf_size * sizeof(int16_t));
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)
{
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)
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));
memset(data, 0, sizeof(mt32_t));
mt32emu_context context = mt32emu_create_context(handler, data);
if (!mt32_check("mt32emu_open_synth", mt32emu_open_synth(context), MT32EMU_RC_OK)) return 0;
if (
!rom_getfile(control_rom, s, 512) ||
!mt32_check("mt32emu_add_rom_file", mt32emu_add_rom_file_ex(context, s), MT32EMU_RC_ADDED_CONTROL_ROM) ||
!rom_getfile(pcm_rom, s, 512) ||
!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);
event = thread_create_event();
thread_h = thread_create(mt32_thread, 0);
samplerate = mt32emu_get_actual_stereo_output_samplerate(context);
buf_size = samplerate/RENDER_RATE*2;
if (sound_is_float)
{
data->buf_size = data->samplerate/RENDER_RATE*(sizeof(float) << 1);
data->buffer = malloc(data->buf_size);
data->buffer_int16 = NULL;
buffer = malloc(buf_size * sizeof(float));
buffer_int16 = NULL;
}
else
{
data->buf_size = data->samplerate/RENDER_RATE*(sizeof(int16_t) << 1);
data->buffer = NULL;
data->buffer_int16 = malloc(data->buf_size);
buffer = NULL;
buffer_int16 = malloc(buf_size * sizeof(int16_t));
}
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);
data->context = context;
data->message[0] = 0;
pclog("mt32 (Munt %s) initialized, samplerate %d, buf_size %d\n", mt32emu_get_library_version_string(), samplerate, buf_size);
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");
if (dev)
strcpy(((mt32_t*)dev->data)->model_name, "MT-32");
return dev;
return mt32emu_init(L"roms/mt32/mt32_control.rom", L"roms/mt32/mt32_pcm.rom");
}
void* cm32l_init()
void *cm32l_init()
{
midi_device_t* dev = 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;
return mt32emu_init(L"roms/cm32l/cm32l_control.rom", L"roms/cm32l/cm32l_pcm.rom");
}
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 (data->thread_h)
thread_kill(data->thread_h);
if (data->event)
thread_destroy_event(data->event);
if (data->context)
if (context)
{
mt32emu_close_synth(data->context);
mt32emu_free_context(data->context);
mt32emu_close_synth(context);
mt32emu_free_context(context);
}
context = NULL;
if (data->buffer)
free(data->buffer);
if (buffer)
free(buffer);
buffer = NULL;
if (data->buffer_int16)
free(data->buffer_int16);
if (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
};

16
src/SOUND/midi_system.c
View File

@@ -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(dev->data);
free(dev);
plat_midi_close();
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
};

11
src/WIN/plat_midi.h
View File

@@ -1,8 +1,7 @@
void* plat_midi_init();
void plat_midi_close(void* p);
void plat_midi_play_msg(struct midi_device_t* device, uint8_t* val);
void plat_midi_play_sysex(struct midi_device_t* device, uint8_t* data, unsigned int len);
int plat_midi_write(struct midi_device_t* device, uint8_t val);
void plat_midi_init();
void plat_midi_close();
void plat_midi_play_msg(uint8_t* val);
void plat_midi_play_sysex(uint8_t* data, unsigned int len);
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);

1
src/WIN/win.c
View File

@@ -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"

1
src/WIN/win_deviceconfig.c
View File

@@ -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"

109
src/WIN/win_midi.c
View File

@@ -5,68 +5,70 @@
#include "../SOUND/midi.h"
#include "plat_midi.h"
typedef struct plat_midi_t
{
int id;
char name[512];
HMIDIOUT midi_out_device;
HANDLE event;
MIDIHDR hdr;
} plat_midi_t;
int midi_id = 0;
static HMIDIOUT midi_out_device = NULL;
void* plat_midi_init()
{
plat_midi_t* data = malloc(sizeof(plat_midi_t));
memset(data, 0, sizeof(plat_midi_t));
HANDLE m_event;
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);
if (data->id == -1)
midi_id = config_get_int("Sound", "midi_host_device", -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;
hr = midiOutOpen(&data->midi_out_device, data->id, (DWORD) data->event,
midi_id = 0;
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 0;
return;
}
}
plat_midi_get_dev_name(data->id, data->name);
midiOutReset(data->midi_out_device);
return data;
midiOutReset(midi_out_device);
}
void plat_midi_close(void* p)
void plat_midi_close()
{
plat_midi_t* data = (plat_midi_t*)p;
if (data->midi_out_device != NULL)
if (midi_out_device != NULL)
{
midiOutReset(data->midi_out_device);
midiOutClose(data->midi_out_device);
midiOutReset(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(data->midi_out_device, *(uint32_t *) msg);
midiOutShortMsg(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;
data->hdr.dwBufferLength = len;
data->hdr.dwBytesRecorded = len;
data->hdr.dwUser = 0;
m_hdr.lpData = (char *) sysex;
m_hdr.dwBufferLength = len;
m_hdr.dwBytesRecorded = len;
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);
result = midiOutLongMsg(data->midi_out_device, &data->hdr, sizeof(data->hdr));
ResetEvent(m_event);
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);
}

2
src/config.c
View File

@@ -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"