Previous

199869 Revisions

Next

r34757 Saturday 31st January, 2015 at 01:39:40 UTC by Couriersud
Converted midi into a module. (nw)

[src/emu/imagedev]	midiin.c midiout.c
[src/osd]	osdcore.h osdepend.h
[src/osd/modules/lib]	osdobj_common.c osdobj_common.h
[src/osd/modules/midi]	midi_module.h* none.c portmidi.c
[src/osd/modules/sound]	sdl_sound.c
[src/osd/sdl]	sdl.mak
[src/osd/windows]	windows.mak

trunk/src/emu/imagedev/midiin.c

r243268	r243269
8	8
9	9	#include "emu.h"
10	10	#include "midiin.h"
	11	#include "osdepend.h"
11	12
12	13	/***************************************************************************
13	14	IMPLEMENTATION
r243268	r243269
77	78	return;
78	79	}
79	80
80		while (osd_poll_midi_channel(m_midi))
	81	while (m_midi->poll())
81	82	{
82		bytesRead = osd_read_midi_channel(m_midi, buf);
	83	bytesRead = m_midi->read(buf);
83	84
84	85	if (bytesRead > 0)
85	86	{
r243268	r243269
97	98
98	99	bool midiin_device::call_load(void)
99	100	{
100		m_midi = osd_open_midi_input(filename());
	101	m_midi = machine().osd().create_midi_device();
101	102
102		if (m_midi == NULL)
	103	if (!m_midi->open_input(filename()))
103	104	{
	105	global_free(m_midi);
	106	m_midi = NULL;
104	107	return IMAGE_INIT_FAIL;
105	108	}
106	109
r243268	r243269
117	120	{
118	121	if (m_midi)
119	122	{
120		osd_close_midi_channel(m_midi);
	123	m_midi->close();
	124	global_free(m_midi);
121	125	}
122	126	m_timer->enable(false);
123	127	m_midi = NULL;

trunk/src/emu/imagedev/midiout.c

r243268	r243269
7	7	*********************************************************************/
8	8
9	9	#include "emu.h"
	10	#include "osdepend.h"
