MIDI file playback using the MPU-401? \ VOGONS

MIDI file playback using the MPU-401?

Topic actions

First post, by superfury

Posted on 2015-02-28, 11:33

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5918
Joined: 2014-03-08, 11:25
Location: Netherlands

I'm currently testing my MPU emulation (which is the Dosbox mpu.cpp as the 'front-end' and my own MIDI emulation (everything producing sound and processing the MIDI commands send to the output) as the 'backend'. I'm currently trying to get my .mid file playback correctly. I do get sound, but it seems to go very fast and crashes in the end:

1#include "headers/types.h"
2#include "headers/support/zalloc.h" //Zalloc support!
3#include "headers/hardware/ports.h" //MPU support!
4#include "headers/emu/timers.h" //Timer support!
5#include "headers/support/mid.h" //Our own typedefs!
6
7#define MIDIHEADER_ID 0x6468544d
8#define MIDIHEADER_TRACK_ID 0x6b72544d
9
10word byteswap16(word value)
11{
12	return ((value & 0xFF) << 8) | ((value & 0xFF00) >> 8); //Byteswap!
13}
14
15uint_32 byteswap32(uint_32 value)
16{
17	return (byteswap16(value & 0xFFFF) << 8) | byteswap16((value & 0xFFFF0000) >> 16); //
18}
19
20uint_32 activetempo = 0x500000; //Current tempo!
21
22word readMID(char *filename, HEADER_CHNK *header, TRACK_CHNK *tracks, byte **channels, word maxchannels)
23{
24	FILE *f;
25	TRACK_CHNK currenttrack;
26	TRACK_CHNK *curtracks = tracks;
27	word currenttrackn = 0; //Ammount of tracks loaded!
28	uint_32 tracklength;
29
30	byte *data;
31	f = fopen(filename, "rb"); //Try to open!
32	if (!f) return 0; //Error: file not found!
33	if (fread(header, 1, sizeof(*header), f) != sizeof(*header))
34	{
35		fclose(f);
36		return 0; //Error reading header!
37	}
38	if (header->Header != MIDIHEADER_ID)
39	{
40		fclose(f);
41		return 0; //Nothing!
42	}
43	if (byteswap32(header->header_length) != 6)
44	{
45		fclose(f);
46		return 0; //Nothing!
47	}
48	if (byteswap16(header->format)>1) //Not single/multiple tracks played simultaneously?
49	{
50		fclose(f);
51		return 0; //Not single track!
52	}
53	nexttrack: //Read the next track!
54	if (fread(&currenttrack, 1, sizeof(currenttrack), f) != sizeof(currenttrack)) //Error in track?
55	{
56		fclose(f);
57		return 0; //Invalid track!
58	}
59	if (currenttrack.Header != MIDIHEADER_TRACK_ID) //Not a track ID?
60	{

…Show last 311 lines

61		fclose(f);
62		return 0; //Invalid track header!
63	}
64	if (!currenttrack.length) //No length?
65	{
66		fclose(f);
67		return 0; //Invalid track length!
68	}
69	tracklength = byteswap32(currenttrack.length); //Calculate the length of the track!
70	data = zalloc(tracklength,"MIDI_DATA"); //Allocate data!
71	if (!data) //Ran out of memory?
72	{
73		fclose(f);
74		return 0; //Ran out of memory!
75	}
76	if (fread(data, 1, tracklength, f) != tracklength) //Error reading data?
77	{
78		fclose(f);
79		freez((void **)&data, tracklength, "MIDI_DATA");
80		return 0; //Error reading data!
81	}
82
83	++currenttrackn; //Increase the number of tracks loaded!
84	if (currenttrackn > maxchannels) //Limit broken?
85	{
86		freez((void **)&data, tracklength, "MIDI_DATA");
87		return 0; //Limit broken: we can't store the file!
88	}
89
90	channels[currenttrackn - 1] = data; //Safe the pointer to the data!
91	memcpy(tracks, &currenttrack, sizeof(currenttrack)); //Copy track information!
92	++tracks; //Next track!
93	if (/*(byteswap16(header->format) > 0) &&*/ (currenttrackn<byteswap16(header->n))) //Format 1? Take all tracks!
94	{
95		goto nexttrack; //Next track to check!
96	}
97
98	/*if (!feof(f)) //Not @EOF when required?
99	{
100		fclose(f);
101		freez((void **)data, byteswap32(currenttrack.length), "MIDI_DATA"); //Release current if there!
102		return 0; //Incomplete file!
103	}*/
104	fclose(f);
105	activetempo = 500000; //Default = 120BPM = 500000 microseconds/quarter note!
106	return currenttrackn; //Give the result: the ammount of tracks loaded!
107}
108
109void freeMID(TRACK_CHNK *tracks, byte **channels, word numchannels)
110{
111	uint_32 channelnr;
112	for (channelnr = 0; channelnr < numchannels; channelnr++)
113	{
114		freez(&channels[channelnr], byteswap32(tracks[channelnr].length), "MIDI_DATA"); //Try to free!
115	}
116}
117
118byte consumeStream(byte **stream, byte *result)
119{
120	if (!memprotect(*stream, 1, "MIDI_DATA")) return 0; //Error: EOS!
121	*result = **stream; //Read!
122	++(*stream); //Increase pointer in the stream!
123	return 1; //Consumed!
124}
125
126byte peekStream(byte **stream, byte *result)
127{
128	if (!memprotect(*stream, 1, "MIDI_DATA")) return 0; //Error: EOS!
129	*result = *(*stream); //Consume a byte!
130	return 1; //Consumed!
131}
132
133byte read_VLV(byte **midi_stream, uint_32 *result)
134{
135	uint_32 temp = 0;
136	byte curdata;
137	if (!consumeStream(midi_stream, &curdata)) return 0; //Read first VLV failed?
138	for (;;) //Process/read the VLV!
139	{
140		temp |= (curdata & 0x7F); //Add to length!
141		if (!(curdata & 0x80)) break; //No byte to follow?
142		temp <<= 7; //Make some room for the next byte!
143		if (!consumeStream(midi_stream, &curdata)) return 0; //Read VLV failed?
144	}
145	*result = temp; //Give the result!
146	return 1; //OK!
147}
148
149float calcfreq(uint_32 tempo, HEADER_CHNK *header)
150{
151	float PPQN, speed;
152	byte frames;
153	byte subframes; //Pulses per quarter note!
154	word division;
155	division = byteswap16(header->division); //Byte swap!
156
157	if (division & 0x8000) //SMTPE?
158	{
159		frames = (float)((division >> 8)&0x7F); //Frames!
160		subframes = (float)(division & 0xFF); //Subframes!
161		speed = frames; //Default: we're the frames!
162		if (subframes)
163		{
164			//We don't use the tempo: our rate is fixed!
165			frames *= subframes; //The result in subframes/second!
166		}
167		speed = frames; //Use (sub)frames!
168	}
169	else
170	{
171		//PPQN method!
172		PPQN = (float)division; //Read PPQN!
173		speed = (float)tempo; //Convert to speed!
174		speed /= 1000000.0f; //Divide by 1 second!
175		speed /= PPQN; //Divide to get the ticks per second!
176		speed = 1.0f / speed; //Ammount per second!
177		speed *= 0.5f; //Divide by 2 for slower speed!
178	}
179	//We're counting in ticks!
180	return speed; //ticks per second!
181}
182
183//The protective semaphore for our flags!
184SDL_sem *MID_timing_pos_Lock = NULL; //Timing position lock!
185SDL_sem *MID_BPM_Lock = NULL; //BPM/Active tempo lock!
186
187uint_64 timing_pos = 0; //Current timing position!
188float BPM = 0.0f; //No BPM by default!
189
190void updateMIDTimer(HEADER_CHNK *header) //Request an update of our timer!
191{
192	addtimer(calcfreq(activetempo, header), (Handler)&timing_pos, "MID_tempotimer", 0, 2, MID_timing_pos_Lock); //Add a counter timer!
193}
194
195//The protective semaphore for the hardware!
196SDL_sem *MIDLock = NULL;
197
198#define MIDI_ERROR(position) {error = position; goto abortMIDI;}
199
200void playMIDIStream(word channel, byte *midi_stream, HEADER_CHNK *header)
201{
202	byte *curstream = midi_stream; //Copy the stream!
203	byte curdata;
204
205	//Metadata event!
206	byte meta_type;
207	uint_32 length; //Our metadata variable length!
208
209	uint_64 play_pos = 0; //Current play position!
210
211	uint_32 delta_time; //Delta time!
212
213	byte last_command = 0; //Last executed command!
214
215	int_32 error = 0; //Default: no error!
216	for (;;) //Playing?
217	{
218		//First, timing information and timing itself!
219		if (!read_VLV(&curstream, &delta_time)) return; //Read VLV time index!
220		play_pos += delta_time; //Add the delta time to the playing position!
221		for (;;)
222		{
223			//Lock
224			SDL_SemWait(MID_timing_pos_Lock);
225			if (timing_pos >= play_pos)
226			{
227				//Unlock
228				SDL_SemPost(MID_timing_pos_Lock);
229				break; //Arrived? Play!
230			}
231			//Unlock
232			SDL_SemPost(MID_timing_pos_Lock);
233			delay(0); //Wait for our tick!
234		}
235
236		if (!peekStream(&curstream, &curdata))
237		{
238			return; //Failed to peek!
239		}
240		if (curdata == 0xFF) //System?
241		{
242			if (!consumeStream(&curstream, &curdata)) return; //EOS!
243			if (!consumeStream(&curstream, &meta_type)) return; //Meta type failed? Give error!
244			if (!read_VLV(&curstream, &length)) return; //Error: unexpected EOS!
245			switch (meta_type) //What event?
246			{
247				case 0x2F: //EOT?
248					dolog("MID", "channel %i: EOT!", channel); //EOT reached!
249					return; //End of track reached: done!
250				case 0x51: //Set tempo?
251					//Lock
252					SDL_SemWait(MID_BPM_Lock);
253					removetimer("MID_tempotimer"); //Remove old timer!
254
255					if (!consumeStream(&curstream, &curdata)) return; //Tempo 1/3 failed?
256					activetempo = curdata; //Final byte!
257					activetempo <<= 8;
258					if (!consumeStream(&curstream, &curdata)) return; //Tempo 2/3 failed?
259					activetempo |= curdata; //Final byte!
260					activetempo <<= 8;
261					if (!consumeStream(&curstream, &curdata)) return; //Tempo 3/3 failed?
262					activetempo |= curdata; //Final byte!
263					//Tempo = us per quarter note!
264
265					updateMIDTimer(header);
266
267					dolog("MID", "channel %i: Set Tempo:%06X!", channel, activetempo);
268
269					//Unlock
270					SDL_SemPost(MID_BPM_Lock);
271					break;
272				default: //Unrecognised meta event? Skip it!
273					dolog("MID", "Unrecognised meta type: %02X@Channel %i; Data length: %i", meta_type, channel,length); //Log the unrecognised metadata type!
274					for (; length--;) //Process length bytes!
275					{
276						if (!consumeStream(&curstream, &curdata)) return; //Skip failed?
277					}
278					break;
279			}
280		}
281		else //Hardware?
282		{
283			//Lock
284			SDL_SemWait(MIDLock);
285
286			if (curdata & 0x80) //Starting a new command?
287			{
288				dolog("MID", "Status@Channel %i=%02X", channel, curdata);
289				if (!consumeStream(&curstream, &curdata)) MIDI_ERROR(1) //EOS!
290				last_command = curdata; //Save the last command!
291				if (last_command != 0xF7) //Escaped continue isn't sent!
292				{
293					PORT_OUT_B(0x330, last_command); //Send the command!
294				}
295			}
296			else
297			{
298				dolog("MID", "Continued status@Channel %i: %02X=>%02X",channel, last_command, curdata);
299				if (last_command != 0xF7) //Escaped continue isn't used last?
300				{
301					PORT_OUT_B(0x330, last_command); //Repeat the status bytes: we don't know what the other channels do!
302				}
303			}
304
305			//Process the data for the command!
306			switch ((last_command >> 4) & 0xF) //What command to send data for?
307			{
308			case 0xF: //Special?
309				switch (last_command & 0xF) //What subcommand are we sending?
310				{
311				case 0x0: //System exclusive?
312				case 0x7: //Escaped continue?
313					if (!read_VLV(&curstream, &length)) MIDI_ERROR(2) //Error: unexpected EOS!
314					for (; length--;) //Transmit the packet!
315					{
316						if (!consumeStream(&curstream, &curdata)) MIDI_ERROR(3+length) //EOS!
317						PORT_OUT_B(0x330, curdata); //Send the byte!
318					}
319					break;
320				case 0x1:
321				case 0x3:
322					//1 byte follows!
323					if (!consumeStream(&curstream, &curdata)) MIDI_ERROR(2) //EOS!
324					PORT_OUT_B(0x330, curdata); //Passthrough to MIDI!
325					break;
326				case 0x2:
327					//2 bytes follow!
328					if (!consumeStream(&curstream, &curdata)) MIDI_ERROR(2) //EOS!
329					PORT_OUT_B(0x330, curdata); //Passthrough to MIDI!
330					if (!consumeStream(&curstream, &curdata)) MIDI_ERROR(3) //EOS!
331					PORT_OUT_B(0x330, curdata); //Passthrough to MIDI!
332					break;
333				default: //Unknown special instruction?
334					break; //Single byte instruction?
335				}
336				break;
337			case 0x8: //Note off?
338			case 0x9: //Note on?
339			case 0xA: //Aftertouch?
340			case 0xB: //Control change?
341			case 0xE: //Pitch bend?
342				//2 bytes follow!
343				if (!consumeStream(&curstream, &curdata)) MIDI_ERROR(2) //EOS!
344				PORT_OUT_B(0x330, curdata); //Passthrough to MIDI!
345				if (!consumeStream(&curstream, &curdata)) MIDI_ERROR(3) //EOS!
346				PORT_OUT_B(0x330, curdata); //Passthrough to MIDI!
347				break;
348			case 0xC: //Program change?
349			case 0xD: //Channel pressure/aftertouch?
350				//1 byte follows
351				if (!consumeStream(&curstream, &curdata)) MIDI_ERROR(2) //EOS!
352				PORT_OUT_B(0x330, curdata); //Passthrough to MIDI!
353				break;
354			default: //Unknown data? We're sending directly to the hardware! We shouldn't be here!
355				if (!consumeStream(&curstream, &curdata)) MIDI_ERROR(2) //EOS!
356				dolog("MID", "Warning: Unknown data detected@channel %i: passthrough to MIDI device: %02X!",channel,curdata);
357				PORT_OUT_B(0x330, curdata); //Passthrough to MIDI!
358				break;
359			}
360		abortMIDI:
361			//Unlock
362			if (error)
363			{
364				dolog("MID", "channel %i: Error @position %i during MID processing! Unexpected EOS? Last command: %02X, Current data: %02X",channel,error,last_command,curdata);
365				SDL_SemPost(MIDLock); //Finish up!
366				return; //Abort on error!
367			}
368			SDL_SemPost(MIDLock); //Finish: prepare for next command!
369		}
370	}
371}

