blob: da8d149178dbd1319a487840b52793a0e5247193 [file] [log] [blame] [raw]
/*
* A simple MIDI parsing library
*
* Copyright (C) 2014-2022 Mateusz Viste
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <string.h> /* memcpy() */
#include "bitfield.h"
#include "fio.h"
#include "mem.h"
#include "midi.h" /* include self for control */
#define BSWAPL(x) ((((unsigned long)(x) & 0x000000FFul) << 24) | (((unsigned long)(x) & 0x0000FF00ul) << 8) | (((unsigned long)(x) & 0x00FF0000ul) >> 8) | (((unsigned long)(x) & 0xFF000000ul) >> 24))
extern unsigned char wbuff[];
/* PRIVATE ROUTINES USED FOR INTERNAL PROCESSING ONLY */
/* fetch a variable length quantity value from a given offset. returns number of bytes read */
static int midi_fetch_variablelen_fromfile(struct fiofile_t *f, unsigned long *result) {
unsigned char bytebuff;
int offset = 0;
*result = 0;
for (;;) {
fio_read(f, &bytebuff, 1);
*result <<= 7;
*result |= (bytebuff & 127);
if ((bytebuff & 128) == 0) break;
}
return(offset);
}
/* reads a MIDI file and computes a map of chunks (ie a list of offsets) */
static int midi_gettrackmap(struct fiofile_t *f, unsigned long *tracklist, int maxchunks) {
short i;
unsigned long ulvar;
for (i = 0; i < maxchunks; i++) {
/* read and validate chunk's id */
if (fio_read(f, &ulvar, 4) != 4) break;
if (ulvar != 0x6b72544dL) return(-1); /* if header != "MTrk" */
/* compute the track's byte length */
if (fio_read(f, &ulvar, 4) != 4) break;
ulvar = BSWAPL(ulvar);
/* remember chunk data offset */
tracklist[i] = fio_seek(f, FIO_SEEK_CUR, 0);
/* skip to next chunk */
fio_seek(f, FIO_SEEK_CUR, ulvar);
}
return(i);
}
/* PUBLIC INTERFACE */
int midi_readhdr(struct fiofile_t *f, int *format, unsigned short *timeunitdiv, unsigned long *tracklist, int maxtracks) {
unsigned short tracks;
/*
* Here's an example of a complete MThd chunk:
* 4D 54 68 64 MThd ID
* 00 00 00 06 Length of the MThd chunk is always 6
* 00 01 The Format type is 1
* 00 02 There are 2 MTrk chunks in this file
* E7 28 Each increment of delta-time represents a millisecond
*/
/* test for RMID header */
/* a RMID file starts with RIFFxxxxRMID (xxxx being the data size) followed
* by the word 'data' followed by a 32-bit data size. */
/* read first 14 bytes - if unable, return an error */
if (fio_read(f, wbuff, 14) != 14) return(-8);
/* if no RMID header, then assume it's normal MIDI */
if ((wbuff[0] == 'R') && (wbuff[1] == 'I') && (wbuff[2] == 'F') && (wbuff[3] == 'F')
&& (wbuff[8] == 'R') && (wbuff[9] == 'M') && (wbuff[10] == 'I') && (wbuff[11] == 'D')) {
/* skip 6 bytes and there we should have our MThd MIDI header */
fio_seek(f, FIO_SEEK_CUR, 6);
if (fio_read(f, wbuff, 14) != 14) return(-7);
}
/* check id (MThd) and len (must be exactly 6 bytes) */
if ((((unsigned long *)wbuff)[0] != 0x6468544dL) || (wbuff[4] != 0) || (wbuff[5] != 0) || (wbuff[6] != 0) || (wbuff[7] != 6)) { /* 0x6468544dL == "MThd" */
return(-6);
}
if (wbuff[8] != 0) return(-5); /* format is 1 or 2 so 1st digit must be 0 */
*format = wbuff[9];
tracks = wbuff[10];
tracks <<= 8;
tracks |= wbuff[11];
/* midi_gettrackmap() should not try reading more tracks than declared in
* the header - some MIDI/RMI files may be trailed with some extra stuff */
if (tracks < maxtracks) maxtracks = tracks;
*timeunitdiv = wbuff[12];
*timeunitdiv <<= 8;
*timeunitdiv |= wbuff[13];
/* timeunitdiv must be a positive number */
if (*timeunitdiv < 1) return(-3);
/* default tempo -> quarter note (1 beat) == 500'000 microseconds (0.5s), ie 120 bpm.
a delta time unit is therefore (0.5s / DIV) long. */
if (*format > 2) return(-2);
/* read the tracks map and return number of tracks */
return(midi_gettrackmap(f, tracklist, maxtracks));
}
/* returns a negative value on error, 0 on success, 1 on end of track */
#ifdef DBGFILE
static int ld_meta(struct midi_event_t *event, struct fiofile_t *f, FILE *logfd, unsigned long *tracklen, char *title, int titlemaxlen, char *copyright, int copyrightmaxlen, char *text, int textmaxlen) {
#else
static int ld_meta(struct midi_event_t *event, struct fiofile_t *f, unsigned long *tracklen, char *title, int titlemaxlen, char *copyright, int copyrightmaxlen, char *text, int textmaxlen) {
#endif
unsigned long metalen;
unsigned long i;
int result = 0;
unsigned char subtype;
fio_read(f, &subtype, 1); /* fetch the META subtype fields */
midi_fetch_variablelen_fromfile(f, &metalen);
/* printf("got META[0x%02X] of %ld bytes\n", subtype, metalen); */
switch (subtype) {
case 1: /* text or marker - often used to describe the file... */
case 6: /* marker */
i = 0;
if ((text != NULL) && (text[0] == 0) && (textmaxlen > 3)) { /* title might be NULL */
for (; i < metalen; i++) {
if (i+1 >= textmaxlen) break; /* avoid overflow */
fio_read(f, text + i, 1);
}
text[i] = 0;
/* recompute the available maxlen */
text += i;
textmaxlen -= i;
/* add a LF trailer, just in case we'd like to append more data */
if (textmaxlen > 2) {
*text = '\n';
text++;
*text = 0;
textmaxlen--;
}
}
/* skip the rest, if we had to truncate the string */
fio_seek(f, FIO_SEEK_CUR, metalen - i);
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: TEXT OR MARKER EVENT\n", *tracklen);
#endif
break;
case 2: /* copyright notice */
i = 0;
if ((copyright != NULL) && (copyright[0] == 0)) { /* take care, copyright might be NULL */
for (; i < metalen; i++) {
if (i+1 >= copyrightmaxlen) break; /* avoid overflow */
fio_read(f, copyright + i, 1);
}
copyright[i] = 0;
}
fio_seek(f, FIO_SEEK_CUR, metalen - i); /* skip the rest, if we had to truncate the string */
break;
case 3: /* track name */
i = 0;
if (title != NULL) { /* title might be NULL */
for (; i < metalen; i++) {
if (i+1 >= titlemaxlen) break; /* avoid overflow */
fio_read(f, title + i, 1);
}
title[i] = 0;
}
fio_seek(f, FIO_SEEK_CUR, metalen - i); /* skip the rest, if we had to truncate the string */
break;
case 4: /* instrument name */
fio_seek(f, FIO_SEEK_CUR, metalen);
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: INSTRUMENT EVENT (ignored)\n", *tracklen);
#endif
break;
case 5: /* lyric */
fio_seek(f, FIO_SEEK_CUR, metalen);
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: LYRIC EVENT (ignored)\n", *tracklen);
#endif
break;
case 0x21: /* MIDI port -- no support for multi-MIDI files, I just ignore it */
fio_seek(f, FIO_SEEK_CUR, metalen);
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: MIDI PORT EVENT (ignored)\n", *tracklen);
#endif
break;
case 0x2F: /* end of track */
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: END OF TRACK\n", *tracklen);
#endif
result = 1;
break;
case 0x51: /* set tempo */
if (metalen != 3) {
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: TEMPO ERROR\n", *tracklen);
#endif
return(-1);
} else {
unsigned char b[3];
event->type = EVENT_TEMPO;
fio_read(f, b, 3);
event->data.tempoval = b[0];
event->data.tempoval <<= 8;
event->data.tempoval |= b[1];
event->data.tempoval <<= 8;
event->data.tempoval |= b[2];
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: TEMPO -> %lu\n", *tracklen, event->data.tempoval);
#endif
}
break;
case 0x54: /* SMPTE offset -> since I expect only format 0/1 files, I ignore this because I want to start playing asap anyway */
fio_seek(f, FIO_SEEK_CUR, metalen);
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: SMPTE OFFSET (ignored)\n", *tracklen);
#endif
break;
case 0x58: /* Time signature */
if (metalen != 4) {
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: INVALID TIME SIGNATURE!\n", *tracklen);
#endif
return(-1);
} else {
fio_seek(f, FIO_SEEK_CUR, metalen);
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: TIME SIGNATURE (ignored)\n", *tracklen);
#endif
}
break;
case 0x59: /* key signature */
if (metalen != 2) {
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: INVALID KEY SIGNATURE!\n", *tracklen);
#endif
return(-1);
} else {
fio_seek(f, FIO_SEEK_CUR, metalen);
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: KEY SIGNATURE (ignored)\n", *tracklen);
#endif
}
break;
case 0x7F: /* proprietary event -> this is non-standard stuff, I ignore it */
fio_seek(f, FIO_SEEK_CUR, metalen);
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: PROPRIETARY EVENT (ignored)\n", *tracklen);
#endif
break;
default:
fio_seek(f, FIO_SEEK_CUR, metalen); /* skip the meta data */
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: UNHANDLED META EVENT [0x%02Xh] (ignored)\n", *tracklen, subtype);
#endif
break;
}
return(result);
}
/* returns a negative value on error, 0 on success, 1 on end of track */
#ifdef DBGFILE
static int ld_sysex(struct midi_event_t *event, struct fiofile_t *f, FILE *logfd, unsigned char statusbyte, unsigned long *tracklen) {
#else
static int ld_sysex(struct midi_event_t *event, struct fiofile_t *f, unsigned char statusbyte, unsigned long *tracklen) {
#endif
unsigned long sysexlen;
int sysexleneven; /* can be int, guaranteed to be less than 4K */
unsigned char *sysexbuff;
midi_fetch_variablelen_fromfile(f, &sysexlen); /* get length */
sysexlen += 1; /* add one byte for the status byte that is not counted, but that we will add to the top of the buffer later */
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: SYSEX EVENT OF %ld BYTES ON CHAN #%d\n", *tracklen, sysexlen, statusbyte & 0x0F);
#endif
if (sysexlen > 4096) { /* skip SYSEX events that are more than 4K big */
fio_seek(f, FIO_SEEK_CUR, sysexlen);
return(0);
}
/* read the sysex string */
sysexleneven = sysexlen + 2; /* add two bytes for the sysex length that I will add in front of the actual sysex string */
if ((sysexleneven & 1) != 0) sysexleneven++; /* make sysexleneven an even number (XMS moves MUST occur on even numbers of bytes) */
sysexbuff = wbuff;
event->type = EVENT_SYSEX;
((unsigned short *)sysexbuff)[0] = sysexlen;
sysexbuff[2] = statusbyte; /* I store the entire sysex string in memory */
fio_read(f, sysexbuff + 3, sysexlen - 1); /* read sysexlen-1 because I have already read the status byte */
event->data.sysex.sysexptr = mem_alloc(sysexleneven);
if (event->data.sysex.sysexptr >= 0) {
mem_push(sysexbuff, event->data.sysex.sysexptr, sysexleneven);
} else {
event->type = EVENT_NONE;
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: SYSEX MEM_ALLOC FAILED FOR %ld BYTES\n", *tracklen, sysexlen);
#endif
return(MIDI_OUTOFMEM);
}
return(0);
}
#ifdef DBGFILE
static int ld_note(struct midi_event_t *event, struct fiofile_t *f, FILE *logfd, unsigned char statusbyte, unsigned long *tracklen, unsigned short *channelsusage, void *reqpatches) {
#else
static int ld_note(struct midi_event_t *event, struct fiofile_t *f, unsigned char statusbyte, unsigned long *tracklen, unsigned short *channelsusage, void *reqpatches) {
#endif
unsigned char ubuff[2]; /* micro buffer for loading data */
switch (statusbyte & 0xF0) { /* I care only about NoteOn/NoteOff events */
case 0x80: /* Note OFF */
fio_read(f, ubuff, 2);
event->type = EVENT_NOTEOFF;
event->data.note.chan = statusbyte & 0x0F;
event->data.note.note = ubuff[0] & 127; /* a note must be in range 0..127 */
event->data.note.velocity = ubuff[1];
break;
case 0x90: /* Note ON */
fio_read(f, ubuff, 2);
event->type = EVENT_NOTEON;
event->data.note.chan = statusbyte & 0x0F;
event->data.note.note = ubuff[0] & 127;
event->data.note.velocity = ubuff[1];
if (event->data.note.velocity == 0) {
event->type = EVENT_NOTEOFF; /* if no velocity, it's in fact a note OFF */
} else {
*channelsusage |= (1 << event->data.note.chan); /* update the channel usage flags */
}
/* if it's percussion, mark the required patch */
if (event->data.note.chan == 9) BIT_SET(reqpatches, event->data.note.note | 128);
break;
case 0xA0: /* key after-touch */
fio_read(f, ubuff, 2);
event->type = EVENT_KEYPRESSURE;
event->data.keypressure.chan = statusbyte & 0x0F;
event->data.keypressure.note = ubuff[0];
event->data.keypressure.pressure = ubuff[1];
break;
case 0xB0: /* control change */
fio_read(f, ubuff, 2);
event->type = EVENT_CONTROL;
event->data.control.chan = statusbyte & 0x0F;
event->data.control.id = ubuff[0];
event->data.control.val = ubuff[1];
break;
case 0xC0: /* program (patch) change */
fio_read(f, ubuff, 1);
event->type = EVENT_PROGCHAN;
event->data.prog.chan = statusbyte & 0x0F;
event->data.prog.prog = ubuff[0] & 127;
BIT_SET(reqpatches, event->data.prog.prog);
break;
case 0xD0: /* channel after-touch (aka "channel pressure") */
fio_read(f, ubuff, 1);
event->type = EVENT_CHANPRESSURE;
event->data.chanpressure.chan = statusbyte & 0x0F;
event->data.chanpressure.pressure = ubuff[0];
break;
case 0xE0: /* pitch wheel change */
fio_read(f, ubuff, 2);
event->type = EVENT_PITCH;
event->data.pitch.chan = statusbyte & 0x0F;
event->data.pitch.wheel = ubuff[1];
event->data.pitch.wheel <<= 7;
event->data.pitch.wheel |= ubuff[0];
break;
default:
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "%lu: Unknown note data\n", *tracklen);
#endif
return(-1);
break;
}
return(0);
}
/* parse a track object and returns the id of the first events in the linked
* list. channelsusage contains 16 flags indicating what channels are used.
* titlemaxlen and copyrightmaxlen are the maximum lengths of the strings,
* including the NULL terminator.
* returns MIDI_EMPTYTRACK if no event found in the track
* returns MIDI_TRACKERROR if the track is corrupted
* returns MIDI_OUTOFMEM if failed to store events in memory */
#ifdef DBGFILE
long midi_track2events(struct fiofile_t *f, char *title, int titlemaxlen, char *copyright, int copyrightmaxlen, char *text, int textmaxlen, unsigned short *channelsusage, FILE *logfd, unsigned long *tracklen, void *reqpatches) {
#else
long midi_track2events(struct fiofile_t *f, char *title, int titlemaxlen, char *copyright, int copyrightmaxlen, char *text, int textmaxlen, unsigned short *channelsusage, unsigned long *tracklen, void *reqpatches) {
#endif
unsigned long deltatime;
unsigned char statusbyte = 0;
struct midi_event_t event;
long result = MIDI_EMPTYTRACK;
unsigned long ignoreddeltas = 0;
/* zero out title and copyright strings, if provided */
if (titlemaxlen > 0) title[0] = 0;
if (copyrightmaxlen > 0) copyright[0] = 0;
if (textmaxlen > 0) text[0] = 0;
*tracklen = 0;
for (;;) {
int r;
unsigned char bytebuff;
/* read the delta time first - variable length */
midi_fetch_variablelen_fromfile(f, &deltatime);
*tracklen += deltatime;
/* check the type of the event */
/* if it's a byte with MSB set, we are dealing with running status (so it's same status as last time */
if (fio_read(f, &bytebuff, 1) == 0) return(MIDI_TRACKERROR);
if ((bytebuff & 128) != 0) {
statusbyte = bytebuff;
} else { /* get back one byte */
fio_seek(f, FIO_SEEK_CUR, -1);
}
event.type = EVENT_NONE;
event.deltatime = deltatime;
event.next = -1;
if (statusbyte == 0xFF) { /* META event */
#ifdef DBGFILE
r = ld_meta(&event, f, logfd, tracklen, title, titlemaxlen, copyright, copyrightmaxlen, text, textmaxlen);
#else
r = ld_meta(&event, f, tracklen, title, titlemaxlen, copyright, copyrightmaxlen, text, textmaxlen);
#endif
if (r < 0) return(MIDI_TRACKERROR);
if (r == 1) break; /* end of track */
} else if ((statusbyte >= 0xF0) && (statusbyte <= 0xF7)) { /* SYSEX event */
#ifdef DBGFILE
r = ld_sysex(&event, f, logfd, statusbyte, tracklen);
#else
r = ld_sysex(&event, f, statusbyte, tracklen);
#endif
if (r != 0) return(MIDI_TRACKERROR);
} else if ((statusbyte >= 0x80) && (statusbyte <= 0xEF)) { /* else it's a note-related command */
#ifdef DBGFILE
r = ld_note(&event, f, logfd, statusbyte, tracklen, channelsusage, reqpatches);
#else
r = ld_note(&event, f, statusbyte, tracklen, channelsusage, reqpatches);
#endif
if (r != 0) return(MIDI_TRACKERROR);
} else { /* else it's an error - free memory we allocated and return NULL */
#ifdef DBGFILE
if (logfd != NULL) fprintf(logfd, "Err. at offset %04lX (bytebuff = 0x%02X)\n", fio_seek(f, FIO_SEEK_CUR, 0), statusbyte);
#endif
return(MIDI_TRACKERROR);
}
/* add the event to the queue */
if (event.type == EVENT_NONE) {
ignoreddeltas += event.deltatime;
} else {
int pusheventres;
event.deltatime += ignoreddeltas; /* add any previously ignored delta times */
ignoreddeltas = 0;
/* add the event to the queue */
if (result == MIDI_EMPTYTRACK) { /* this is the first event in the queue */
pusheventres = pusheventqueue(&event, &result);
} else {
pusheventres = pusheventqueue(&event, NULL);
}
if (pusheventres != 0) {
return(MIDI_OUTOFMEM);
}
}
}
if (result >= 0) {
if (pusheventqueue(NULL, NULL) != 0) return(MIDI_OUTOFMEM); /* flush last event in buffer to memory */
}
return(result);
}
/* merge two MIDI tracks into a single (serialized) one. returns a "pointer"
* to the unique track. I take care not to allocate/free memory here.
* All notes are already in RAM after all. totlen is filled with the total
* time of the merged tracks (in seconds). */
long midi_mergetrack(long t0, long t1, unsigned long *totlen, unsigned short timeunitdiv) {
long res = -1, lasteventid = -1, selectedid;
int selected;
unsigned long curtempo = 500000l, utotlen = 0;
struct midi_event_t event[2], lastevent;
if (totlen != NULL) *totlen = 0;
/* fetch first events for both tracks */
if (t0 >= 0) mem_pull(t0, &event[0], sizeof(struct midi_event_t));
if (t1 >= 0) mem_pull(t1, &event[1], sizeof(struct midi_event_t));
/* start looping */
while ((t0 >= 0) || (t1 >= 0)) {
/* compare both tracks, and select the soonest one */
if (t0 >= 0) {
if ((t1 >= 0) && (event[1].deltatime < event[0].deltatime)) {
selected = 1;
selectedid = t1;
} else {
selected = 0;
selectedid = t0;
}
} else {
selected = 1;
selectedid = t1;
}
/* on first iteration, make sure to assign a result */
if (lasteventid < 0) {
res = selectedid;
} else if (lastevent.next != selectedid) { /* otherwise attach selected */
lastevent.next = selectedid; /* track to last note, and */
mem_push(&lastevent, lasteventid, sizeof(struct midi_event_t)); /* update last pointer (if */
} /* not good already) */
/* save the last event into buffer for later, and remember its id */
lasteventid = selectedid;
memcpy(&lastevent, &(event[selected]), sizeof(struct midi_event_t));
/* increment timer */
if ((totlen != NULL) && (event[selected].deltatime != 0)) {
utotlen += DELTATIME2US(event[selected].deltatime, curtempo, timeunitdiv);
while (utotlen >= 1000000lu) {
utotlen -= 1000000lu;
*totlen += 1;
}
}
if (event[selected].type == EVENT_TEMPO) curtempo = event[selected].data.tempoval;
/* decrement timer on the non-selected track, and synch it to xms if needed */
/* then move along on the selected track, and fetch it from xms */
if (selected == 0) {
if ((t1 >= 0) && (event[0].deltatime != 0)) {
event[1].deltatime -= event[0].deltatime;
mem_push(&event[1], t1, sizeof(struct midi_event_t));
}
t0 = event[0].next;
if (t0 >= 0) mem_pull(t0, &event[0], sizeof(struct midi_event_t));
} else { /* selected == 1 */
if ((t0 >= 0) && (event[1].deltatime != 0)) {
event[0].deltatime -= event[1].deltatime;
mem_push(&event[0], t0, sizeof(struct midi_event_t));
}
t1 = event[1].next;
if (t1 >= 0) mem_pull(t1, &event[1], sizeof(struct midi_event_t));
}
}
return(res);
}