10	11	#include "midiout.h"
11	12
12	13	/***************************************************************************
r243268	r243269
63	64
64	65	bool midiout_device::call_load(void)
65	66	{
66		m_midi = osd_open_midi_output(filename());
	67	m_midi = machine().osd().create_midi_device();
67	68
68		if (m_midi == NULL)
	69	if (!m_midi->open_output(filename()))
69	70	{
	71	global_free(m_midi);
	72	m_midi = NULL;
70	73	return IMAGE_INIT_FAIL;
71	74	}
72	75
r243268	r243269
81	84	{
82	85	if (m_midi)
83	86	{
84		osd_close_midi_channel(m_midi);
	87	m_midi->close();
	88	global_free(m_midi);
	89	m_midi = NULL;
85	90	}
86	91	}
87	92
r243268	r243269
92	97
93	98	if (m_midi)
94	99	{
95		osd_write_midi_channel(m_midi, data);
	100	m_midi->write(data);
96	101	}
97	102	}

trunk/src/osd/modules/lib/osdobj_common.c

r243268	r243269
131	131	REGISTER_MODULE(m_mod_man, NETDEV_TAPTUN);
132	132	REGISTER_MODULE(m_mod_man, NETDEV_PCAP);
133	133
	134	REGISTER_MODULE(m_mod_man, MIDI_PM);
	135	REGISTER_MODULE(m_mod_man, MIDI_NONE);
134	136
135	137	// after initialization we know which modules are supported
136	138
r243268	r243269
148	150	dnames.append(names[i]);
149	151	update_option(OSD_SOUND_PROVIDER, dnames);
150	152
	153	#if 0
	154	// Register midi options and update options
	155	m_mod_man.get_module_names(OSD_DEBUG_PROVIDER, 20, &num, names);
	156	dnames.reset();
	157	for (int i = 0; i < num; i++)
	158	dnames.append(names[i]);
	159	update_option(OSD_DEBUG_PROVIDER, dnames);
	160	#endif
	161
151	162	// Register debugger options and update options
152	163	m_mod_man.get_module_names(OSD_DEBUG_PROVIDER, 20, &num, names);
153	164	dnames.reset();
r243268	r243269
416	427	}
417	428	else if (strcmp(command, OSDCOMMAND_LIST_MIDI_DEVICES) == 0)
418	429	{
419		osd_list_midi_devices();
	430	osd_module *om = select_module_options(options(), OSD_MIDI_PROVIDER);
	431	midi_module *pm = select_module_options<midi_module *>(options(), OSD_MIDI_PROVIDER);
	432
	433	if (om->probe())
	434	{
	435	om->init();
	436	pm->list_midi_devices();
	437	om->exit();
	438	}
420	439	return true;
421	440	}
422	441
r243268	r243269
441	460	machine().add_notifier(MACHINE_NOTIFY_RESUME, machine_notify_delegate(FUNC(osd_common_t::input_resume), this));
442	461
443	462	output_init();
444		midi_init();
445	463
446	464	m_font_module = select_module_options<font_module *>(options(), OSD_FONT_PROVIDER);
447	465
r243268	r243269
453	471
454	472	select_module_options<netdev_module *>(options(), OSD_NETDEV_PROVIDER);
455	473
	474	m_midi = select_module_options<midi_module *>(options(), OSD_MIDI_PROVIDER);
	475
456	476	m_mod_man.init();
457	477
458	478	}
r243268	r243269
499	519	video_exit();
500	520	input_exit();
501	521	output_exit();
502		midi_exit();
503	522	}
504	523
505	524	void osd_common_t::video_exit()
r243268	r243269
530	549	//m_video_options.add(name, type, false);
531	550	m_video_names.append(core_strdup(name));
532	551	}
533
534		bool osd_common_t::midi_init()
535		{
536		// this should be done on the OS_level
537		return osd_midi_init();
538		}
539
540		void osd_common_t::midi_exit()
541		{
542		osd_midi_exit();
543		}

trunk/src/osd/modules/lib/osdobj_common.h

r243268	r243269
19	19	#include "modules/sound/sound_module.h"
20	20	#include "modules/debugger/debug_module.h"
21	21	#include "modules/netdev/netdev_module.h"
	22	#include "modules/midi/midi_module.h"
22	23	#include "cliopts.h"
23	24
24	25	//============================================================
r243268	r243269
148	149
149	150	osd_font *font_alloc() { return m_font_module->font_alloc(); }
150	151
	152	osd_midi_device *create_midi_device() { return m_midi->create_midi_device(); }
	153
151	154	// FIXME: everything below seems to be osd specific and not part of
152	155	//        this INTERFACE but part of the osd IMPLEMENTATION
153	156
r243268	r243269
165	168
166	169	virtual void input_resume();
167	170	virtual bool output_init();
168		virtual bool midi_init();
169	171
170	172	virtual void exit_subsystems();
171	173	virtual void video_exit();
172	174	virtual void window_exit();
173	175	virtual void input_exit();
174	176	virtual void output_exit();
175		virtual void midi_exit();
176	177
177	178	virtual void osd_exit();
178	179
r243268	r243269
216	217	protected:
217	218	sound_module* m_sound;
218	219	debug_module* m_debugger;
	220	midi_module* m_midi;
219	221	private:
220	222	//tagmap_t<osd_video_type>  m_video_options;
221	223	dynamic_array<const char *> m_video_names;

trunk/src/osd/modules/midi/midi_module.h

r0	r243269
	1	/*
	2	* midi_module.h
	3	*
	4	*/
	5
	6	#ifndef MIDI_MODULE_H_
	7	#define MIDI_MODULE_H_
	8
	9	#include "osdepend.h"
	10	#include "modules/osdmodule.h"
	11
	12	//============================================================
	13	//  CONSTANTS
	14	//============================================================
	15
	16	#define OSD_MIDI_PROVIDER   "midiprovider"
	17
	18	class midi_module
	19	{
	20	public:
	21	virtual ~midi_module() { }
	22	// specific routines
	23
	24	virtual osd_midi_device *create_midi_device() = 0;
	25	// FIXME: should return a list of strings ...
	26	virtual void list_midi_devices(void) = 0;
	27	};
	28
	29
	30	#endif /* MIDI_MODULE_H_ */

