1 //
2 // Copyright(C) 2005-2014 Simon Howard
3 //
4 // This program is free software; you can redistribute it and/or
5 // modify it under the terms of the GNU General Public License
6 // as published by the Free Software Foundation; either version 2
7 // of the License, or (at your option) any later version.
8 //
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU General Public License for more details.
13 //
14 // DESCRIPTION:
15 // Reading of MIDI files.
16 //
17
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <string.h>
21 #include <assert.h>
22
23 #include "doomtype.h"
24 #include "i_swap.h"
25 #include "i_system.h"
26 #include "midifile.h"
27
28 #define HEADER_CHUNK_ID "MThd"
29 #define TRACK_CHUNK_ID "MTrk"
30 #define MAX_BUFFER_SIZE 0x10000
31
32 // haleyjd 09/09/10: packing required
33 #ifdef _MSC_VER
34 #pragma pack(push, 1)
35 #endif
36
37 typedef PACKED_STRUCT (
38 {
39 byte chunk_id[4];
40 unsigned int chunk_size;
41 }) chunk_header_t;
42
43 typedef PACKED_STRUCT (
44 {
45 chunk_header_t chunk_header;
46 unsigned short format_type;
47 unsigned short num_tracks;
48 unsigned short time_division;
49 }) midi_header_t;
50
51 // haleyjd 09/09/10: packing off.
52 #ifdef _MSC_VER
53 #pragma pack(pop)
54 #endif
55
56 typedef struct
57 {
58 // Length in bytes:
59
60 unsigned int data_len;
61
62 // Events in this track:
63
64 midi_event_t *events;
65 int num_events;
66 } midi_track_t;
67
68 struct midi_track_iter_s
69 {
70 midi_track_t *track;
71 unsigned int position;
72 };
73
74 struct midi_file_s
75 {
76 midi_header_t header;
77
78 // All tracks in this file:
79 midi_track_t *tracks;
80 unsigned int num_tracks;
81
82 // Data buffer used to store data read for SysEx or meta events:
83 byte *buffer;
84 unsigned int buffer_size;
85 };
86
87 // Check the header of a chunk:
88
CheckChunkHeader(chunk_header_t * chunk,char * expected_id)89 static boolean CheckChunkHeader(chunk_header_t *chunk,
90 char *expected_id)
91 {
92 boolean result;
93
94 result = (memcmp((char *) chunk->chunk_id, expected_id, 4) == 0);
95
96 if (!result)
97 {
98 fprintf(stderr, "CheckChunkHeader: Expected '%s' chunk header, "
99 "got '%c%c%c%c'\n",
100 expected_id,
101 chunk->chunk_id[0], chunk->chunk_id[1],
102 chunk->chunk_id[2], chunk->chunk_id[3]);
103 }
104
105 return result;
106 }
107
108 // Read a single byte. Returns false on error.
109
ReadByte(byte * result,FILE * stream)110 static boolean ReadByte(byte *result, FILE *stream)
111 {
112 int c;
113
114 c = fgetc(stream);
115
116 if (c == EOF)
117 {
118 fprintf(stderr, "ReadByte: Unexpected end of file\n");
119 return false;
120 }
121 else
122 {
123 *result = (byte) c;
124
125 return true;
126 }
127 }
128
129 // Read a variable-length value.
130
ReadVariableLength(unsigned int * result,FILE * stream)131 static boolean ReadVariableLength(unsigned int *result, FILE *stream)
132 {
133 int i;
134 byte b = 0;
135
136 *result = 0;
137
138 for (i=0; i<4; ++i)
139 {
140 if (!ReadByte(&b, stream))
141 {
142 fprintf(stderr, "ReadVariableLength: Error while reading "
143 "variable-length value\n");
144 return false;
145 }
146
147 // Insert the bottom seven bits from this byte.
148
149 *result <<= 7;
150 *result |= b & 0x7f;
151
152 // If the top bit is not set, this is the end.
153
154 if ((b & 0x80) == 0)
155 {
156 return true;
157 }
158 }
159
160 fprintf(stderr, "ReadVariableLength: Variable-length value too "
161 "long: maximum of four bytes\n");
162 return false;
163 }
164
165 // Read a byte sequence into the data buffer.
166
ReadByteSequence(unsigned int num_bytes,FILE * stream)167 static void *ReadByteSequence(unsigned int num_bytes, FILE *stream)
168 {
169 unsigned int i;
170 byte *result;
171
172 // Allocate a buffer. Allocate one extra byte, as malloc(0) is
173 // non-portable.
174
175 result = malloc(num_bytes + 1);
176
177 if (result == NULL)
178 {
179 fprintf(stderr, "ReadByteSequence: Failed to allocate buffer\n");
180 return NULL;
181 }
182
183 // Read the data:
184
185 for (i=0; i<num_bytes; ++i)
186 {
187 if (!ReadByte(&result[i], stream))
188 {
189 fprintf(stderr, "ReadByteSequence: Error while reading byte %u\n",
190 i);
191 free(result);
192 return NULL;
193 }
194 }
195
196 return result;
197 }
198
199 // Read a MIDI channel event.
200 // two_param indicates that the event type takes two parameters
201 // (three byte) otherwise it is single parameter (two byte)
202
ReadChannelEvent(midi_event_t * event,byte event_type,boolean two_param,FILE * stream)203 static boolean ReadChannelEvent(midi_event_t *event,
204 byte event_type, boolean two_param,
205 FILE *stream)
206 {
207 byte b = 0;
208
209 // Set basics:
210
211 event->event_type = event_type & 0xf0;
212 event->data.channel.channel = event_type & 0x0f;
213
214 // Read parameters:
215
216 if (!ReadByte(&b, stream))
217 {
218 fprintf(stderr, "ReadChannelEvent: Error while reading channel "
219 "event parameters\n");
220 return false;
221 }
222
223 event->data.channel.param1 = b;
224
225 // Second parameter:
226
227 if (two_param)
228 {
229 if (!ReadByte(&b, stream))
230 {
231 fprintf(stderr, "ReadChannelEvent: Error while reading channel "
232 "event parameters\n");
233 return false;
234 }
235
236 event->data.channel.param2 = b;
237 }
238
239 return true;
240 }
241
242 // Read sysex event:
243
ReadSysExEvent(midi_event_t * event,int event_type,FILE * stream)244 static boolean ReadSysExEvent(midi_event_t *event, int event_type,
245 FILE *stream)
246 {
247 event->event_type = event_type;
248
249 if (!ReadVariableLength(&event->data.sysex.length, stream))
250 {
251 fprintf(stderr, "ReadSysExEvent: Failed to read length of "
252 "SysEx block\n");
253 return false;
254 }
255
256 // Read the byte sequence:
257
258 event->data.sysex.data = ReadByteSequence(event->data.sysex.length, stream);
259
260 if (event->data.sysex.data == NULL)
261 {
262 fprintf(stderr, "ReadSysExEvent: Failed while reading SysEx event\n");
263 return false;
264 }
265
266 return true;
267 }
268
269 // Read meta event:
270
ReadMetaEvent(midi_event_t * event,FILE * stream)271 static boolean ReadMetaEvent(midi_event_t *event, FILE *stream)
272 {
273 byte b = 0;
274
275 event->event_type = MIDI_EVENT_META;
276
277 // Read meta event type:
278
279 if (!ReadByte(&b, stream))
280 {
281 fprintf(stderr, "ReadMetaEvent: Failed to read meta event type\n");
282 return false;
283 }
284
285 event->data.meta.type = b;
286
287 // Read length of meta event data:
288
289 if (!ReadVariableLength(&event->data.meta.length, stream))
290 {
291 fprintf(stderr, "ReadSysExEvent: Failed to read length of "
292 "SysEx block\n");
293 return false;
294 }
295
296 // Read the byte sequence:
297
298 event->data.meta.data = ReadByteSequence(event->data.meta.length, stream);
299
300 if (event->data.meta.data == NULL)
301 {
302 fprintf(stderr, "ReadSysExEvent: Failed while reading SysEx event\n");
303 return false;
304 }
305
306 return true;
307 }
308
ReadEvent(midi_event_t * event,unsigned int * last_event_type,FILE * stream)309 static boolean ReadEvent(midi_event_t *event, unsigned int *last_event_type,
310 FILE *stream)
311 {
312 byte event_type = 0;
313
314 if (!ReadVariableLength(&event->delta_time, stream))
315 {
316 fprintf(stderr, "ReadEvent: Failed to read event timestamp\n");
317 return false;
318 }
319
320 if (!ReadByte(&event_type, stream))
321 {
322 fprintf(stderr, "ReadEvent: Failed to read event type\n");
323 return false;
324 }
325
326 // All event types have their top bit set. Therefore, if
327 // the top bit is not set, it is because we are using the "same
328 // as previous event type" shortcut to save a byte. Skip back
329 // a byte so that we read this byte again.
330
331 if ((event_type & 0x80) == 0)
332 {
333 event_type = *last_event_type;
334
335 if (fseek(stream, -1, SEEK_CUR) < 0)
336 {
337 fprintf(stderr, "ReadEvent: Unable to seek in stream\n");
338 return false;
339 }
340 }
341 else
342 {
343 *last_event_type = event_type;
344 }
345
346 // Check event type:
347
348 switch (event_type & 0xf0)
349 {
350 // Two parameter channel events:
351
352 case MIDI_EVENT_NOTE_OFF:
353 case MIDI_EVENT_NOTE_ON:
354 case MIDI_EVENT_AFTERTOUCH:
355 case MIDI_EVENT_CONTROLLER:
356 case MIDI_EVENT_PITCH_BEND:
357 return ReadChannelEvent(event, event_type, true, stream);
358
359 // Single parameter channel events:
360
361 case MIDI_EVENT_PROGRAM_CHANGE:
362 case MIDI_EVENT_CHAN_AFTERTOUCH:
363 return ReadChannelEvent(event, event_type, false, stream);
364
365 default:
366 break;
367 }
368
369 // Specific value?
370
371 switch (event_type)
372 {
373 case MIDI_EVENT_SYSEX:
374 case MIDI_EVENT_SYSEX_SPLIT:
375 return ReadSysExEvent(event, event_type, stream);
376
377 case MIDI_EVENT_META:
378 return ReadMetaEvent(event, stream);
379
380 default:
381 break;
382 }
383
384 fprintf(stderr, "ReadEvent: Unknown MIDI event type: 0x%x\n", event_type);
385 return false;
386 }
387
388 // Free an event:
389
FreeEvent(midi_event_t * event)390 static void FreeEvent(midi_event_t *event)
391 {
392 // Some event types have dynamically allocated buffers assigned
393 // to them that must be freed.
394
395 switch (event->event_type)
396 {
397 case MIDI_EVENT_SYSEX:
398 case MIDI_EVENT_SYSEX_SPLIT:
399 free(event->data.sysex.data);
400 break;
401
402 case MIDI_EVENT_META:
403 free(event->data.meta.data);
404 break;
405
406 default:
407 // Nothing to do.
408 break;
409 }
410 }
411
412 // Read and check the track chunk header
413
ReadTrackHeader(midi_track_t * track,FILE * stream)414 static boolean ReadTrackHeader(midi_track_t *track, FILE *stream)
415 {
416 size_t records_read;
417 chunk_header_t chunk_header;
418
419 records_read = fread(&chunk_header, sizeof(chunk_header_t), 1, stream);
420
421 if (records_read < 1)
422 {
423 return false;
424 }
425
426 if (!CheckChunkHeader(&chunk_header, TRACK_CHUNK_ID))
427 {
428 return false;
429 }
430
431 track->data_len = SDL_SwapBE32(chunk_header.chunk_size);
432
433 return true;
434 }
435
ReadTrack(midi_track_t * track,FILE * stream)436 static boolean ReadTrack(midi_track_t *track, FILE *stream)
437 {
438 midi_event_t *new_events;
439 midi_event_t *event;
440 unsigned int last_event_type;
441
442 track->num_events = 0;
443 track->events = NULL;
444
445 // Read the header:
446
447 if (!ReadTrackHeader(track, stream))
448 {
449 return false;
450 }
451
452 // Then the events:
453
454 last_event_type = 0;
455
456 for (;;)
457 {
458 // Resize the track slightly larger to hold another event:
459
460 new_events = I_Realloc(track->events,
461 sizeof(midi_event_t) * (track->num_events + 1));
462 track->events = new_events;
463
464 // Read the next event:
465
466 event = &track->events[track->num_events];
467 if (!ReadEvent(event, &last_event_type, stream))
468 {
469 return false;
470 }
471
472 ++track->num_events;
473
474 // End of track?
475
476 if (event->event_type == MIDI_EVENT_META
477 && event->data.meta.type == MIDI_META_END_OF_TRACK)
478 {
479 break;
480 }
481 }
482
483 return true;
484 }
485
486 // Free a track:
487
FreeTrack(midi_track_t * track)488 static void FreeTrack(midi_track_t *track)
489 {
490 unsigned int i;
491
492 for (i=0; i<track->num_events; ++i)
493 {
494 FreeEvent(&track->events[i]);
495 }
496
497 free(track->events);
498 }
499
ReadAllTracks(midi_file_t * file,FILE * stream)500 static boolean ReadAllTracks(midi_file_t *file, FILE *stream)
501 {
502 unsigned int i;
503
504 // Allocate list of tracks and read each track:
505
506 file->tracks = malloc(sizeof(midi_track_t) * file->num_tracks);
507
508 if (file->tracks == NULL)
509 {
510 return false;
511 }
512
513 memset(file->tracks, 0, sizeof(midi_track_t) * file->num_tracks);
514
515 // Read each track:
516
517 for (i=0; i<file->num_tracks; ++i)
518 {
519 if (!ReadTrack(&file->tracks[i], stream))
520 {
521 return false;
522 }
523 }
524
525 return true;
526 }
527
528 // Read and check the header chunk.
529
ReadFileHeader(midi_file_t * file,FILE * stream)530 static boolean ReadFileHeader(midi_file_t *file, FILE *stream)
531 {
532 size_t records_read;
533 unsigned int format_type;
534
535 records_read = fread(&file->header, sizeof(midi_header_t), 1, stream);
536
537 if (records_read < 1)
538 {
539 return false;
540 }
541
542 if (!CheckChunkHeader(&file->header.chunk_header, HEADER_CHUNK_ID)
543 || SDL_SwapBE32(file->header.chunk_header.chunk_size) != 6)
544 {
545 fprintf(stderr, "ReadFileHeader: Invalid MIDI chunk header! "
546 "chunk_size=%i\n",
547 SDL_SwapBE32(file->header.chunk_header.chunk_size));
548 return false;
549 }
550
551 format_type = SDL_SwapBE16(file->header.format_type);
552 file->num_tracks = SDL_SwapBE16(file->header.num_tracks);
553
554 if ((format_type != 0 && format_type != 1)
555 || file->num_tracks < 1)
556 {
557 fprintf(stderr, "ReadFileHeader: Only type 0/1 "
558 "MIDI files supported!\n");
559 return false;
560 }
561
562 return true;
563 }
564
MIDI_FreeFile(midi_file_t * file)565 void MIDI_FreeFile(midi_file_t *file)
566 {
567 int i;
568
569 if (file->tracks != NULL)
570 {
571 for (i=0; i<file->num_tracks; ++i)
572 {
573 FreeTrack(&file->tracks[i]);
574 }
575
576 free(file->tracks);
577 }
578
579 free(file);
580 }
581
MIDI_LoadFile(char * filename)582 midi_file_t *MIDI_LoadFile(char *filename)
583 {
584 midi_file_t *file;
585 FILE *stream;
586
587 file = malloc(sizeof(midi_file_t));
588
589 if (file == NULL)
590 {
591 return NULL;
592 }
593
594 file->tracks = NULL;
595 file->num_tracks = 0;
596 file->buffer = NULL;
597 file->buffer_size = 0;
598
599 // Open file
600
601 stream = fopen(filename, "rb");
602
603 if (stream == NULL)
604 {
605 fprintf(stderr, "MIDI_LoadFile: Failed to open '%s'\n", filename);
606 MIDI_FreeFile(file);
607 return NULL;
608 }
609
610 // Read MIDI file header
611
612 if (!ReadFileHeader(file, stream))
613 {
614 fclose(stream);
615 MIDI_FreeFile(file);
616 return NULL;
617 }
618
619 // Read all tracks:
620
621 if (!ReadAllTracks(file, stream))
622 {
623 fclose(stream);
624 MIDI_FreeFile(file);
625 return NULL;
626 }
627
628 fclose(stream);
629
630 return file;
631 }
632
633 // Get the number of tracks in a MIDI file.
634
MIDI_NumTracks(midi_file_t * file)635 unsigned int MIDI_NumTracks(midi_file_t *file)
636 {
637 return file->num_tracks;
638 }
639
640 // Start iterating over the events in a track.
641
MIDI_IterateTrack(midi_file_t * file,unsigned int track)642 midi_track_iter_t *MIDI_IterateTrack(midi_file_t *file, unsigned int track)
643 {
644 midi_track_iter_t *iter;
645
646 assert(track < file->num_tracks);
647
648 iter = malloc(sizeof(*iter));
649 iter->track = &file->tracks[track];
650 iter->position = 0;
651
652 return iter;
653 }
654
MIDI_FreeIterator(midi_track_iter_t * iter)655 void MIDI_FreeIterator(midi_track_iter_t *iter)
656 {
657 free(iter);
658 }
659
660 // Get the time until the next MIDI event in a track.
661
MIDI_GetDeltaTime(midi_track_iter_t * iter)662 unsigned int MIDI_GetDeltaTime(midi_track_iter_t *iter)
663 {
664 if (iter->position < iter->track->num_events)
665 {
666 midi_event_t *next_event;
667
668 next_event = &iter->track->events[iter->position];
669
670 return next_event->delta_time;
671 }
672 else
673 {
674 return 0;
675 }
676 }
677
678 // Get a pointer to the next MIDI event.
679
MIDI_GetNextEvent(midi_track_iter_t * iter,midi_event_t ** event)680 int MIDI_GetNextEvent(midi_track_iter_t *iter, midi_event_t **event)
681 {
682 if (iter->position < iter->track->num_events)
683 {
684 *event = &iter->track->events[iter->position];
685 ++iter->position;
686
687 return 1;
688 }
689 else
690 {
691 return 0;
692 }
693 }
694
MIDI_GetFileTimeDivision(midi_file_t * file)695 unsigned int MIDI_GetFileTimeDivision(midi_file_t *file)
696 {
697 short result = SDL_SwapBE16(file->header.time_division);
698
699 // Negative time division indicates SMPTE time and must be handled
700 // differently.
701 if (result < 0)
702 {
703 return (signed int)(-(result/256))
704 * (signed int)(result & 0xFF);
705 }
706 else
707 {
708 return result;
709 }
710 }
711
MIDI_RestartIterator(midi_track_iter_t * iter)712 void MIDI_RestartIterator(midi_track_iter_t *iter)
713 {
714 iter->position = 0;
715 }
716
717 #ifdef TEST
718
MIDI_EventTypeToString(midi_event_type_t event_type)719 static char *MIDI_EventTypeToString(midi_event_type_t event_type)
720 {
721 switch (event_type)
722 {
723 case MIDI_EVENT_NOTE_OFF:
724 return "MIDI_EVENT_NOTE_OFF";
725 case MIDI_EVENT_NOTE_ON:
726 return "MIDI_EVENT_NOTE_ON";
727 case MIDI_EVENT_AFTERTOUCH:
728 return "MIDI_EVENT_AFTERTOUCH";
729 case MIDI_EVENT_CONTROLLER:
730 return "MIDI_EVENT_CONTROLLER";
731 case MIDI_EVENT_PROGRAM_CHANGE:
732 return "MIDI_EVENT_PROGRAM_CHANGE";
733 case MIDI_EVENT_CHAN_AFTERTOUCH:
734 return "MIDI_EVENT_CHAN_AFTERTOUCH";
735 case MIDI_EVENT_PITCH_BEND:
736 return "MIDI_EVENT_PITCH_BEND";
737 case MIDI_EVENT_SYSEX:
738 return "MIDI_EVENT_SYSEX";
739 case MIDI_EVENT_SYSEX_SPLIT:
740 return "MIDI_EVENT_SYSEX_SPLIT";
741 case MIDI_EVENT_META:
742 return "MIDI_EVENT_META";
743
744 default:
745 return "(unknown)";
746 }
747 }
748
PrintTrack(midi_track_t * track)749 void PrintTrack(midi_track_t *track)
750 {
751 midi_event_t *event;
752 unsigned int i;
753
754 for (i=0; i<track->num_events; ++i)
755 {
756 event = &track->events[i];
757
758 if (event->delta_time > 0)
759 {
760 printf("Delay: %i ticks\n", event->delta_time);
761 }
762
763 printf("Event type: %s (%i)\n",
764 MIDI_EventTypeToString(event->event_type),
765 event->event_type);
766
767 switch(event->event_type)
768 {
769 case MIDI_EVENT_NOTE_OFF:
770 case MIDI_EVENT_NOTE_ON:
771 case MIDI_EVENT_AFTERTOUCH:
772 case MIDI_EVENT_CONTROLLER:
773 case MIDI_EVENT_PROGRAM_CHANGE:
774 case MIDI_EVENT_CHAN_AFTERTOUCH:
775 case MIDI_EVENT_PITCH_BEND:
776 printf("\tChannel: %i\n", event->data.channel.channel);
777 printf("\tParameter 1: %i\n", event->data.channel.param1);
778 printf("\tParameter 2: %i\n", event->data.channel.param2);
779 break;
780
781 case MIDI_EVENT_SYSEX:
782 case MIDI_EVENT_SYSEX_SPLIT:
783 printf("\tLength: %i\n", event->data.sysex.length);
784 break;
785
786 case MIDI_EVENT_META:
787 printf("\tMeta type: %i\n", event->data.meta.type);
788 printf("\tLength: %i\n", event->data.meta.length);
789 break;
790 }
791 }
792 }
793
main(int argc,char * argv[])794 int main(int argc, char *argv[])
795 {
796 midi_file_t *file;
797 unsigned int i;
798
799 if (argc < 2)
800 {
801 printf("Usage: %s <filename>\n", argv[0]);
802 exit(1);
803 }
804
805 file = MIDI_LoadFile(argv[1]);
806
807 if (file == NULL)
808 {
809 fprintf(stderr, "Failed to open %s\n", argv[1]);
810 exit(1);
811 }
812
813 for (i=0; i<file->num_tracks; ++i)
814 {
815 printf("\n== Track %i ==\n\n", i);
816
817 PrintTrack(&file->tracks[i]);
818 }
819
820 return 0;
821 }
822
823 #endif
824
825