The loader:

1extern uint_64 timing_pos; //Current timing position for MIDI speed playback!
2
3word MID_RUNNING = 0;
4
5HEADER_CHNK header;
6
7SDL_sem *MID_channel_Lock = NULL; //Our channel lock for counting running MIDI!
8
9byte *MID_data[100]; //Tempo and music track!
10TRACK_CHNK MID_tracks[100];
11
12void handleMIDIChannel()
13{
14	word channel;
15	channel = (word)getthreadparams(); //Gotten a channel?
16	playMIDIStream(channel,MID_data[channel], &header); //Play the MIDI stream!
17	SDL_SemWait(MID_channel_Lock);
18	dolog("MID", "Channel %i finished", channel); //We're finished!
19	--MID_RUNNING; //Done!
20	SDL_SemPost(MID_channel_Lock);
21}
22
23//All used locks!
24extern SDL_sem *MIDLock;
25extern SDL_sem *MID_timing_pos_Lock;
26extern SDL_sem *MID_BPM_Lock;

...

1	memset(&MID_data, 0, sizeof(MID_data)); //Init data!
2	memset(&MID_tracks, 0, sizeof(MID_tracks)); //Init tracks!
3
4	word numchannels = 0;
5	if ((numchannels = readMID("MPU.mid", &header, &MID_tracks[0], &MID_data[0], 100)))
6	{
7		//Initialise our device!
8		PORT_OUT_B(0x331, 0xFF); //Reset!
9		PORT_OUT_B(0x331, 0x3F); //Kick to UART mode!
10		updateMIDTimer(&header); //Update the timer!
11
12		//Create the semaphore for the threads!
13		MIDLock = SDL_CreateSemaphore(1);
14		MID_timing_pos_Lock = SDL_CreateSemaphore(1);
15		MID_BPM_Lock = SDL_CreateSemaphore(1);
16		MID_channel_Lock = SDL_CreateSemaphore(1);
17
18		//Now, start up all timers!
19
20		word i;
21		MID_RUNNING = numchannels; //Init to all running!
22		for (i = 0; i < numchannels; i++)
23		{
24			startThread(&handleMIDIChannel, "MIDI_STREAM", (void *)i, DEFAULT_PRIORITY); //Start a thread handling the output of the channel!
25		}
26
27		delay(10000); //Wait a bit to allow for initialisation (position 0) to run!
28
29		startTimers(1);
30		startTimers(0); //Start our timers!
31
32		byte running = 1; //Are we running?
33
34		for (;;) //Wait to end!
35		{
36			delay(1000000); //Wait 1sec intervals!
37			SDL_SemWait(MID_channel_Lock);
38			if (!MID_RUNNING)
39			{
40				running = 0; //Not running anymore!
41			}
42			SDL_SemPost(MID_channel_Lock);
43			if (!running) break; //Not running anymore? Start quitting!
44		}
45
46		//Destroy semaphore
47		SDL_DestroySemaphore(MIDLock);
48		SDL_DestroySemaphore(MID_timing_pos_Lock);
49		SDL_DestroySemaphore(MID_BPM_Lock);
50		SDL_DestroySemaphore(MID_channel_Lock);
51
52		removetimer("MID_tempotimer"); //Clean up!
53		freeMID(&MID_tracks[0], &MID_data[0], numchannels); //Free all channels!
54		halt();
55		exit(0);
56		sleep();
57	}

What happens:
- The loader does the normal 'CPU' work.
- The midi channel processes a channel and send it to the MPU-401.
- The Dosbox mpu.cpp sends command and data bytes it to my emulated MIDI processing layer (Dosbox itself sends it to Windows/Unix etc.), since it's in UART mode.
- My MIDI processing layer processes command and sets them a command at a time to my playback engine.
- My MIDI playback engine handles everything to generate the sound:
- 1. Process the command and execute it.
- 2. Voice sound thread: Make the correct sound using the SoundFont backend and envelopes.

Anyone knows if the above parser is correct?

BTW, the delay(us) function delays the current thread. PORT_OUT_B(port,data) sends data to the MPU-401.

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Go to top of page Go to top of page

Back to DOSBox Development