trunk/src/osd/modules/midi/none.c

r243268	r243269
7	7	*******************************************************************c********/
8	8
9	9	#include "osdcore.h"
	10	#include "corealloc.h"
	11	#include "modules/osdmodule.h"
	12	#include "midi_module.h"
10	13
11		struct osd_midi_device
	14	class none_module : public osd_module, public midi_module
12	15	{
	16	public:
	17
	18	none_module()
	19	: osd_module(OSD_MIDI_PROVIDER, "pm"), midi_module()
	20	{
	21	}
	22	virtual ~none_module() { }
	23
	24	virtual int init();
	25	virtual void exit();
	26
	27	osd_midi_device *create_midi_device();
	28	void list_midi_devices(void);
	29	};
	30
	31
	32	class osd_midi_device_none : public osd_midi_device
	33	{
	34	public:
	35	virtual ~osd_midi_device_none() { }
	36	virtual bool open_input(const char *devname);
	37	virtual bool open_output(const char *devname);
	38	virtual void close();
	39	virtual bool poll();
	40	virtual int read(UINT8 *pOut);
	41	virtual void write(UINT8 data);
	42
	43	private:
13	44	int dummy;
14	45	};
15	46
16		bool osd_midi_init()
	47	osd_midi_device *none_module::create_midi_device()
17	48	{
18		return true;
	49	return global_alloc(osd_midi_device_none());
19	50	}
20	51
21		void osd_midi_exit()
	52
	53	int none_module::init()
22	54	{
	55	return 0;
23	56	}
24	57
25		void osd_list_midi_devices(void)
	58	void none_module::exit()
26	59	{
	60	}
	61
	62	void none_module::list_midi_devices(void)
	63	{
27	64	osd_printf_warning("\nMIDI is not supported in this build\n");
28	65	}
29	66
30		osd_midi_device *osd_open_midi_input(const char *devname)
	67	bool osd_midi_device_none::open_input(const char *devname)
31	68	{
32		return NULL;
	69	return false;
33	70	}
34	71
35		osd_midi_device *osd_open_midi_output(const char *devname)
	72	bool osd_midi_device_none::open_output(const char *devname)
36	73	{
37		return NULL;
	74	return false;
38	75	}
39	76
40		void osd_close_midi_channel(osd_midi_device *dev)
	77	void osd_midi_device_none::close()
41	78	{
42	79	}
43	80
44		bool osd_poll_midi_channel(osd_midi_device *dev)
	81	bool osd_midi_device_none::poll()
45	82	{
46	83	return false;
47	84	}
48	85
49		int osd_read_midi_channel(osd_midi_device *dev, UINT8 *pOut)
	86	int osd_midi_device_none::read(UINT8 *pOut)
50	87	{
51	88	return 0;
52	89	}
53	90
54		void osd_write_midi_channel(osd_midi_device *dev, UINT8 data)
	91	void osd_midi_device_none::write(UINT8 data)
55	92	{
56	93	}
	94
	95	MODULE_DEFINITION(MIDI_NONE, none_module)

trunk/src/osd/modules/midi/portmidi.c

r243268	r243269
6	6
7	7	*******************************************************************c********/
8	8
	9	#ifndef NO_USE_MIDI
	10
9	11	#include "portmidi/pm_common/portmidi.h"
10	12	#include "osdcore.h"
	13	#include "corealloc.h"
	14	#include "modules/osdmodule.h"
	15	#include "midi_module.h"
11	16
	17	class pm_module : public osd_module, public midi_module
	18	{
	19	public:
	20
	21	pm_module()
	22	: osd_module(OSD_MIDI_PROVIDER, "pm"), midi_module()
	23	{
	24	}
	25	virtual ~pm_module() { }
	26
	27	virtual int init();
	28	virtual void exit();
	29
	30	osd_midi_device *create_midi_device();
	31	void list_midi_devices(void);
	32	};
	33
	34
12	35	static const int RX_EVENT_BUF_SIZE = 512;
13	36
14	37	#define MIDI_SYSEX  0xf0
15	38	#define MIDI_EOX    0xf7
16	39
17		struct osd_midi_device
	40	class osd_midi_device_pm : public osd_midi_device
