aboutsummaryrefslogtreecommitdiff
path: root/shared/common/mifi.c
diff options
context:
space:
mode:
Diffstat (limited to 'shared/common/mifi.c')
-rw-r--r--shared/common/mifi.c524
1 files changed, 270 insertions, 254 deletions
diff --git a/shared/common/mifi.c b/shared/common/mifi.c
index ad16b3b..b2fea10 100644
--- a/shared/common/mifi.c
+++ b/shared/common/mifi.c
@@ -19,12 +19,8 @@
#include "common/bifi.h"
#include "common/mifi.h"
-#if 1
#define MIFI_VERBOSE
-#if 0
#define MIFI_DEBUG
-#endif
-#endif
#define MIFI_SHORTEST_EVENT 2 /* singlebyte delta and one databyte */
#define MIFI_EVENT_NALLOC 32 /* LATER do some research (average max?) */
@@ -51,56 +47,57 @@ typedef struct _mifi_trackheader
/* reading helpers */
-static void mifi_earlyeof(t_mifi_stream *x)
+static void mifi_earlyeof(t_mifi_stream *sp)
{
- x->s_bytesleft = 0;
- x->s_eof = 1;
+ sp->s_bytesleft = 0;
+ sp->s_eof = 1;
}
/* Get next byte from track data.
- On error: return 0 (which is a valid result) and set x->s_eof.
+ On error: return 0 (which is a valid result) and set sp->s_eof.
*/
-static uchar mifi_getbyte(t_mifi_stream *x)
+static uchar mifi_getbyte(t_mifi_stream *sp)
{
- if (x->s_bytesleft)
+ if (sp->s_bytesleft)
{
int c;
- if ((c = fgetc(x->s_fp)) == EOF)
+ if ((c = fgetc(sp->s_fp)) == EOF)
{
- mifi_earlyeof(x);
+ mifi_earlyeof(sp);
return (0);
}
- else {
- x->s_bytesleft--;
+ else
+ {
+ sp->s_bytesleft--;
return ((uchar)c);
}
}
else return (0);
}
-static uint32 mifi_readbytes(t_mifi_stream *x, uchar *buf, uint32 size)
+static uint32 mifi_readbytes(t_mifi_stream *sp, uchar *buf, uint32 size)
{
size_t res;
- if (size > x->s_bytesleft)
- size = x->s_bytesleft;
- if ((res = fread(buf, 1, (size_t)size, x->s_fp)) == size)
- x->s_bytesleft -= res;
+ if (size > sp->s_bytesleft)
+ size = sp->s_bytesleft;
+ if ((res = fread(buf, 1, (size_t)size, sp->s_fp)) == size)
+ sp->s_bytesleft -= res;
else
- mifi_earlyeof(x);
+ mifi_earlyeof(sp);
return (res);
}
-static int mifi_skipbytes(t_mifi_stream *x, uint32 size)
+static int mifi_skipbytes(t_mifi_stream *sp, uint32 size)
{
- if (size > x->s_bytesleft)
- size = x->s_bytesleft;
+ if (size > sp->s_bytesleft)
+ size = sp->s_bytesleft;
if (size)
{
- int res = fseek(x->s_fp, size, SEEK_CUR);
+ int res = fseek(sp->s_fp, size, SEEK_CUR);
if (res < 0)
- mifi_earlyeof(x);
+ mifi_earlyeof(sp);
else
- x->s_bytesleft -= size;
+ sp->s_bytesleft -= size;
return res;
}
else return (0);
@@ -108,7 +105,7 @@ static int mifi_skipbytes(t_mifi_stream *x, uint32 size)
/* helpers handling variable-length quantities */
-static size_t mifi_writevarlen(t_mifi_stream *x, uint32 n)
+static size_t mifi_writevarlen(t_mifi_stream *sp, uint32 n)
{
uint32 buf = n & 0x7f;
size_t length = 1;
@@ -119,18 +116,18 @@ static size_t mifi_writevarlen(t_mifi_stream *x, uint32 n)
buf += n & 0x7f;
length++;
}
- return ((fwrite(&buf, 1, length, x->s_fp) == length) ? length : 0);
+ return ((fwrite(&buf, 1, length, sp->s_fp) == length) ? length : 0);
}
-static uint32 mifi_readvarlen(t_mifi_stream *x)
+static uint32 mifi_readvarlen(t_mifi_stream *sp)
{
uint32 n = 0;
uchar c;
- uint32 count = x->s_bytesleft;
+ uint32 count = sp->s_bytesleft;
if (count > 4) count = 4;
while (count--)
{
- n = (n << 7) + ((c = mifi_getbyte(x)) & 0x7f);
+ n = (n << 7) + ((c = mifi_getbyte(sp)) & 0x7f);
if ((c & 0x80) == 0)
break;
}
@@ -139,14 +136,14 @@ static uint32 mifi_readvarlen(t_mifi_stream *x)
/* other helpers */
-static int mifi_read_start_track(t_mifi_stream *x)
+static int mifi_read_start_track(t_mifi_stream *sp)
{
t_mifi_trackheader header;
long skip;
int notyet = 1;
do {
if (fread(&header, 1,
- MIFI_TRACKHEADER_SIZE, x->s_fp) < MIFI_TRACKHEADER_SIZE)
+ MIFI_TRACKHEADER_SIZE, sp->s_fp) < MIFI_TRACKHEADER_SIZE)
goto nomoretracks;
header.h_length = bifi_swap4(header.h_length);
if (strncmp(header.h_type, "MTrk", 4))
@@ -154,29 +151,29 @@ static int mifi_read_start_track(t_mifi_stream *x)
char buf[5];
strncpy(buf, header.h_type, 4);
buf[5] = '\0';
- if (x->s_anapass)
+ if (sp->s_anapass)
post("unknown chunk %s in midifile -- skipped", buf);
}
else if (header.h_length < MIFI_SHORTEST_EVENT)
{
- if (x->s_anapass) post("empty track in midifile -- skipped");
+ if (sp->s_anapass) post("empty track in midifile -- skipped");
}
else notyet = 0;
if (notyet && (skip = header.h_length) &&
- fseek(x->s_fp, skip, SEEK_CUR) < 0)
+ fseek(sp->s_fp, skip, SEEK_CUR) < 0)
goto nomoretracks;
} while (notyet);
- x->s_track++;
- x->s_newtrack = 1;
- x->s_status = x->s_channel = 0;
- x->s_bytesleft = header.h_length;
- x->s_time = 0;
+ sp->s_track++;
+ sp->s_newtrack = 1;
+ sp->s_status = sp->s_channel = 0;
+ sp->s_bytesleft = header.h_length;
+ sp->s_time = 0;
return (1);
nomoretracks:
- if (x->s_track == 0)
- if (x->s_anapass) post("no valid miditracks");
+ if (sp->s_track == 0)
+ if (sp->s_anapass) post("no valid miditracks");
return (0);
}
@@ -184,37 +181,48 @@ nomoretracks:
t_mifi_event *mifi_event_new(void)
{
- t_mifi_event *e = getbytes(sizeof(*e));
- if (e && !(e->e_data = getbytes(e->e_bufsize = MIFI_EVENT_NALLOC)))
+ t_mifi_event *ep = getbytes(sizeof(*ep));
+ if (ep && !(ep->e_data = getbytes(ep->e_bufsize = MIFI_EVENT_NALLOC)))
{
- freebytes(e, sizeof(*e));
+ freebytes(ep, sizeof(*ep));
return (0);
}
- return (e);
+ return (ep);
}
-void mifi_event_free(t_mifi_event *e)
+void mifi_event_free(t_mifi_event *ep)
{
- freebytes(e->e_data, e->e_bufsize);
- freebytes(e, sizeof(*e));
+ freebytes(ep->e_data, ep->e_bufsize);
+ freebytes(ep, sizeof(*ep));
}
-int mifi_event_settext(t_mifi_event *e, int type, char *text)
+int mifi_event_settext(t_mifi_event *ep, int type, char *text)
{
- e->e_delay = 0;
- e->e_status = MIFI_EVENT_META;
- e->e_meta = type;
- e->e_length = strlen(text);
- if (squb_checksize(e, e->e_length + 1, 1) <= e->e_length)
+ ep->e_delay = 0;
+ ep->e_status = MIFI_EVENT_META;
+ ep->e_meta = type;
+ ep->e_length = strlen(text);
+ if (squb_checksize(ep, ep->e_length + 1, 1) <= ep->e_length)
{
- e->e_length = 0;
+ ep->e_length = 0;
return (0);
}
- strcpy(e->e_data, text);
+ strcpy(ep->e_data, text);
return (1);
}
-void mifi_event_printmeta(t_mifi_event *e)
+#ifdef MIFI_DEBUG
+static void mifi_event_printsysex(t_mifi_event *ep)
+{
+ int length = ep->e_length;
+ uchar *dp = ep->e_data;
+ startpost("sysex:");
+ while (length--) postfloat((float)*dp++);
+ endpost();
+}
+#endif
+
+void mifi_event_printmeta(t_mifi_event *ep)
{
static int isprintable[MIFI_META_MAXPRINTABLE+1] =
{
@@ -229,67 +237,67 @@ void mifi_event_printmeta(t_mifi_event *e)
"", "text: %s", "copyright: %s", "track name: %s",
"instrument name: %s", "lyric: %s", "marker: %s", "cue point: %s"
};
- if (e->e_meta <= MIFI_META_MAXPRINTABLE)
+ if (ep->e_meta <= MIFI_META_MAXPRINTABLE)
{
- if (isprintable[e->e_meta] && printformat[e->e_meta])
- post(printformat[e->e_meta], e->e_data);
+ if (isprintable[ep->e_meta] && printformat[ep->e_meta])
+ post(printformat[ep->e_meta], ep->e_data);
}
#ifdef MIFI_DEBUG /* in verbose mode tempo printout done only after sorting */
- else if (e->e_meta == MIFI_META_TEMPO)
+ else if (ep->e_meta == MIFI_META_TEMPO)
{
- int tempo = bifi_swap4(*(uint32*)e->e_data);
- post("tempo %d after %d", tempo, e->e_delay);
+ int tempo = bifi_swap4(*(uint32 *)ep->e_data);
+ post("tempo %d after %d", tempo, ep->e_delay);
}
#endif
}
-void mifi_stream_reset(t_mifi_stream *x)
+void mifi_stream_reset(t_mifi_stream *sp)
{
- sq_reset(x);
- x->s_status = x->s_channel = 0;
- x->s_timecoef = sq_msecs2ticks(x, 0);
- x->s_bytesleft = 0;
+ sq_reset(sp);
+ sp->s_status = sp->s_channel = 0;
+ sp->s_timecoef = sq_msecs2ticks(sp, 0);
+ sp->s_bytesleft = 0;
}
t_mifi_stream *mifi_stream_new(void)
{
- t_mifi_stream *x = sq_new();
- if (x)
+ t_mifi_stream *sp = sq_new();
+ if (sp)
{
- if (x->s_auxeve = mifi_event_new())
+ if (sp->s_auxeve = mifi_event_new())
{
- x->s_hdtracks = 1;
- x->s_alltracks = 0;
- mifi_stream_reset(x); /* LATER avoid calling sq_reset() twice */
+ sp->s_hdtracks = 1;
+ sp->s_alltracks = 0;
+ mifi_stream_reset(sp); /* LATER avoid calling sq_reset() twice */
}
else
{
- mifi_stream_free(x);
+ mifi_stream_free(sp);
return (0);
}
}
- return (x);
+ return (sp);
}
-void mifi_stream_free(t_mifi_stream *x)
+void mifi_stream_free(t_mifi_stream *sp)
{
- if (x->s_auxeve)
- mifi_event_free(x->s_auxeve);
- sq_free(x);
+ if (sp->s_auxeve)
+ mifi_event_free(sp->s_auxeve);
+ sq_free(sp);
}
/* Open midifile for reading, parse the header. May be used as t_mifi_stream
- allocator (if x is a null pointer), to be freed by mifi_read_end() or
+ allocator (if sp is a null pointer), to be freed by mifi_read_end() or
explicitly.
- Return value: null on error, else x if passed a valid pointer, else pointer
+ Return value: null on error, else sp if passed a valid pointer, else pointer
to an allocated structure.
*/
-t_mifi_stream *mifi_read_start(t_mifi_stream *x,
+t_mifi_stream *mifi_read_start(t_mifi_stream *sp,
const char *filename, const char *dirname,
int complain)
{
- t_mifi_stream *result = x;
+ t_mifi_stream *result = sp;
t_bifi bifi;
t_bifi *bp = &bifi;
t_mifi_header header;
@@ -315,7 +323,7 @@ t_mifi_stream *mifi_read_start(t_mifi_stream *x,
}
/* since we will tolerate other incompatibilities, now we can allocate */
- if (x) mifi_stream_reset(x);
+ if (sp) mifi_stream_reset(sp);
else
{
if (!(result = mifi_stream_new()))
@@ -340,121 +348,124 @@ badheader:
if (complain)
post("`%s\' is not a valid midifile", filename);
badstart:
- if (result && !x) mifi_stream_free(result);
+ if (result && !sp) mifi_stream_free(result);
bifi_free(bp);
return (0);
}
-int mifi_read_restart(t_mifi_stream *x)
+int mifi_read_restart(t_mifi_stream *sp)
{
- FILE *fp = x->s_fp;
- mifi_stream_reset(x);
- x->s_anapass = 0;
- x->s_fp = fp;
+ FILE *fp = sp->s_fp;
+ mifi_stream_reset(sp);
+ sp->s_anapass = 0;
+ sp->s_fp = fp;
return (fseek(fp, 0, SEEK_SET) ? 0 : 1);
}
/* Close midifile and free t_mifi_stream if it was allocated
by mifi_read_start() */
-void mifi_read_end(t_mifi_stream *x)
+void mifi_read_end(t_mifi_stream *sp)
{
- if (x->s_fp) fclose(x->s_fp);
- if (x->s_autoalloc) mifi_stream_free(x);
+ if (sp->s_fp) fclose(sp->s_fp);
+ if (sp->s_autoalloc) mifi_stream_free(sp);
}
/* Read next event from midifile.
Return value: see #defines in mifi.h.
*/
-int mifi_read_event(t_mifi_stream *x, t_mifi_event *e)
+int mifi_read_event(t_mifi_stream *sp, t_mifi_event *ep)
{
uchar status, channel;
uint32 length;
- x->s_newtrack = 0;
+ sp->s_newtrack = 0;
nextattempt:
- if (x->s_bytesleft < MIFI_SHORTEST_EVENT && !mifi_read_start_track(x))
+ if (sp->s_bytesleft < MIFI_SHORTEST_EVENT && !mifi_read_start_track(sp))
return (MIFI_READ_EOF);
- x->s_time += (e->e_delay = mifi_readvarlen(x));
+ sp->s_time += (ep->e_delay = mifi_readvarlen(sp));
- if ((status = mifi_getbyte(x)) < 0x80)
+ if ((status = mifi_getbyte(sp)) < 0x80)
{
- if (MIFI_IS_CHANNEL(x->s_status))
+ if (MIFI_IS_CHANNEL(sp->s_status))
{
- e->e_data[0] = status;
- e->e_length = 1;
- status = x->s_status;
- e->e_channel = x->s_channel;
+ ep->e_data[0] = status;
+ ep->e_length = 1;
+ status = sp->s_status;
+ ep->e_channel = sp->s_channel;
}
- else {
- if (x->s_anapass)
- post("missing running status in midifile -- skip to end of track");
+ else
+ {
+ if (sp->s_anapass)
+ post("missing running status in midifile -- \
+ skip to end of track");
goto endoftrack;
}
}
- else e->e_length = 0;
+ else ep->e_length = 0;
/* channel message */
if (status < 0xf0)
{
- if (e->e_length == 0)
+ if (ep->e_length == 0)
{
- e->e_data[0] = mifi_getbyte(x);
- e->e_length = 1;
- x->s_status = status & 0xf0;
- x->s_channel = e->e_channel = status & 0x0f;
- status = x->s_status;
+ ep->e_data[0] = mifi_getbyte(sp);
+ ep->e_length = 1;
+ sp->s_status = status & 0xf0;
+ sp->s_channel = ep->e_channel = status & 0x0f;
+ status = sp->s_status;
}
if (!MIFI_ONE_DATABYTE(status))
{
- e->e_data[1] = mifi_getbyte(x);
- e->e_length = 2;
+ ep->e_data[1] = mifi_getbyte(sp);
+ ep->e_length = 2;
}
}
/* system exclusive */
else if (status == MIFI_SYSEX_FIRST || status == MIFI_SYSEX_NEXT)
{
- /* LATER choose the right way --
- do we really need all those huge bulk dumps? */
- length = mifi_readvarlen(x);
- if (squb_checksize(e, length, 1) < length)
+ length = mifi_readvarlen(sp);
+ if (squb_checksize(ep, length, 1) < length)
{
- if (mifi_skipbytes(x, length) < 0)
+ if (mifi_skipbytes(sp, length) < 0)
return (MIFI_READ_FATAL);
goto nextattempt;
}
- if (mifi_readbytes(x, e->e_data, length) != length)
+ /* LATER make the allocation optional */
+ if (mifi_readbytes(sp, ep->e_data, length) != length)
return (MIFI_READ_FATAL);
- e->e_length = length;
-#ifdef MIFI_VERBOSE
- if (x->s_anapass) post("got %d bytes of sysex", length);
+ ep->e_length = length;
+#ifdef MIFI_DEBUG
+ if (sp->s_anapass) mifi_event_printsysex(ep);
+#elif defined MIFI_VERBOSE
+ if (sp->s_anapass) post("got %d bytes of sysex", length);
#endif
}
/* meta-event */
else if (status == MIFI_EVENT_META)
{
- e->e_meta = mifi_getbyte(x);
- length = mifi_readvarlen(x);
- if (e->e_meta > 127)
+ ep->e_meta = mifi_getbyte(sp);
+ length = mifi_readvarlen(sp);
+ if (ep->e_meta > 127)
{
/* try to skip corrupted meta-event (quietly) */
#ifdef MIFI_VERBOSE
- if (x->s_anapass) post("bad meta: %d > 127", e->e_meta);
+ if (sp->s_anapass) post("bad meta: %d > 127", ep->e_meta);
#endif
- if (mifi_skipbytes(x, length) < 0)
+ if (mifi_skipbytes(sp, length) < 0)
return (MIFI_READ_FATAL);
goto nextattempt;
}
- switch (e->e_meta)
+ switch (ep->e_meta)
{
case MIFI_META_EOT:
if (length)
{
/* corrupted eot: ignore and skip to the real end of track */
#ifdef MIFI_VERBOSE
- if (x->s_anapass) post("corrupted eot, length %d", length);
+ if (sp->s_anapass) post("corrupted eot, length %d", length);
#endif
goto endoftrack;
}
@@ -462,39 +473,40 @@ nextattempt:
case MIFI_META_TEMPO:
if (length != 3)
{
- if (x->s_anapass)
+ if (sp->s_anapass)
post("corrupted event in midifile -- skip to end of track");
goto endoftrack;
}
- if (mifi_readbytes(x, e->e_data+1, 3) != 3)
+ if (mifi_readbytes(sp, ep->e_data + 1, 3) != 3)
return (MIFI_READ_FATAL);
- e->e_data[0] = 0;
- x->s_tempo = bifi_swap4(*(uint32*)e->e_data);
+ ep->e_data[0] = 0;
+ sp->s_tempo = bifi_swap4(*(uint32 *)ep->e_data);
break;
default:
- if (squb_checksize(e, length + 1, 1) <= length)
+ if (squb_checksize(ep, length + 1, 1) <= length)
{
- if (mifi_skipbytes(x, length) < 0)
+ if (mifi_skipbytes(sp, length) < 0)
return (MIFI_READ_FATAL);
goto nextattempt;
}
- if (mifi_readbytes(x, e->e_data, length) != length)
+ if (mifi_readbytes(sp, ep->e_data, length) != length)
return (MIFI_READ_FATAL);
- e->e_length = length;
- if (e->e_meta && e->e_meta <= MIFI_META_MAXPRINTABLE)
- e->e_data[length] = '\0'; /* text meta-event nultermination */
+ ep->e_length = length;
+ if (ep->e_meta && ep->e_meta <= MIFI_META_MAXPRINTABLE)
+ ep->e_data[length] = '\0'; /* text meta-event nultermination */
}
}
- else {
- if (x->s_anapass)
+ else
+ {
+ if (sp->s_anapass)
post("unknown event type in midifile -- skip to end of track");
goto endoftrack;
}
- return ((e->e_status = status) == MIFI_EVENT_META ? e->e_meta : status);
+ return ((ep->e_status = status) == MIFI_EVENT_META ? ep->e_meta : status);
endoftrack:
- if (mifi_skipbytes(x, x->s_bytesleft) < 0)
+ if (mifi_skipbytes(sp, sp->s_bytesleft) < 0)
return (MIFI_READ_FATAL);
return (MIFI_READ_SKIP);
}
@@ -503,9 +515,9 @@ endoftrack:
allocate the maps. To be called in the first pass of reading.
*/
/* LATER consider optional reading of nonchannel events */
-int mifi_read_analyse(t_mifi_stream *x)
+int mifi_read_analyse(t_mifi_stream *sp)
{
- t_mifi_event *evp = x->s_auxeve;
+ t_mifi_event *ep = sp->s_auxeve;
int evtype, result = MIFI_READ_FATAL;
int isnewtrack = 0;
int i;
@@ -514,18 +526,18 @@ int mifi_read_analyse(t_mifi_stream *x)
t_squack *trp = 0;
*tnamebuf = '\0';
- x->s_alltracks = x->s_ntracks = 0;
- x->s_nevents = 0;
- x->s_ntempi = 0;
+ sp->s_alltracks = sp->s_ntracks = 0;
+ sp->s_nevents = 0;
+ sp->s_ntempi = 0;
- while ((evtype = mifi_read_event(x, evp)) >= MIFI_READ_SKIP)
+ while ((evtype = mifi_read_event(sp, ep)) >= MIFI_READ_SKIP)
{
if (evtype == MIFI_READ_SKIP)
continue;
- if (x->s_newtrack)
+ if (sp->s_newtrack)
{
#ifdef MIFI_VERBOSE
- post("track %d", x->s_track);
+ post("track %d", sp->s_track);
#endif
isnewtrack = 1;
*tnamebuf = '\0';
@@ -536,8 +548,8 @@ int mifi_read_analyse(t_mifi_stream *x)
if (isnewtrack)
{
isnewtrack = 0;
- x->s_alltracks++;
- if (!(trp = squax_add(x)))
+ sp->s_alltracks++;
+ if (!(trp = squax_add(sp)))
goto anafail;
if (*tnamebuf)
{
@@ -548,23 +560,23 @@ int mifi_read_analyse(t_mifi_stream *x)
}
else tnamesym = trp->tr_name = &s_;
}
- x->s_nevents++;
+ sp->s_nevents++;
}
else if (evtype < 0x80)
{
- mifi_event_printmeta(evp);
+ mifi_event_printmeta(ep);
if (evtype == MIFI_META_TEMPO)
- x->s_ntempi++;
+ sp->s_ntempi++;
else if (evtype == MIFI_META_TRACKNAME)
{
- char *p1 = evp->e_data;
+ char *p1 = ep->e_data;
if (*p1 &&
!*tnamebuf) /* take the first one */
{
while (*p1 == ' ') p1++;
if (*p1)
{
- char *p2 = evp->e_data + evp->e_length - 1;
+ char *p2 = ep->e_data + ep->e_length - 1;
while (p2 > p1 && *p2 == ' ') *p2-- = '\0';
p2 = p1;
do if (*p2 == ' ' || *p2 == ',' || *p2 == ';')
@@ -584,22 +596,22 @@ int mifi_read_analyse(t_mifi_stream *x)
if (evtype != MIFI_READ_EOF)
goto anafail;
- i = x->s_ntracks;
+ i = sp->s_ntracks;
while (--i >= 0)
{
- if (!x->s_track_name(i) || x->s_track_name(i) == &s_)
+ if (!sp->s_track_name(i) || sp->s_track_name(i) == &s_)
{
sprintf(tnamebuf, "%d-track", i);
- x->s_track_name(i) = gensym(tnamebuf);
+ sp->s_track_name(i) = gensym(tnamebuf);
}
}
/* now (re)allocate the buffers */
- if (squb_checksize(x->s_mytempi,
- x->s_ntempi, sizeof(t_squmpo)) < x->s_ntempi)
+ if (squb_checksize(sp->s_mytempi,
+ sp->s_ntempi, sizeof(t_squmpo)) < sp->s_ntempi)
goto anafail;
- x->s_track_nevents(0) = 0;
- x->s_track_nevents(x->s_ntracks) = x->s_nevents; /* guard point */
+ sp->s_track_nevents(0) = 0;
+ sp->s_track_nevents(sp->s_ntracks) = sp->s_nevents; /* guard point */
result = evtype;
anafail:
@@ -608,32 +620,32 @@ anafail:
/* To be called in second pass of reading */
/* LATER do not trust analysis: in case of inconsistency give up or checksize */
-int mifi_read_doit(t_mifi_stream *x)
+int mifi_read_doit(t_mifi_stream *sp)
{
- t_mifi_event *evp = x->s_auxeve;
- t_squiter *it = x->s_myiter;
+ t_mifi_event *ep = sp->s_auxeve;
+ t_squiter *it = sp->s_myiter;
t_squiter_seekhook seekhook = squiter_seekhook(it);
t_squiter_incrhook incrhook = squiter_incrhook(it);
t_squiter_setevehook evehook = squiter_setevehook(it);
t_squiter_settimhook timhook = squiter_settimhook(it);
t_squiter_settarhook tarhook = squiter_settarhook(it);
int evtype, result = MIFI_READ_FATAL;
- int nevents = x->s_nevents; /* three proxies... */
- int ntracks = x->s_ntracks;
- int ntempi = x->s_ntempi;
+ int nevents = sp->s_nevents; /* three proxies... */
+ int ntracks = sp->s_ntracks;
+ int ntempi = sp->s_ntempi;
int trackno = 0;
t_symbol *trackname = 0;
int isnewtrack = 0;
- t_squmpo *tp = x->s_tempomap;
+ t_squmpo *tp = sp->s_tempomap;
if (!it || !seekhook(it, 0))
goto readfailed;
- while ((evtype = mifi_read_event(x, evp)) >= MIFI_READ_SKIP)
+ while ((evtype = mifi_read_event(sp, ep)) >= MIFI_READ_SKIP)
{
if (evtype == MIFI_READ_SKIP)
continue;
- if (x->s_newtrack)
+ if (sp->s_newtrack)
isnewtrack = 1;
if (MIFI_IS_CHANNEL(evtype))
{
@@ -641,7 +653,7 @@ int mifi_read_doit(t_mifi_stream *x)
if (isnewtrack)
{
isnewtrack = 0;
- trackname = x->s_track_name(trackno);
+ trackname = sp->s_track_name(trackno);
trackno++;
if (!trackname || trackname == &s_)
{
@@ -649,17 +661,18 @@ int mifi_read_doit(t_mifi_stream *x)
trackname = gensym("bug-track");
}
}
- x->s_track_nevents(trackno)++;
+ sp->s_track_nevents(trackno)++;
if (ret = squiter_inrange(it))
{
- evehook(it, (t_squeve *)evp, &ret);
+ evehook(it, (t_squeve *)ep, &ret);
/* We store onset times instead of delta times, because:
1) some deltas may represent delays since nonchannel events;
2) we'll need onsets while merging the tracks. */
- if (ret) timhook(it, (t_float)x->s_time, &ret);
+ if (ret) timhook(it, (t_float)sp->s_time, &ret);
if (ret) tarhook(it, trackname, &ret);
}
- if (ret) incrhook(it);
+ if (ret)
+ incrhook(it);
else
goto readfailed;
}
@@ -667,8 +680,8 @@ int mifi_read_doit(t_mifi_stream *x)
{
if (evtype == MIFI_META_TEMPO)
{
- tp->te_onset = x->s_time;
- tp->te_value = x->s_tempo;
+ tp->te_onset = sp->s_time;
+ tp->te_value = sp->s_tempo;
tp++;
}
}
@@ -682,16 +695,16 @@ readfailed:
}
/* Open midifile for saving, write the header. May be used as t_mifi_stream
- allocator (if x is a null pointer), to be freed by mifi_write_end() or
+ allocator (if sp is a null pointer), to be freed by mifi_write_end() or
explicitly.
- Return value: null on error, else x if passed a valid pointer, else pointer
+ Return value: null on error, else sp if passed a valid pointer, else pointer
to allocated structure.
*/
-t_mifi_stream *mifi_write_start(t_mifi_stream *x,
+t_mifi_stream *mifi_write_start(t_mifi_stream *sp,
const char *filename, const char *dirname)
{
- t_mifi_stream *result = x;
+ t_mifi_stream *result = sp;
t_bifi bifi;
t_bifi *bp = &bifi;
t_mifi_header header;
@@ -699,36 +712,38 @@ t_mifi_stream *mifi_write_start(t_mifi_stream *x,
/* this must precede bifi_swap() calls */
bifi_new(bp, (char *)&header, MIFI_HEADER_SIZE);
- if (x->s_format == 0)
+ if (sp->s_format == 0)
{
- if (x->s_ntracks != 1)
+ if (sp->s_ntracks != 1)
goto startfailure; /* LATER replace with a warning only? */
#ifdef MIFI_VERBOSE
post("writing singletrack midifile %s", filename);
#endif
}
#ifdef MIFI_VERBOSE
- else post("writing midifile %s (%d tracks)", filename, x->s_ntracks);
+ else post("writing midifile %s (%d tracks)", filename, sp->s_ntracks);
#endif
strncpy(header.h_type, "MThd", 4);
header.h_length = bifi_swap4(MIFI_HEADERDATA_SIZE);
- if (x)
+ if (sp)
{
- if (!x->s_hdtracks || !x->s_nticks)
+ if (!sp->s_hdtracks || !sp->s_nticks)
goto startfailure;
- header.h_format = bifi_swap2(x->s_format);
- header.h_ntracks = bifi_swap2(x->s_hdtracks);
- if (x->s_nframes)
- header.h_division = ((x->s_nframes << 8) | x->s_nticks) | 0x8000;
+ header.h_format = bifi_swap2(sp->s_format);
+ header.h_ntracks = bifi_swap2(sp->s_hdtracks);
+ if (sp->s_nframes)
+ header.h_division = ((sp->s_nframes << 8) | sp->s_nticks) | 0x8000;
else
- header.h_division = x->s_nticks & 0x7fff;
+ header.h_division = sp->s_nticks & 0x7fff;
header.h_division = bifi_swap2(header.h_division);
}
- else {
+ else
+ {
header.h_format = 0;
header.h_ntracks = bifi_swap2(1);
- header.h_division = bifi_swap2(192); /* LATER parametrize this somehow */
+ /* LATER parametrize this somehow */
+ header.h_division = bifi_swap2(192);
}
if (!bifi_write_start(bp, filename, dirname))
@@ -738,7 +753,7 @@ t_mifi_stream *mifi_write_start(t_mifi_stream *x,
return (0);
}
- if (x) mifi_stream_reset(x);
+ if (sp) mifi_stream_reset(sp);
else
{
if (!(result = mifi_stream_new()))
@@ -750,39 +765,39 @@ t_mifi_stream *mifi_write_start(t_mifi_stream *x,
return (result);
startfailure:
- if (result && !x) mifi_stream_free(result);
+ if (result && !sp) mifi_stream_free(result);
bifi_free(bp);
return (0);
}
/* Close midifile, free t_mifi_stream if it was allocated
by mifi_write_start(). */
-void mifi_write_end(t_mifi_stream *x)
+void mifi_write_end(t_mifi_stream *sp)
{
- if (x->s_autoalloc)
+ if (sp->s_autoalloc)
{
/* LATER adjust ntracks field in a file header, but do so only if
a stream was autoallocated -- number of tracks must be known
before calling mifi_write_start() for a preexisting stream. */
}
- if (x->s_fp) fclose(x->s_fp);
- if (x->s_autoalloc) mifi_stream_free(x);
+ if (sp->s_fp) fclose(sp->s_fp);
+ if (sp->s_autoalloc) mifi_stream_free(sp);
}
-int mifi_write_start_track(t_mifi_stream *x)
+int mifi_write_start_track(t_mifi_stream *sp)
{
t_mifi_trackheader header;
- /* LATER check if (x->s_track < x->s_hdtracks)... after some thinking */
+ /* LATER check if (sp->s_track < sp->s_hdtracks)... after some thinking */
strncpy(header.h_type, "MTrk", 4);
header.h_length = 0;
- x->s_trackid = x->s_track_id(x->s_track);
- x->s_track++;
- x->s_newtrack = 1;
- x->s_status = x->s_channel = 0;
- x->s_bytesleft = 0;
- x->s_time = 0;
+ sp->s_trackid = sp->s_track_id(sp->s_track);
+ sp->s_track++;
+ sp->s_newtrack = 1;
+ sp->s_status = sp->s_channel = 0;
+ sp->s_bytesleft = 0;
+ sp->s_time = 0;
if (fwrite(&header, 1,
- MIFI_TRACKHEADER_SIZE, x->s_fp) != MIFI_TRACKHEADER_SIZE)
+ MIFI_TRACKHEADER_SIZE, sp->s_fp) != MIFI_TRACKHEADER_SIZE)
{
post("unable to write midifile header");
return (0);
@@ -791,77 +806,78 @@ int mifi_write_start_track(t_mifi_stream *x)
}
/* append eot meta and update length field in a track header */
-int mifi_write_adjust_track(t_mifi_stream *x, uint32 eotdelay)
+int mifi_write_adjust_track(t_mifi_stream *sp, uint32 eotdelay)
{
- t_mifi_event *evp = x->s_auxeve;
+ t_mifi_event *ep = sp->s_auxeve;
long skip;
uint32 length;
- evp->e_delay = eotdelay;
- evp->e_status = MIFI_EVENT_META;
- evp->e_meta = MIFI_META_EOT;
- evp->e_length = 0;
- if (!mifi_write_event(x, evp))
+ ep->e_delay = eotdelay;
+ ep->e_status = MIFI_EVENT_META;
+ ep->e_meta = MIFI_META_EOT;
+ ep->e_length = 0;
+ if (!mifi_write_event(sp, ep))
return (0);
- skip = x->s_bytesleft + 4;
- length = bifi_swap4(x->s_bytesleft);
+ skip = sp->s_bytesleft + 4;
+ length = bifi_swap4(sp->s_bytesleft);
#ifdef MIFI_DEBUG
- post("adjusting track size to %d", x->s_bytesleft);
+ post("adjusting track size to %d", sp->s_bytesleft);
#endif
/* LATER add sanity check (compare to saved filepos) */
if (skip > 4 &&
- fseek(x->s_fp, -skip, SEEK_CUR) < 0 ||
- fwrite(&length, 1, 4, x->s_fp) != 4 ||
- fseek(x->s_fp, 0, SEEK_END) < 0)
+ fseek(sp->s_fp, -skip, SEEK_CUR) < 0 ||
+ fwrite(&length, 1, 4, sp->s_fp) != 4 ||
+ fseek(sp->s_fp, 0, SEEK_END) < 0)
{
- post("unable to adjust length field in midifile track header (length %d)",
- x->s_bytesleft);
+ post("unable to adjust length field in midifile track header \
+ (length %d)", sp->s_bytesleft);
return (0);
}
return (1);
}
/* LATER analyse shrinking effect caused by truncation */
-int mifi_write_event(t_mifi_stream *x, t_mifi_event *e)
+int mifi_write_event(t_mifi_stream *sp, t_mifi_event *ep)
{
uchar buf[3], *ptr = buf;
- size_t size = mifi_writevarlen(x, e->e_delay);
+ size_t size = mifi_writevarlen(sp, ep->e_delay);
if (!size)
return (0);
- x->s_bytesleft += size;
- if (MIFI_IS_CHANNEL(e->e_status))
+ sp->s_bytesleft += size;
+ if (MIFI_IS_CHANNEL(ep->e_status))
{
- if ((*ptr = e->e_status | e->e_channel) == x->s_status)
+ if ((*ptr = ep->e_status | ep->e_channel) == sp->s_status)
size = 1;
- else {
- x->s_status = *ptr++;
+ else
+ {
+ sp->s_status = *ptr++;
size = 2;
}
- *ptr++ = e->e_data[0];
- if (!MIFI_ONE_DATABYTE(e->e_status))
+ *ptr++ = ep->e_data[0];
+ if (!MIFI_ONE_DATABYTE(ep->e_status))
{
- *ptr = e->e_data[1];
+ *ptr = ep->e_data[1];
size++;
}
ptr = buf;
}
- else if (e->e_status == MIFI_EVENT_META)
+ else if (ep->e_status == MIFI_EVENT_META)
{
- x->s_status = 0; /* sysex and meta-events cancel any running status */
- buf[0] = e->e_status;
- buf[1] = e->e_meta;
- if (fwrite(buf, 1, 2, x->s_fp) != 2)
+ sp->s_status = 0; /* sysex and meta-events cancel any running status */
+ buf[0] = ep->e_status;
+ buf[1] = ep->e_meta;
+ if (fwrite(buf, 1, 2, sp->s_fp) != 2)
return (0);
- x->s_bytesleft += 2;
- size = mifi_writevarlen(x, (uint32)(e->e_length));
+ sp->s_bytesleft += 2;
+ size = mifi_writevarlen(sp, (uint32)(ep->e_length));
if (!size)
return (0);
- x->s_bytesleft += size;
- size = e->e_length;
- ptr = e->e_data;
+ sp->s_bytesleft += size;
+ size = ep->e_length;
+ ptr = ep->e_data;
}
else return (0);
- if (fwrite(ptr, 1, size, x->s_fp) != size)
+ if (fwrite(ptr, 1, size, sp->s_fp) != size)
return (0);
- x->s_bytesleft += size;
+ sp->s_bytesleft += size;
return (1);
}