2 * Copyright (c) 2007, 2008 Edward Tomasz NapieraĆa <trasz@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * ALTHOUGH THIS SOFTWARE IS MADE OF WIN AND SCIENCE, IT IS PROVIDED BY THE
15 * AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
16 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
17 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
18 * THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
20 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
21 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
23 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 * Standard MIDI File format loader.
35 /* Reference: http://www.borg.com/~jglatt/tech/midifile.htm */
43 #include <arpa/inet.h>
45 #include "smf_private.h"
48 * Returns pointer to the next SMF chunk in smf->buffer, based on length of the previous one.
49 * Returns NULL in case of error.
51 static struct chunk_header_struct *
52 next_chunk(smf_t *smf)
54 struct chunk_header_struct *chunk;
57 assert(smf->file_buffer != NULL);
58 assert(smf->file_buffer_length > 0);
60 if (smf->next_chunk_offset + sizeof(struct chunk_header_struct) >= smf->file_buffer_length) {
61 g_critical("SMF warning: no more chunks left.");
65 next_chunk_ptr = (unsigned char *)smf->file_buffer + smf->next_chunk_offset;
67 chunk = (struct chunk_header_struct *)next_chunk_ptr;
69 if (!isalpha(chunk->id[0]) || !isalpha(chunk->id[1]) || !isalpha(chunk->id[2]) || !isalpha(chunk->id[3])) {
70 g_critical("SMF error: chunk signature contains at least one non-alphanumeric byte.");
75 * XXX: On SPARC, after compiling with "-fast" option there will be SIGBUS here.
76 * Please compile with -xmemalign=8i".
78 smf->next_chunk_offset += sizeof(struct chunk_header_struct) + ntohl(chunk->length);
80 if (smf->next_chunk_offset > smf->file_buffer_length) {
81 g_critical("SMF error: malformed chunk; truncated file?");
89 * Returns 1, iff signature of the "chunk" is the same as string passed as "signature".
92 chunk_signature_matches(const struct chunk_header_struct *chunk, const char *signature)
94 if (!memcmp(chunk->id, signature, 4))
101 * Verifies if MThd header looks OK. Returns 0 iff it does.
104 parse_mthd_header(smf_t *smf)
107 struct chunk_header_struct *mthd, *tmp_mthd;
109 /* Make sure compiler didn't do anything stupid. */
110 assert(sizeof(struct chunk_header_struct) == 8);
113 * We could just do "mthd = smf->file_buffer;" here, but this way we wouldn't
114 * get useful error messages.
116 if (smf->file_buffer_length < 6) {
117 g_critical("SMF error: file is too short, it cannot be a MIDI file.");
122 tmp_mthd = smf->file_buffer;
124 if (!chunk_signature_matches(tmp_mthd, "MThd")) {
125 g_critical("SMF error: MThd signature not found, is that a MIDI file?");
130 /* Ok, now use next_chunk(). */
131 mthd = next_chunk(smf);
135 assert(mthd == tmp_mthd);
137 len = ntohl(mthd->length);
139 g_critical("SMF error: MThd chunk length %d, must be 6.", len);
148 * Parses MThd chunk, filling "smf" structure with values extracted from it. Returns 0 iff everything went OK.
151 parse_mthd_chunk(smf_t *smf)
153 signed char first_byte_of_division, second_byte_of_division;
155 struct mthd_chunk_struct *mthd;
157 assert(sizeof(struct mthd_chunk_struct) == 14);
159 if (parse_mthd_header(smf))
162 mthd = (struct mthd_chunk_struct *)smf->file_buffer;
164 smf->format = ntohs(mthd->format);
165 if (smf->format < 0 || smf->format > 2) {
166 g_critical("SMF error: bad MThd format field value: %d, valid values are 0-2, inclusive.", smf->format);
170 if (smf->format == 2) {
171 g_critical("SMF file uses format #2, no support for that yet.");
175 smf->expected_number_of_tracks = ntohs(mthd->number_of_tracks);
176 if (smf->expected_number_of_tracks <= 0) {
177 g_critical("SMF error: bad number of tracks: %d, must be greater than zero.", smf->expected_number_of_tracks);
181 /* XXX: endianess? */
182 first_byte_of_division = *((signed char *)&(mthd->division));
183 second_byte_of_division = *((signed char *)&(mthd->division) + 1);
185 if (first_byte_of_division >= 0) {
186 smf->ppqn = ntohs(mthd->division);
187 smf->frames_per_second = 0;
191 smf->frames_per_second = - first_byte_of_division;
192 smf->resolution = second_byte_of_division;
195 if (smf->ppqn == 0) {
196 g_critical("SMF file uses FPS timing instead of PPQN, no support for that yet.");
204 * Interprets Variable Length Quantity pointed at by "buf" and puts its value into "value" and number
205 * of bytes consumed into "len", making sure it does not read past "buf" + "buffer_length".
206 * Explanation of Variable Length Quantities is here: http://www.borg.com/~jglatt/tech/midifile/vari.htm
207 * Returns 0 iff everything went OK, different value in case of error.
210 smf_extract_vlq(const unsigned char *buf, const size_t buffer_length, uint32_t *value, uint32_t *len)
213 const unsigned char *c = buf;
216 if (c >= buf + buffer_length) {
217 g_critical("End of buffer in extract_vlq().");
221 val = (val << 7) + (*c & 0x7F);
234 g_critical("SMF error: Variable Length Quantities longer than four bytes are not supported yet.");
242 * Returns 1 if the given byte is a valid status byte, 0 otherwise.
245 is_status_byte(const unsigned char status)
247 return (status & 0x80);
251 is_sysex_byte(const unsigned char status)
260 is_escape_byte(const unsigned char status)
269 * Just like expected_message_length(), but only for System Exclusive messages.
270 * Note that value returned by this thing here is the length of SysEx "on the wire",
271 * not the number of bytes that this sysex takes in the file - in SMF format sysex
272 * contains VLQ telling how many bytes it takes, "on the wire" format does not have
276 expected_sysex_length(const unsigned char status, const unsigned char *second_byte, const size_t buffer_length, int32_t *consumed_bytes)
278 uint32_t sysex_length = 0;
281 assert(status == 0xF0);
283 if (buffer_length < 3) {
284 g_critical("SMF error: end of buffer in expected_sysex_length().");
288 smf_extract_vlq(second_byte, buffer_length, &sysex_length, &len);
290 if (consumed_bytes != NULL)
291 *consumed_bytes = len;
293 /* +1, because the length does not include status byte. */
294 return (sysex_length + 1);
298 expected_escaped_length(const unsigned char status, const unsigned char *second_byte, const size_t buffer_length, int32_t *consumed_bytes)
300 /* -1, because we do not want to account for 0x7F status. */
301 return (expected_sysex_length(status, second_byte, buffer_length, consumed_bytes) - 1);
305 * Returns expected length of the midi message (including the status byte), in bytes, for the given status byte.
306 * The "second_byte" points to the expected second byte of the MIDI message. "buffer_length" is the buffer
307 * length limit, counting from "second_byte". Returns value < 0 iff there was an error.
310 expected_message_length(unsigned char status, const unsigned char *second_byte, const size_t buffer_length)
312 /* Make sure this really is a valid status byte. */
313 assert(is_status_byte(status));
315 /* We cannot use this routine for sysexes. */
316 assert(!is_sysex_byte(status));
318 /* We cannot use this routine for escaped events. */
319 assert(!is_escape_byte(status));
321 /* Is this a metamessage? */
322 if (status == 0xFF) {
323 if (buffer_length < 2) {
324 g_critical("SMF error: end of buffer in expected_message_length().");
329 * Format of this kind of messages is like this: 0xFF 0xwhatever 0xlength and then "length" bytes.
330 * Second byte points to this: ^^^^^^^^^^
332 return (*(second_byte + 1) + 3);
335 if ((status & 0xF0) == 0xF0) {
337 case 0xF2: /* Song Position Pointer. */
340 case 0xF1: /* MTC Quarter Frame. */
341 case 0xF3: /* Song Select. */
344 case 0xF6: /* Tune Request. */
345 case 0xF8: /* MIDI Clock. */
346 case 0xF9: /* Tick. */
347 case 0xFA: /* MIDI Start. */
348 case 0xFB: /* MIDI Continue. */
349 case 0xFC: /* MIDI Stop. */
350 case 0xFE: /* Active Sense. */
354 g_critical("SMF error: unknown 0xFx-type status byte '0x%x'.", status);
359 /* Filter out the channel. */
363 case 0x80: /* Note Off. */
364 case 0x90: /* Note On. */
365 case 0xA0: /* AfterTouch. */
366 case 0xB0: /* Control Change. */
367 case 0xE0: /* Pitch Wheel. */
370 case 0xC0: /* Program Change. */
371 case 0xD0: /* Channel Pressure. */
375 g_critical("SMF error: unknown status byte '0x%x'.", status);
381 extract_sysex_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
386 int32_t vlq_length, message_length;
387 const unsigned char *c = buf;
391 assert(is_sysex_byte(status));
395 message_length = expected_sysex_length(status, c, buffer_length - 1, &vlq_length);
397 if (message_length < 0)
402 if (vlq_length + (size_t)message_length >= buffer_length) {
403 g_critical("End of buffer in extract_sysex_event().");
407 event->midi_buffer_length = message_length;
408 event->midi_buffer = malloc(event->midi_buffer_length);
409 if (event->midi_buffer == NULL) {
410 g_critical("Cannot allocate memory in extract_sysex_event(): %s", strerror(errno));
414 event->midi_buffer[0] = status;
415 memcpy(event->midi_buffer + 1, c, message_length - 1);
417 *len = vlq_length + message_length;
423 extract_escaped_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
428 int32_t message_length = 0;
429 int32_t vlq_length = 0;
430 const unsigned char *c = buf;
434 assert(is_escape_byte(status));
438 message_length = expected_escaped_length(status, c, buffer_length - 1, &vlq_length);
440 if (message_length < 0)
445 if (vlq_length + (size_t)message_length >= buffer_length) {
446 g_critical("End of buffer in extract_escaped_event().");
450 event->midi_buffer_length = message_length;
451 event->midi_buffer = malloc(event->midi_buffer_length);
452 if (event->midi_buffer == NULL) {
453 g_critical("Cannot allocate memory in extract_escaped_event(): %s", strerror(errno));
457 memcpy(event->midi_buffer, c, message_length);
459 if (smf_event_is_valid(event)) {
460 g_critical("Escaped event is invalid.");
464 if (smf_event_is_system_realtime(event) || smf_event_is_system_common(event)) {
465 g_warning("Escaped event is not System Realtime nor System Common.");
468 *len = vlq_length + message_length;
475 * Puts MIDI data extracted from from "buf" into "event" and number of consumed bytes into "len".
476 * In case valid status is not found, it uses "last_status" (so called "running status").
477 * Returns 0 iff everything went OK, value < 0 in case of error.
480 extract_midi_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
483 int32_t message_length;
484 const unsigned char *c = buf;
486 assert(buffer_length > 0);
488 /* Is the first byte the status byte? */
489 if (is_status_byte(*c)) {
494 /* No, we use running status then. */
495 status = last_status;
498 if (!is_status_byte(status)) {
499 g_critical("SMF error: bad status byte (MSB is zero).");
503 if (is_sysex_byte(status))
504 return (extract_sysex_event(buf, buffer_length, event, len, last_status));
506 if (is_escape_byte(status))
507 return (extract_escaped_event(buf, buffer_length, event, len, last_status));
509 /* At this point, "c" points to first byte following the status byte. */
510 message_length = expected_message_length(status, c, buffer_length - (c - buf));
512 if (message_length < 0)
515 if ((size_t)message_length > buffer_length - (c - buf) + 1) {
516 g_critical("End of buffer in extract_midi_event().");
520 event->midi_buffer_length = message_length;
521 event->midi_buffer = malloc(event->midi_buffer_length);
522 if (event->midi_buffer == NULL) {
523 g_critical("Cannot allocate memory in extract_midi_event(): %s", strerror(errno));
527 event->midi_buffer[0] = status;
528 memcpy(event->midi_buffer + 1, c, message_length - 1);
530 *len = c + message_length - 1 - buf;
536 * Locates, basing on track->next_event_offset, the next event data in track->buffer,
537 * interprets it, allocates smf_event_t and fills it properly. Returns smf_event_t
538 * or NULL, if there was an error. Allocating event means adding it to the track;
539 * see smf_event_new().
542 parse_next_event(smf_track_t *track)
546 size_t buffer_length;
547 unsigned char *c, *start;
549 smf_event_t *event = smf_event_new();
553 c = start = (unsigned char *)track->file_buffer + track->next_event_offset;
555 assert(track->file_buffer != NULL);
556 assert(track->file_buffer_length > 0);
557 assert(track->next_event_offset > 0);
559 buffer_length = track->file_buffer_length - track->next_event_offset;
560 assert(buffer_length > 0);
562 /* First, extract time offset from previous event. */
563 if (smf_extract_vlq(c, buffer_length, &time, &len))
567 buffer_length -= len;
569 if (buffer_length <= 0)
572 /* Now, extract the actual event. */
573 if (extract_midi_event(c, buffer_length, event, &len, track->last_status))
577 buffer_length -= len;
578 track->last_status = event->midi_buffer[0];
579 track->next_event_offset += c - start;
581 smf_track_add_event_delta_pulses(track, event, time);
587 smf_event_delete(event);
593 * Takes "len" characters starting in "buf", making sure it does not access past the length of the buffer,
594 * and makes ordinary, zero-terminated string from it. May return NULL if there was any problem.
597 make_string(const unsigned char *buf, const size_t buffer_length, uint32_t len)
601 assert(buffer_length > 0);
604 if (len > buffer_length) {
605 g_critical("End of buffer in make_string().");
610 str = malloc(len + 1);
612 g_critical("Cannot allocate memory in make_string().");
616 memcpy(str, buf, len);
623 * \return 1, if passed a metaevent containing text, that is, Text, Copyright,
624 * Sequence/Track Name, Instrument, Lyric, Marker, Cue Point, Program Name,
625 * or Device Name; 0 otherwise.
628 smf_event_is_textual(const smf_event_t *event)
630 if (!smf_event_is_metadata(event))
633 if (event->midi_buffer_length < 4)
636 if (event->midi_buffer[3] < 1 && event->midi_buffer[3] > 9)
643 * Extracts text from "textual metaevents", such as Text or Lyric.
645 * \return Zero-terminated string extracted from "text events" or NULL, if there was any problem.
648 smf_event_extract_text(const smf_event_t *event)
650 uint32_t string_length = 0;
651 uint32_t length_length = 0;
653 if (!smf_event_is_textual(event))
656 if (event->midi_buffer_length < 3) {
657 g_critical("smf_event_extract_text: truncated MIDI message.");
661 smf_extract_vlq((void *)&(event->midi_buffer[2]), event->midi_buffer_length - 2, &string_length, &length_length);
663 if (string_length <= 0) {
664 g_critical("smf_event_extract_text: truncated MIDI message.");
668 return (make_string((void *)(&event->midi_buffer[2] + length_length), event->midi_buffer_length - 2 - length_length, string_length));
672 * Verify if the next chunk really is MTrk chunk, and if so, initialize some track variables and return 0.
673 * Return different value otherwise.
676 parse_mtrk_header(smf_track_t *track)
678 struct chunk_header_struct *mtrk;
680 /* Make sure compiler didn't do anything stupid. */
681 assert(sizeof(struct chunk_header_struct) == 8);
682 assert(track->smf != NULL);
684 mtrk = next_chunk(track->smf);
689 if (!chunk_signature_matches(mtrk, "MTrk")) {
690 g_warning("SMF warning: Expected MTrk signature, got %c%c%c%c instead; ignoring this chunk.",
691 mtrk->id[0], mtrk->id[1], mtrk->id[2], mtrk->id[3]);
696 track->file_buffer = mtrk;
697 track->file_buffer_length = sizeof(struct chunk_header_struct) + ntohl(mtrk->length);
698 track->next_event_offset = sizeof(struct chunk_header_struct);
704 * Return 1 if event is end-of-the-track, 0 otherwise.
707 event_is_end_of_track(const smf_event_t *event)
709 if (event->midi_buffer[0] == 0xFF && event->midi_buffer[1] == 0x2F)
716 * \return Nonzero, if event is as long as it should be, from the MIDI specification point of view.
717 * Does not work for SysExes - it doesn't recognize internal structure of SysEx.
720 smf_event_length_is_valid(const smf_event_t *event)
723 assert(event->midi_buffer);
727 if (event->midi_buffer_length < 1)
730 /* We cannot use expected_message_length on sysexes. */
731 if (smf_event_is_sysex(event))
735 expected = expected_message_length(event->midi_buffer[0],
736 &(event->midi_buffer[1]), event->midi_buffer_length - 1);
737 if (expected < 0 || event->midi_buffer_length != (size_t)expected) {
745 * \return Nonzero, if MIDI data in the event is valid, 0 otherwise. For example,
746 * it checks if event length is correct.
748 /* XXX: this routine requires some more work to detect more errors. */
750 smf_event_is_valid(const smf_event_t *event)
753 assert(event->midi_buffer);
754 assert(event->midi_buffer_length >= 1);
756 if (!is_status_byte(event->midi_buffer[0])) {
757 g_critical("First byte of MIDI message is not a valid status byte.");
762 if (!smf_event_length_is_valid(event))
769 * Parse events and put it on the track.
772 parse_mtrk_chunk(smf_track_t *track)
776 if (parse_mtrk_header(track))
780 event = parse_next_event(track);
782 /* Couldn't parse an event? */
786 assert(smf_event_is_valid(event));
788 if (event_is_end_of_track(event))
792 track->file_buffer = NULL;
793 track->file_buffer_length = 0;
794 track->next_event_offset = -1;
800 * Allocate buffer of proper size and read file contents into it.
803 load_file_into_buffer(void **file_buffer, size_t *file_buffer_length, FILE* stream)
807 if (stream == NULL) {
808 g_critical("Cannot open input file: %s", strerror(errno));
813 if (fseek(stream, 0, SEEK_END)) {
814 g_critical("fseek(3) failed: %s", strerror(errno));
819 offset = ftell(stream);
821 g_critical("ftell(3) failed: %s", strerror(errno));
825 *file_buffer_length = (size_t)offset;
827 if (fseek(stream, 0, SEEK_SET)) {
828 g_critical("fseek(3) failed: %s", strerror(errno));
833 *file_buffer = malloc(*file_buffer_length);
834 if (*file_buffer == NULL) {
835 g_critical("malloc(3) failed: %s", strerror(errno));
840 if (fread(*file_buffer, 1, *file_buffer_length, stream) != *file_buffer_length) {
841 g_critical("fread(3) failed: %s", strerror(errno));
850 * Creates new SMF and fills it with data loaded from the given buffer.
851 * \return SMF or NULL, if loading failed.
854 smf_load_from_memory(const void *buffer, const size_t buffer_length)
858 smf_t *smf = smf_new();
860 smf->file_buffer = (void *)buffer;
861 smf->file_buffer_length = buffer_length;
862 smf->next_chunk_offset = 0;
864 if (parse_mthd_chunk(smf))
867 for (i = 1; i <= smf->expected_number_of_tracks; i++) {
868 smf_track_t *track = smf_track_new();
872 smf_add_track(smf, track);
874 /* Skip unparseable chunks. */
875 if (parse_mtrk_chunk(track)) {
876 g_warning("SMF warning: Cannot load track.");
877 smf_track_delete(track);
881 track->file_buffer = NULL;
882 track->file_buffer_length = 0;
883 track->next_event_offset = -1;
886 if (smf->expected_number_of_tracks != smf->number_of_tracks) {
887 g_warning("SMF warning: MThd header declared %d tracks, but only %d found; continuing anyway.",
888 smf->expected_number_of_tracks, smf->number_of_tracks);
890 smf->expected_number_of_tracks = smf->number_of_tracks;
893 smf->file_buffer = NULL;
894 smf->file_buffer_length = 0;
895 smf->next_chunk_offset = 0;
903 * \param file Open file.
904 * \return SMF or NULL, if loading failed.
909 size_t file_buffer_length;
913 if (load_file_into_buffer(&file_buffer, &file_buffer_length, file))
916 smf = smf_load_from_memory(file_buffer, file_buffer_length);
918 memset(file_buffer, 0, file_buffer_length);