18	41	{
	42	public:
	43	virtual ~osd_midi_device_pm() { }
	44	virtual bool open_input(const char *devname);
	45	virtual bool open_output(const char *devname);
	46	virtual void close();
	47	virtual bool poll();
	48	virtual int read(UINT8 *pOut);
	49	virtual void write(UINT8 data);
	50
	51	private:
19	52	PortMidiStream *pmStream;
20	53	PmEvent rx_evBuf[RX_EVENT_BUF_SIZE];
21	54	UINT8 xmit_in[4]; // Pm_Messages mean we can at most have 3 residue bytes
r243268	r243269
24	57	bool rx_sysex;
25	58	};
26	59
27		bool osd_midi_init()
	60	osd_midi_device *pm_module::create_midi_device()
28	61	{
	62	return global_alloc(osd_midi_device_pm());
	63	}
	64
	65
	66	int pm_module::init()
	67	{
29	68	Pm_Initialize();
30		return true;
	69	return 0;
31	70	}
32	71
33		void osd_midi_exit()
	72	void pm_module::exit()
34	73	{
35	74	Pm_Terminate();
36	75	}
37	76
38		void osd_list_midi_devices(void)
	77	void pm_module::list_midi_devices(void)
39	78	{
40	79	int num_devs = Pm_CountDevices();
41	80	const PmDeviceInfo *pmInfo;
r243268	r243269
71	110	}
72	111	}
73	112
74		osd_midi_device *osd_open_midi_input(const char *devname)
	113	bool osd_midi_device_pm::open_input(const char *devname)
75	114	{
76	115	int num_devs = Pm_CountDevices();
77	116	int found_dev = -1;
78	117	const PmDeviceInfo *pmInfo;
79	118	PortMidiStream *stm;
80		osd_midi_device *ret;
81	119
82	120	if (!strcmp("default", devname))
83	121	{
r243268	r243269
104	142	{
105	143	if (Pm_OpenInput(&stm, found_dev, NULL, RX_EVENT_BUF_SIZE, NULL, NULL) == pmNoError)
106	144	{
107		ret = (osd_midi_device *)osd_malloc(sizeof(osd_midi_device));
108		memset(ret, 0, sizeof(osd_midi_device));
109		ret->pmStream = stm;
110		return ret;
	145	pmStream = stm;
	146	return true;
111	147	}
112	148	else
113	149	{
114	150	printf("Couldn't open PM device\n");
115		return NULL;
	151	return false;
116	152	}
117	153	}
118	154	else
119	155	{
120		return NULL;
	156	return false;
121	157	}
122	158	}
123	159
124		osd_midi_device *osd_open_midi_output(const char *devname)
	160	bool osd_midi_device_pm::open_output(const char *devname)
125	161	{
126	162	int num_devs = Pm_CountDevices();
127	163	int found_dev = -1;
128	164	const PmDeviceInfo *pmInfo;
129	165	PortMidiStream *stm;
130		osd_midi_device *ret;
131	166
132	167	if (!strcmp("default", devname))
133	168	{
r243268	r243269
154	189	{
155	190	if (Pm_OpenOutput(&stm, found_dev, NULL, 100, NULL, NULL, 0) == pmNoError)
156	191	{
157		ret = (osd_midi_device *)osd_malloc(sizeof(osd_midi_device));
158		memset(ret, 0, sizeof(osd_midi_device));
159		ret->pmStream = stm;
160		return ret;
	192	pmStream = stm;
	193	return true;
161	194	}
162	195	else
163	196	{
164	197	printf("Couldn't open PM device\n");
165		return NULL;
	198	return false;
166	199	}
167	200	}
168	201	else
169	202	{
170		return NULL;
	203	return false;
171	204	}
172		return NULL;
	205	return false;
173	206	}
174	207
175		void osd_close_midi_channel(osd_midi_device *dev)
	208	void osd_midi_device_pm::close()
176	209	{
177		Pm_Close(dev->pmStream);
178		osd_free(dev);
	210	Pm_Close(pmStream);
179	211	}
180	212
181		bool osd_poll_midi_channel(osd_midi_device *dev)
	213	bool osd_midi_device_pm::poll()
182	214	{
183		PmError chk = Pm_Poll(dev->pmStream);
	215	PmError chk = Pm_Poll(pmStream);
184	216
185	217	return (chk == pmGotData) ? true : false;
186	218	}
187	219
188		int osd_read_midi_channel(osd_midi_device *dev, UINT8 *pOut)
	220	int osd_midi_device_pm::read(UINT8 *pOut)
189	221	{
190		int msgsRead = Pm_Read(dev->pmStream, dev->rx_evBuf, RX_EVENT_BUF_SIZE);
	222	int msgsRead = Pm_Read(pmStream, rx_evBuf, RX_EVENT_BUF_SIZE);
191	223	int bytesOut = 0;
192	224
193	225	if (msgsRead <= 0)
r243268	r243269
197	229
198	230	for (int msg = 0; msg < msgsRead; msg++)
199	231	{
200		UINT8 status = Pm_MessageStatus(dev->rx_evBuf[msg].message);
	232	UINT8 status = Pm_MessageStatus(rx_evBuf[msg].message);
201	233
202		if (dev->rx_sysex)
	234	if (rx_sysex)
203	235	{
204	236	if (status & 0x80)  // sys real-time imposing on us?
205	237	{
206	238	if ((status == 0xf2) || (status == 0xf3))
207	239	{
208	240	*pOut++ = status;
209		*pOut++ = Pm_MessageData1(dev->rx_evBuf[msg].message);
210		*pOut++ = Pm_MessageData2(dev->rx_evBuf[msg].message);
	241	*pOut++ = Pm_MessageData1(rx_evBuf[msg].message);
	242	*pOut++ = Pm_MessageData2(rx_evBuf[msg].message);
211	243	bytesOut += 3;
212	244	}
213	245	else
r243268	r243269
216	248	bytesOut++;
217	249	if (status == MIDI_EOX)
218	250	{
219		dev->rx_sysex = false;
	251	rx_sysex = false;
220	252	}
221	253	}
222	254	}
r243268	r243269
224	256	{
225	257	for (int i = 0; i < 4; i++)
226	258	{
227		UINT8 byte = dev->rx_evBuf[msg].message & 0xff;
	259	UINT8 byte = rx_evBuf[msg].message & 0xff;
228	260	*pOut++ = byte;
229	261	bytesOut++;
230	262	if (byte == MIDI_EOX)
231	263	{
232		dev->rx_sysex = false;
	264	rx_sysex = false;
233	265	break;
234	266	}
235		dev->rx_evBuf[msg].message >>= 8;
	267	rx_evBuf[msg].message >>= 8;
236	268	}
237	269	}
238	270	}
r243268	r243269
243	275	case 0xc:   // 2-byte messages
244	276	case 0xd:
245	277	*pOut++ = status;
246		*pOut++ = Pm_MessageData1(dev->rx_evBuf[msg].message);
	278	*pOut++ = Pm_MessageData1(rx_evBuf[msg].message);
247	279	bytesOut += 2;
248	280	break;
249	281
r243268	r243269
253	285	case 0: // System Exclusive
254	286	{
255	287	*pOut++ = status;   // this should be OK: the shortest legal sysex is F0 tt dd F7, I believe
256		*pOut++ = (dev->rx_evBuf[msg].message>>8) & 0xff;
257		*pOut++ = (dev->rx_evBuf[msg].message>>16) & 0xff;
258		UINT8 last = *pOut++ = (dev->rx_evBuf[msg].message>>24) & 0xff;
	288	*pOut++ = (rx_evBuf[msg].message>>8) & 0xff;
	289	*pOut++ = (rx_evBuf[msg].message>>16) & 0xff;
	290	UINT8 last = *pOut++ = (rx_evBuf[msg].message>>24) & 0xff;
259	291	bytesOut += 4;
260		dev->rx_sysex = (last != MIDI_EOX);
	292	rx_sysex = (last != MIDI_EOX);
261	293	break;
262	294	}
263	295
264	296	case 7: // End of System Exclusive
265	297	*pOut++ = status;
266	298	bytesOut += 1;
267		dev->rx_sysex = false;
	299	rx_sysex = false;
268	300	break;
269	301
270	302	case 2: // song pos
271	303	case 3: // song select
272	304	*pOut++ = status;
273		*pOut++ = Pm_MessageData1(dev->rx_evBuf[msg].message);
274		*pOut++ = Pm_MessageData2(dev->rx_evBuf[msg].message);
	305	*pOut++ = Pm_MessageData1(rx_evBuf[msg].message);
	306	*pOut++ = Pm_MessageData2(rx_evBuf[msg].message);
275	307	bytesOut += 3;
276	308	break;
277	309
r243268	r243269
282	314
283	315	default:
284	316	*pOut++ = status;
285		*pOut++ = Pm_MessageData1(dev->rx_evBuf[msg].message);
286		*pOut++ = Pm_MessageData2(dev->rx_evBuf[msg].message);
	317	*pOut++ = Pm_MessageData1(rx_evBuf[msg].message);
	318	*pOut++ = Pm_MessageData2(rx_evBuf[msg].message);
287	319	bytesOut += 3;
288	320	break;
289	321	}
r243268	r243269
293	325	return bytesOut;
294	326	}
295	327
296		void osd_write_midi_channel(osd_midi_device *dev, UINT8 data)
	328	void osd_midi_device_pm::write(UINT8 data)
297	329	{
298	330	int bytes_needed = 0;
299	331	PmEvent ev;
300	332	ev.timestamp = 0;   // use the current time
301	333
302		//  printf("write: %02x (%d)\n", data, dev->xmit_cnt);
	334	//  printf("write: %02x (%d)\n", data, xmit_cnt);
303	335
304	336	// reject data bytes when no valid status exists
305		if ((dev->last_status == 0) && !(data & 0x80))
	337	if ((last_status == 0) && !(data & 0x80))
306	338	{
307		dev->xmit_cnt = 0;
	339	xmit_cnt = 0;
308	340	return;
309	341	}
310	342
311		if (dev->xmit_cnt >= 4)
	343	if (xmit_cnt >= 4)
312	344	{
313	345	printf("MIDI out: packet assembly overflow, contact MAMEdev!\n");
314	346	return;
315	347	}
316	348
317	349	// handle sysex
318		if (dev->last_status == MIDI_SYSEX)
	350	if (last_status == MIDI_SYSEX)
319	351	{
320		//      printf("sysex: %02x (%d)\n", data, dev->xmit_cnt);
	352	//      printf("sysex: %02x (%d)\n", data, xmit_cnt);
321	353
322	354	// if we get a status that isn't sysex, assume it's system common
323	355	if ((data & 0x80) && (data != MIDI_EOX))
324	356	{
325	357	//          printf("common during sysex!\n");
326	358	ev.message = Pm_Message(data, 0, 0);
327		Pm_Write(dev->pmStream, &ev, 1);
	359	Pm_Write(pmStream, &ev, 1);
328	360	return;
329	361	}
330	362
331		dev->xmit_in[dev->xmit_cnt++] = data;
	363	xmit_in[xmit_cnt++] = data;
332	364
333	365	// if EOX or 4 bytes filled, transmit 4 bytes
334		if ((dev->xmit_cnt == 4) || (data == MIDI_EOX))
	366	if ((xmit_cnt == 4) || (data == MIDI_EOX))
335	367	{
336		ev.message = dev->xmit_in[0] | (dev->xmit_in[1]<<8) | (dev->xmit_in[2]<<16) | (dev->xmit_in[3]<<24);
337		Pm_Write(dev->pmStream, &ev, 1);
338		dev->xmit_in[0] = dev->xmit_in[1] = dev->xmit_in[2] = dev->xmit_in[3] = 0;
339		dev->xmit_cnt = 0;
	368	ev.message = xmit_in[0] | (xmit_in[1]<<8) | (xmit_in[2]<<16) | (xmit_in[3]<<24);
	369	Pm_Write(pmStream, &ev, 1);
	370	xmit_in[0] = xmit_in[1] = xmit_in[2] = xmit_in[3] = 0;
	371	xmit_cnt = 0;
340	372
341	373	//          printf("SysEx packet: %08x\n", ev.message);
342	374
343	375	// if this is EOX, kill the running status
344	376	if (data == MIDI_EOX)
345	377	{
346		dev->last_status = 0;
	378	last_status = 0;
347	379	}
348	380	}
349	381
r243268	r243269
351	383	}
352	384
353	385	// handle running status.  don't allow system real-time messages to be considered as running status.
354		if ((dev->xmit_cnt == 0) && (data & 0x80) && (data < 0xf8))
	386	if ((xmit_cnt == 0) && (data & 0x80) && (data < 0xf8))
355	387	{
356		dev->last_status = data;
	388	last_status = data;
357	389	}
358	390
359		if ((dev->xmit_cnt == 0) && !(data & 0x80))
	391	if ((xmit_cnt == 0) && !(data & 0x80))
360	392	{
361		dev->xmit_in[dev->xmit_cnt++] = dev->last_status;
362		dev->xmit_in[dev->xmit_cnt++] = data;
363		//      printf("\trunning status: [%d] = %02x, [%d] = %02x, last_status = %02x\n", dev->xmit_cnt-2, dev->last_status, dev->xmit_cnt-1, data, dev->last_status);
	393	xmit_in[xmit_cnt++] = last_status;
	394	xmit_in[xmit_cnt++] = data;
	395	//      printf("\trunning status: [%d] = %02x, [%d] = %02x, last_status = %02x\n", xmit_cnt-2, last_status, xmit_cnt-1, data, last_status);
364	396	}
365	397	else
366	398	{
367		dev->xmit_in[dev->xmit_cnt++] = data;
368		//      printf("\tNRS: [%d] = %02x\n", dev->xmit_cnt-1, data);
	399	xmit_in[xmit_cnt++] = data;
	400	//      printf("\tNRS: [%d] = %02x\n", xmit_cnt-1, data);
369	401	}
370	402
371		if ((dev->xmit_cnt == 1) && (dev->xmit_in[0] == MIDI_SYSEX))
	403	if ((xmit_cnt == 1) && (xmit_in[0] == MIDI_SYSEX))
372	404	{
373	405	//      printf("Start SysEx!\n");
374		dev->last_status = MIDI_SYSEX;
	406	last_status = MIDI_SYSEX;
375	407	return;
376	408	}
377	409
378	410	// are we there yet?
379		//  printf("status check: %02x\n", dev->xmit_in[0]);
380		switch ((dev->xmit_in[0]>>4) & 0xf)
	411	//  printf("status check: %02x\n", xmit_in[0]);
	412	switch ((xmit_in[0]>>4) & 0xf)
381	413	{
382	414	case 0xc:   // 2-byte messages
383	415	case 0xd:
r243268	r243269
385	417	break;
386	418
387	419	case 0xf:   // system common
388		switch (dev->xmit_in[0] & 0xf)
	420	switch (xmit_in[0] & 0xf)
389	421	{
390	422	case 0: // System Exclusive is handled above
391	423	break;
r243268	r243269
410	442	break;
411	443	}
412	444
413		if (dev->xmit_cnt == bytes_needed)
	445	if (xmit_cnt == bytes_needed)
414	446	{
415		ev.message = Pm_Message(dev->xmit_in[0], dev->xmit_in[1], dev->xmit_in[2]);
416		Pm_Write(dev->pmStream, &ev, 1);
417		dev->xmit_cnt = 0;
	447	ev.message = Pm_Message(xmit_in[0], xmit_in[1], xmit_in[2]);
	448	Pm_Write(pmStream, &ev, 1);
	449	xmit_cnt = 0;
418	450	}
419	451
420	452	}
	453	#else
	454	#include "modules/osdmodule.h"
	455	#include "netdev_module.h"
	456
	457	MODULE_NOT_SUPPORTED(pm_module, OSD_MIDI_PROVIDER, "pm")
	458	#endif
	459
	460
	461	MODULE_DEFINITION(MIDI_PM, pm_module)

trunk/src/osd/modules/sound/sdl_sound.c

r243268	r243269
12	12	#include "sound_module.h"
13	13	#include "modules/osdmodule.h"
14	14
15		#if (!defined(OSD_WINDOWS))
	15	#if (!defined(OSD_WINDOWS) || defined(USE_SDL_SOUND))
16	16
17	17	// standard sdl header
18	18	#include "../../sdl/sdlinc.h"

trunk/src/osd/osdcore.h

r243268	r243269
887	887	/***************************************************************************
888	888	MIDI I/O INTERFACES
889	889	***************************************************************************/
890		struct osd_midi_device;
891	890
892		bool osd_midi_init();
893		void osd_midi_exit();
894		void osd_list_midi_devices(void);
895		// free result with osd_close_midi_channel()
896		osd_midi_device *osd_open_midi_input(const char *devname);
897		// free result with osd_close_midi_channel()
898		osd_midi_device *osd_open_midi_output(const char *devname);
899		void osd_close_midi_channel(osd_midi_device *dev);
900		bool osd_poll_midi_channel(osd_midi_device *dev);
901		int osd_read_midi_channel(osd_midi_device *dev, UINT8 *pOut);
902		void osd_write_midi_channel(osd_midi_device *dev, UINT8 data);
	891	class osd_midi_device
	892	{
	893	public:
	894	virtual ~osd_midi_device() { }
	895	// free result with osd_close_midi_channel()
	896	virtual bool open_input(const char *devname) = 0;
	897	// free result with osd_close_midi_channel()
	898	virtual bool open_output(const char *devname) = 0;
	899	virtual void close() = 0;
	900	virtual bool poll() = 0;
	901	virtual int read(UINT8 *pOut) = 0;
	902	virtual void write(UINT8 data) = 0;
	903	};
903	904
904
	905	//FIXME: really needed here?
905	906	void osd_list_network_adapters(void);
906	907
907	908	/***************************************************************************

trunk/src/osd/osdepend.h

r243268	r243269
71	71	// command option overrides
72	72	virtual bool execute_command(const char *command) = 0;
73	73
	74	// midi interface
	75	virtual osd_midi_device *create_midi_device() = 0;
	76
74	77	};
75	78
76	79	#endif  /* __OSDEPEND_H__ */

trunk/src/osd/sdl/sdl.mak

r243268	r243269
210	210	BASE_TARGETOS = unix
211	211	SYNC_IMPLEMENTATION = tc
212	212	SDL_NETWORK = taptun
213		#SDL_NETWORK = pcap
214	213
215	214	ifndef NO_USE_MIDI
216	215	INCPATH += `pkg-config --cflags alsa`
r243268	r243269
448	447	$(OSDOBJ)/modules/font/font_none.o \
449	448	$(OSDOBJ)/modules/netdev/taptun.o \
450	449	$(OSDOBJ)/modules/netdev/pcap.o \
	450	$(OSDOBJ)/modules/midi/portmidi.o \
	451	$(OSDOBJ)/modules/midi/none.o \
451	452
452	453	ifdef NO_USE_MIDI
453		OSDOBJS += $(OSDOBJ)/modules/midi/none.o
	454	DEFS += -DNO_USE_MIDI
454	455	else
455		OSDOBJS += $(OSDOBJ)/modules/midi/portmidi.o
456	456	endif
457	457
458	458	# Add SDL2.0 support

trunk/src/osd/windows/windows.mak

r243268	r243269
383	383	$(WINOBJ)/winmenu.o \
384	384	$(WINOBJ)/winmain.o \
385	385	$(OSDOBJ)/modules/midi/portmidi.o \
	386	$(OSDOBJ)/modules/midi/none.o \
386	387	$(OSDOBJ)/modules/lib/osdobj_common.o  \
387	388	$(OSDOBJ)/modules/font/font_sdl.o \
388	389	$(OSDOBJ)/modules/font/font_windows.o \
r243268	r243269
392	393	$(OSDOBJ)/modules/netdev/taptun.o \
393	394
394	395	ifdef USE_SDL
395		OSDOBJS += \
396		$(OSDOBJ)/modules/sound/sdl_sound.o
	396	DEFS += -DUSE_SDL_SOUND
397	397	endif
398	398
399	399	ifndef DONT_USE_NETWORK

https://github.com/mamedev/mame/commit/8c3b8d43c7064df763a26b383eabf2972eefc788

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team