Import upstream version 5.3.

[mup] / mup / mup / midiutil.c

/* Copyright (c) 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2005 by Arkkra Enterprises */
/* All rights reserved */

/* utility functions for creating MIDI output from Mup input. These functions
 * are split out into this file to keep midi.c from being so huge */

#ifdef __WATCOMC__
#include <io.h>
#endif
#include "defines.h"
#include "structs.h"
#include "globals.h"


static struct GRPSYL *create_prev_grp P((struct MAINLL *mll_p, int staffno,
		int v));
static struct GRPSYL *create_meas_space P((struct MAINLL *mll_p));
static void fix_spacechord P((struct MAINLL *chmll_p, struct CHORD *ch_p));
static void splitspace P((struct GRPSYL *gs_p, RATIONAL duration));
static void splicechord P((struct GRPSYL *gs_p, struct CHORD *ch_p));
static void guitar_grpsyl_transpose P((struct GRPSYL *gs_p));
static RATIONAL find_acc_end_time P((RATIONAL begin_time, struct GRPSYL *gs_p,
		int n));
static void propogate_accidental P((struct NOTE *note_p, RATIONAL begin_time,
		RATIONAL end_time, struct GRPSYL *gs_p));
static void mv_skipped_midi P((struct STUFF *stuff_p, int staffno,
		struct MAINLL *topstaff_mll_p));
\f

/* seek back to where header size is in file, and fill in the correct size,
 * now that we know what it is. */

void
fix_track_size(mfile, track_start, track_size)

int mfile;		/* file descriptor of MIDI file */
long track_start;	/* offset in file where size needs to be put */
long track_size;	/* track length in bytes */

{
	unsigned char buff[4];


	debug(512, "fix_track_size");

	/* go to where track size is stored in file */
	(void) lseek(mfile, track_start + 4, SEEK_SET);

	/* convert to 4-byte number with correct byte ordering regardless
	 * of machine byte ordering */
	buff[0] = (track_size >> 24) & 0xff;
	buff[1] = (track_size >> 16) & 0xff;
	buff[2] = (track_size >> 8) & 0xff;
	buff[3] = track_size & 0xff;
	(void) write(mfile, buff, 4);

	/* go back to end of file in case there are more track to write */
	(void) lseek(mfile, 0L, SEEK_END);
}
\f

/* given an octave mark string, return number of octaves to tranpose (could
 * be negative if transposing down) */

int
parse_octave(string, place, fname, lineno)

char *string;		/* typically "8va" */
int place;		/* PL_ABOVE or PL_BELOW */
char *fname;		/* file name for errors */
int lineno;
		

{
	int font, size;
	int octave_value = 0;
	int code;		/* ASCII of character in string */

	
	font = string[0];
	size = string[1];
	string += 2;
	code = next_str_char(&string, &font, &size);
	if (isdigit(code)) {
		octave_value = code - '0';
		code = next_str_char(&string, &font, &size);
		/* might be a second digit. If user is crazy enough to use
		 * an octave number greater than 2 digits, ignore the rest */
		if (isdigit(code)) {
			octave_value = (octave_value * 10) + (code - '0');
		}
	}

	/* must be either a non-zero multiple of 8, or things like 15, 22,
	 * etc if some musical mathematician adds 7 instead of 8 */
	if (octave_value < 8 || ((octave_value - 8) % 7 != 0 &&
				 (octave_value - 8) % 8 != 0)) {
		l_ufatal(fname, lineno, "invalid octave mark string");
	}
	if (octave_value % 8 == 0) {
		octave_value /= 8;
	} else {
		octave_value = 1 + (octave_value - 8) % 7;
	}

	return(place == PL_BELOW ? -octave_value : octave_value);
}
\f

/* determine "clocks per metronome tick." It not entirely clear to me
 * how that is supposed to work, but... if the time signature denominator is
 * 4, we'll use 24. If 8, use 12, etc. Only go down as far as 3, since that's
 * not divisible by 2. Really, in fast tempo triple time, the denominator
 * isn't the beat, but this will do for now. */

int
clocks(num)

int num;

{
	switch(num) {
	case 1:
		return(96);
	case 2:
		return(48);
	case 4:
		return(24);
	case 8:
		return(12);
	case 16:
		return(6);
	default:
		return(3);
	}
}
\f

/* given a string, if it contains a word followed by an =, followed by a word,
 * any of which may be separated by white space, return, via pointers,
 * a pointer to the beginning of the word, the length of the word, and a pointer
 * to the first non-white-space character after the =, and return YES.
 * Otherwise, return NO. A "word" is a sequence of non-white-space chars. */

int
getkeyword(string, key_p, leng_p, arg_p_p)

char *string;		/* check this string */
char **key_p;		/* return pointer to keyword via this */
int *leng_p;		/* return length of keyword via this */
char **arg_p_p;		/* return pointer to argument after = via this */

{
	char *tok;


	/* skip leading white space */
	for (*key_p = string; **key_p == ' ' || **key_p == '\t'; (*key_p)++) {
		;
	}

	/* go till hit white space or equals sign */
	for (tok = *key_p; *tok != '\0'; tok++) {
		if (*tok == ' ' || *tok == '\t' || *tok == '=') {
			break;
		}
	}

	/* fill in length of key */
	*leng_p = tok - *key_p;

	if (*leng_p == 0) {
		return(NO);
	}

	/* find first non-white beyond the = */
	for (   ; *tok != '\0'; tok++) {
		if (*tok == '=') {
			for (tok++; *tok != '\0'; tok++) {
				if (*tok != ' ' && *tok != '\t') {
					*arg_p_p = tok;
					return(YES);
				}
			}
		}
	}
	return(NO);
}
\f

/* given a user-specified key, see if it matches the given command name. Return
 * YES if it does, NO if it doesn't. User only has to specify the first 3 or
 * more characters of the command, because that's enough to make it unique,
 * and saves them from typing longer names. */

int
matches(key, leng, cmd)

char *key;		/* user specified key to be checked */
int leng;		/* length of key */
char *cmd;		/* check if key matches this command */

{
	if (leng < 3) {
		return(NO);
	}
	return(strncmp(key, cmd, leng) == 0 ? YES : NO);
}
\f

/* given an ASCII hex digit, return its value 0-15 */

int
hexdig(ch)

int ch;

{
	if (ch >= '0' && ch <= '9') {
		return(ch - '0');
	}
	else if (ch >= 'a' && ch <= 'f') {
		return(ch - 'a' + 10);
	}
	else if (ch >= 'A' && ch <= 'F') {
		return(ch - 'A' + 10);
	}
	pfatal("bad hex digit");
	/*NOTREACHED*/
	return(0);
}
\f

/* given a string, output it to midi file, prefixed by its length. */
/* return number of bytes written */

UINT32B
midi_wrstring(mfile, str, internalform)

int mfile;	/* MIDI file */
char *str;	/* string to write to file */
int internalform;	/* YES if str is in Mup format, NO if just ASCII,
			 * C-style null-terminated string to be copied */

{
	char *buff;		/* for all-ASCII version of str */
	UINT32B bytes;		/* number of bytes in length value */
	int length;		/* of string */


	/* get plain ascii version of string. Write out length of
	 * string, then plain string itself */
	if (internalform == YES) {
		buff = ascii_str(str, NO, YES, TM_NONE);
		length = strlen(buff);
		bytes = wr_varlength(mfile, (UINT32B) length);
		bytes += write(mfile, buff, (unsigned) length);
	}
	else {
		length = strlen(str);
		bytes = wr_varlength(mfile, (UINT32B) length);
		bytes += write(mfile, str, (unsigned) length);
	}

	/* return number of bytes written */
	return(bytes);
}
\f

/* given a number, write to MIDI file in MIDI variable length format.
 * Return number of bytes written. */

UINT32B
wr_varlength(mfile, num)

UINT32B num;

{
	unsigned char buff[4];
	int i;
	int shift;
	

	/* Because only 7 bits of each MIDI byte can be used,
	 * there is only support for numbers up to 28 bits long. */
	if ((num & 0xf0000000) != 0) {
		ufatal("midi value too large");
	}

	/* convert value to the MIDI variable-length number, which
	 * uses the lower 7 bits of each byte as parts of the number, and
	 * the high order bit as a flag to say which is the last byte of
	 * the (potentially) multi-byte number */
	for (i = 0, shift = 21; shift >= 7; shift -= 7) {
		if ( (num >> shift) || (i > 0)) {
			buff[i++] = 0x80 | ((num >> shift) & 0x7f);
		}
	}
	buff[i] = num & 0x7f;
	(void) write(mfile, buff, (unsigned) (i + 1));
	return (UINT32B) (i+1);
}
\f

/* do key signature. Return number of bytes written */

UINT32B
midi_keysig(mfile, sharps, is_minor)

int mfile;
int sharps;
int is_minor;	/* YES if minor */

{
	UINT32B bytes;
	unsigned char buff[8];


	bytes = write_delta(mfile);
	buff[0] = 0xff;
	buff[1] = 0x59;
	buff[2] = 0x02;
	buff[3] = (char) sharps;
	buff[4] = (is_minor == YES ? 1 : 0);
	(void) write(mfile, buff, 5);

	return(bytes + 5);
}
\f

/* write out the timesig in Score SSV. Return number of bytes written */

UINT32B
midi_timesig(mfile)

int mfile;
{
	UINT32B bytes;
	unsigned char buff[8];


	/* With additive time signatures, it is possible to get an effective
	 * time signature that won't fit in 7 bits. In that case, we don't
	 * do any time signature, since we can't represent it. */
	if (Score.timenum > 127) {
		return(0);
	}

	bytes = write_delta(mfile);
	buff[0] = 0xff;
	buff[1] = 0x58;
	buff[2] = 0x04;
	buff[3] = (char) Score.timenum;
	buff[4] = (unsigned char) drmo(Score.timeden);
	buff[5] = clocks(Score.timeden);
	buff[6] = 0x8;
	bytes += write(mfile, buff, 7);
	return(bytes);
}
\f

/* find group before given group. If none before it in current measure,
 * back up in main list to find corresponding group list, and use final group
 * in that list. If no group exists, create one. */

struct GRPSYL *
grp_before(gs_p, mll_p, staffno, v)

struct GRPSYL *gs_p;	/* find group before this one */
struct MAINLL *mll_p;	/* the list containing gs_p is attached to main list here */
int staffno;
int v;			/* voice */

{
	int found_bar = NO;


	if (gs_p->prev != (struct GRPSYL *) 0) {
		/* oh good. There's another group before this one in the
		 * current measure, so just return it */
		return(gs_p->prev);
	}

	/* have to go back to previous measure, if any. Start searching
	 * backwards in main list. */
	for (mll_p = mll_p->prev; mll_p != (struct MAINLL *) 0;
						mll_p = mll_p->prev) {
		switch (mll_p->str) {
		case S_STAFF:
			if (found_bar == NO) {
				/* still in current measure */
				break;
			}

			if (mll_p->u.staff_p->staffno == staffno) {
				/* we found the previous measure */
				if (mll_p->u.staff_p->groups_p[v]
						!= (struct GRPSYL *) 0) {
					/* find and return last group */
					for (gs_p=mll_p->u.staff_p->groups_p[v];
							gs_p->next !=
							(struct GRPSYL *) 0;
							gs_p = gs_p->next) {
						;
					}
					return(gs_p);
				}
				else {
					/* this voice wasn't present before.
					 * Will have to create a measure */
					return(create_meas_space(mll_p));
				}
			}
			else if (mll_p->u.staff_p->staffno < staffno) {
				/* corresponding staff does not exist in this
				 * measure. The only time this should happen is
				 * if user changed the number of staffs.
				 * So create staff */
				return(create_prev_grp(mll_p, staffno, v));
			}
			break;

		case S_BAR:
			found_bar = YES;
			break;

		default:
			/* ignore other things */
			break;
		}
	}

	/* Fell off the top of the list. This used to be possible,
	 * and we called create_prev_grp() to create a measure.
	 * But the measure really needs to be created much earlier--
	 * before makechords() is run--in order for squeezing to work right.
	 * So that's what we do now. So we should never get here. */
	pfatal("fell off top of list in grp_before()");
	/* NOTREACHED */
	return(create_prev_grp(mll_p, staffno, v));
}
\f

/* create a new STAFF struct and insert in main list, with grpcont of
 * space and fulltime of the measure. Return pointer to the GRPSYL of
 * appropriate voice of the STAFF that was created. */

static struct GRPSYL *
create_prev_grp(mll_p, staffno, v)

struct MAINLL *mll_p;	/* insert here */
int staffno;
int v;

{
	struct MAINLL *new_p;	/* new STAFF */
	int i;


	new_p = newMAINLLstruct(S_STAFF, -1);
	new_p->u.staff_p->staffno = (short) staffno;
	insertMAINLL(new_p, mll_p);
	for (i = 0; i < MAXVOICES; i++) {
		new_p->u.staff_p->groups_p[i]
					= create_meas_space(mll_p);
	}

	/* if added to beginning of list, have to add bar as well */
	if (mll_p == (struct MAINLL *) 0) {
		struct MAINLL *mbar_p;

		mbar_p = newMAINLLstruct(S_BAR, -1);
		insertMAINLL(mbar_p, new_p);
	}

	return(new_p->u.staff_p->groups_p[v]);
}
\f

/* create a measure space as long as that of the reference measure (or of 4/4
 * if no reference) and return it */

static struct GRPSYL *
create_meas_space(mll_p)

struct MAINLL *mll_p;	/* use this for reference to get measure length */

{
	struct GRPSYL *gs_p;	/* new grpsyl */
	struct GRPSYL *egs_p;	/* existing grpsyl */


	gs_p = newGRPSYL(GS_GROUP);
	gs_p->grpcont = GC_SPACE;

	/* figure out how much full time to give the group. If mll_p is not
 	 * null, we are adding a staff to an existing measure, so use
	 * length of its first voice. Count up the length of existing measure */
	gs_p->fulltime = Zero;
	if (mll_p != (struct MAINLL *) 0 && mll_p->str == S_STAFF) {
		for (egs_p = mll_p->u.staff_p->groups_p[0];
					egs_p != (struct GRPSYL *) 0;
					egs_p = egs_p->next) {

			gs_p->fulltime = radd(gs_p->fulltime, egs_p->fulltime);
		}
	}
	else {
		/* at beginning of list, use default  of 1/1 (the reduced
		 * form of 4/4) */
		gs_p->fulltime.n = gs_p->fulltime.d = 1;
	}

	return(gs_p);
} 
\f

/* add a rest of the specified fulltime duration after the specified group.
 * Since this is just for midi purposes, don't worry about filling in all
 * the fields. */

void
add_rest(gs_p, fulltime)

struct GRPSYL *gs_p;	/* add rest after this group */
RATIONAL fulltime;	/* make it this long */

{
	struct GRPSYL *newgs_p;


	if (gs_p == (struct GRPSYL *) 0) {
		pfatal("null group passed to add_rest");
	}

	newgs_p = newGRPSYL(GS_GROUP);
	newgs_p->grpcont = GC_REST;
	rred (&fulltime);
	newgs_p->fulltime = fulltime;
	newgs_p->next = gs_p->next;
	newgs_p->prev = gs_p;
	gs_p->next = newgs_p;
	if (newgs_p->next != (struct GRPSYL *) 0) {
		newgs_p->next->prev = newgs_p;
	}
}
\f

/* when all voices have space, that should be squeezed to zero time.
 * Go through main list. For each CHHEAD found,
 * go down the list of chords. For each chord, see if
 * if it is an all-space chord. If so, call fix_spacechord() to
 * handle it.
 */

void
midi_squeeze()

{
	struct MAINLL *mll_p;	/* walk through main list */
	struct CHORD *ch_p;	/* walk through list of chords */


	debug(256, "midi_squeeze");

	initstructs();
	for (mll_p = Mainllhc_p; mll_p != (struct MAINLL *) 0;
						mll_p = mll_p->next) {

		/* skip everything except CHHEADs and SSV updates */
		if (mll_p->str != S_CHHEAD) {
			if (mll_p->str == S_SSV) {
				asgnssv(mll_p->u.ssv_p);
			}
			continue;
		}

		/* do each chord */
		for (ch_p = mll_p->u.chhead_p->ch_p;
						ch_p != (struct CHORD *) 0;
						ch_p = ch_p->ch_p) {

			if (ch_p->width == 0.0) {
				/* found one to squeeze, do it */
				fix_spacechord(mll_p, ch_p);
			}
		}
	}
}
\f

/* given an all-space chord to crunch, split up any groups that
 * spill into this chord or extend beyond it. Then set the grpvalue of each
 * group in the chord to GV_ZERO.
 */

static void
fix_spacechord(chmll_p, ch_p)

struct MAINLL *chmll_p;		/* chord is hanging off this CHHEAD */
struct CHORD *ch_p;		/* zero-width chord */

{
	struct MAINLL *mll_p;	/* walk through STAFFs in main list */
	struct GRPSYL *gs_p;	/* walk through groups in chord */
	struct GRPSYL *group_p;	/* head of list of grpsyls in measure */
	RATIONAL minspacetime;	/* time of shortest space in chord */
	RATIONAL chordstart;	/* where in measure chord begins */
	RATIONAL chordend;	/* where the space ends */
	RATIONAL new_chordend;	/* tentative new value for chordend */
	RATIONAL grpstart;	/* where in measure grpsyl begins */
	int v;			/* voice index */


	/* first find the smallest duration in the chord. Can't use
	* ch_p->duration here because grace notes have been adjusted
	* by now to take some time */
	minspacetime = ch_p->gs_p->fulltime;
	for (gs_p = ch_p->gs_p->gs_p; gs_p != (struct GRPSYL *) 0;
						gs_p = gs_p->gs_p) {

		/* skip lyrics */
		if (gs_p->grpsyl == GS_SYLLABLE) {
			continue;
		}

		/* skip things on tab staff--we use the associated tabnotes
		 * staff instead */
		if (is_tab_staff(gs_p->staffno) == YES) {
			continue;
		}

		/* double check */
		if (gs_p->grpcont != GC_SPACE) {
			pfatal("non-space in zero-width chord");
		}

		/* find minimum time value of space */
		if (LT(gs_p->fulltime, minspacetime)) {
			minspacetime = gs_p->fulltime;
		}
	}

	/* find the start of the chord. Can't use ch_p->startime because
	 * we may have squeezed out time earlier in the measure and need
	 * to compensate for that. So have to count up the time before
	 * the group at the top of the chord. */
	for (chordstart = Zero, gs_p = ch_p->gs_p->prev;
				gs_p != (struct GRPSYL *) 0;
				gs_p = gs_p->prev) {
		chordstart = radd(chordstart, gs_p->fulltime);
	}

	/* if spaces are overlapped in strange ways between different
	 * voices, the minspacetime we found above may actually be too long.
	 * If the time between this chord and the next is less than the
	 * minspacetime found so far, make minspacetime the time till the
	 * next chord */
	if (ch_p->ch_p != (struct CHORD *) 0) {
		if (LT(rsub(ch_p->ch_p->starttime, chordstart), minspacetime)) {
			minspacetime = rsub(ch_p->ch_p->starttime, chordstart);
		}
	}

	/* That still isn't completely adequate to find where the space actually
	 * ends, because if there were lots of grace notes moved back into a
	 * space, and a very short space in another voice, they could overlap.
	 * So go through the list of voices, seeing where the real end is.
	 * This code is unfortunately very similar to the code below it,
	 * yet different enough to make it hard to make it
	 * into a common function. */
	chordend = radd(chordstart, minspacetime);
	for (mll_p = chmll_p->next; mll_p != (struct MAINLL *) 0;
						mll_p = mll_p->next) {

		/* CHHEAD is followed immediately by STAFFS, so when we
		 * hit something other than STAFF, we are done */
		if (mll_p->str != S_STAFF) {
			break;
		}

		/* do each voice */
		for (v = 0; v < MAXVOICES; v++ ) {
			/* Check if we have a special case where the actual
			 * space is shorter than we thought. We unfortunately
			 * cannot use hasspace() here, because it ignores grace
			 * notes, and by now, grace notes have some time.
			 * Find the chord that begins the space in question. */
			grpstart = Zero;

			if ((gs_p = mll_p->u.staff_p->groups_p[v])
						== (struct GRPSYL *) 0) {
				/* no voice here, so that's all space.
				 * That's good: we're done with this voice */
				continue;
			}

			/* grace notes at the beginning of the measure
			 * have effectively been moved timewise
			 * into previous measure, so discount them. */
			for (   ; gs_p->grpvalue == GV_ZERO
					&& gs_p->grpcont == GC_NOTES;
					gs_p = gs_p->next) {
				;
			}

			for (  ; gs_p != (struct GRPSYL *) 0;
							gs_p = gs_p->next) {

				/* see if this group start corresponds
				 * with start of chord, or spills into
				 * the chord or is the last chord. If
				 * so, that's the one we want. */
				if (EQ(grpstart, chordstart) ||
						GT(radd(grpstart,
						gs_p->fulltime),
						chordstart) ||
						gs_p->next ==
						(struct GRPSYL *) 0) {
					/* found appropriate group */
					break;
				}
				else {
					/* accummulate time so far */
					grpstart = radd(grpstart, gs_p->fulltime);
				}
			}

			if (gs_p == (struct GRPSYL *) 0) {
				pfatal("failed to find space group");
			}

			if (gs_p->grpcont != GC_SPACE) {
				/* things overlapped so much after the
				 * grace note adjustments and such
				 * that this isn't really a
				 * crunch-able chord after all. */
				return;
			}

			/* need to adjust amount of space we
			 * can really crunch. Find where this chord
			 * ends, and add in the time of any immediately
			 * following space groups. */
			new_chordend = radd(grpstart, gs_p->fulltime);
			for (gs_p = gs_p->next; gs_p != (struct GRPSYL *) 0;
						gs_p = gs_p->next) {

				if (gs_p->grpcont == GC_SPACE) {
					new_chordend = radd(new_chordend,
							gs_p->fulltime);
				}
				else {
					break;
				}
			}

			/* if the newly calculated end is sooner than
			 * what we had before, then adjust accordingly. */
			if (LT(new_chordend, chordend)) {
				chordend = new_chordend;
			}
		}
	}

	/* recalculate the minspace time after any adjustment */
	minspacetime = rsub(chordend, chordstart);
	

	/* go down each voice of each staff.
	 * For each, find the space group associated with the chord.
	 * If it has the same starttime as the chord and has minspacetime
	 * duration, it's easy: we just mark it GV_ZERO. Otherwise, if
	 * it starts earlier, we have to split off a group in the front
	 * first, and if it lasts longer than the end of the chord, we
	 * have to split off a group at the end first.
	 */
	for (mll_p = chmll_p->next; mll_p != (struct MAINLL *) 0;
						mll_p = mll_p->next) {
		/* CHHEAD is followed immediately by STAFFS, so when we
		 * hit something other than STAFF, we are done */
		if (mll_p->str != S_STAFF) {
			break;
		}

		/* do each voice */
		for (v = 0; v < MAXVOICES; v++ ) {

			/* get shorter name for list of grpsyls */
			group_p = mll_p->u.staff_p->groups_p[v];

			if (group_p == (struct GRPSYL *) 0) {
				continue;
			}

			/* go through groups, add up time till we find the
			 * group we're looking for */
			grpstart = Zero;

			/* grace notes at the beginning of the measure
			 * have effectively been moved timewise
			 * into previous measure, so discount them. */
			for (gs_p = group_p; gs_p->grpvalue == GV_ZERO
					&& gs_p->grpcont == GC_NOTES;
					gs_p = gs_p->next) {
				;
			}

			for (  ; gs_p != (struct GRPSYL *) 0;
						gs_p = gs_p->next) {

				/* see if this group start corresponds with
				 * start of chord */
				if (EQ(grpstart, chordstart)) {
					/* found appropriate group */
					break;
				}

				else if (GT(radd(grpstart,gs_p->fulltime),
								 chordstart)) {
					/* This group spills into space
					 * to be crunched.
					 * Split off beginning of group. */
					splitspace(gs_p,
						rsub(chordstart, grpstart));

					/* point to added group */
					gs_p = gs_p->next;

					/* splice added group into chord */
					splicechord(gs_p, ch_p);

					/* found appropriate group */
					break;
				}
				else {
					/* haven't gotten to the group yet.
					 * Add on the time taken by this
					 * group in preparation for next
					 * trip around the loop */
					grpstart = radd(grpstart, gs_p->fulltime);
					/* if last group in measure, this has
					 * to be the appropriate one */
					if (gs_p->next == (struct GRPSYL *) 0) {
						break;
					} 
				}
			}

			if (gs_p == (struct GRPSYL *) 0) {
				pfatal("failed to find space group");
			}

			/* if group extended beyond end of
			 * chord, split the group and splice added group
			 * into chord */
			if (GT(gs_p->fulltime, minspacetime)) {
				splitspace(gs_p, minspacetime);
				splicechord(gs_p->next, ch_p->ch_p);
			}

			/* mark as taking no time */
			gs_p->grpvalue = GV_ZERO;
		}
	}
}
\f

/* split a space grpsyl into two. The original group becomes the first
 * group, having the specified duration. A new group is added after it,
 * having the remainder of the time taken by the original group. */

static void
splitspace(gs_p, duration)

struct GRPSYL *gs_p;	/* split this group */
RATIONAL duration;	/* make the first group of split this long */

{
	struct GRPSYL *newgs_p;	/* added group */


	/* bug insurance */
	if (gs_p == (struct GRPSYL *) 0 ||
			(gs_p->grpcont != GC_SPACE &&
			svpath(gs_p->staffno, VISIBLE)->visible == YES) ) {
		pfatal("bad group passed to splitspace");
	}

	/* split into 2 groups, one taking duration, and the
	 * other taking the remainder */
	newgs_p = newGRPSYL(GS_GROUP);
	copy_attributes(newgs_p, gs_p);
	newgs_p->grpcont = GC_SPACE;
	newgs_p->fulltime = rsub(gs_p->fulltime, duration);
	gs_p->fulltime = duration;

	/* link new one into list */
	newgs_p->next = gs_p->next;
	newgs_p->prev = gs_p;
	gs_p->next = newgs_p;	
	if (newgs_p->next != (struct GRPSYL *) 0) {
		newgs_p->next->prev = newgs_p;
	}
}
\f

/* splice a grpsyl into a chord */

static void
splicechord(gs_p, ch_p)

struct GRPSYL *gs_p;	/* splice in this group */
struct CHORD *ch_p;	/* splice into this chord */

{
	struct GRPSYL *nxtgs_p;		/* next group in chord list */
	struct GRPSYL **ins_p_p;	/* where to insert new grpsyl */


	if (ch_p == (struct CHORD *) 0) {
		/* this could happen if user gave measure of space, and
		 * then following measure started with a grace note. The
		 * grace note got moved into the space, but there was no
		 * chhead created for it. It should be safe to just
		 * not link it into a chhead, so return */
		return;
	}

	if (gs_p == (struct GRPSYL *) 0) {
		pfatal("null pointer in splicechord");
	}

	/* Figure out where to insert. */
	for (ins_p_p = &(ch_p->gs_p); (*ins_p_p) != (struct GRPSYL *) 0;
						ins_p_p = &((*ins_p_p)->gs_p)) {

		/* gets inserted here if next group is for a higher staffno or
		 * for a higher voice number of the same staffno */
		nxtgs_p = *ins_p_p;
		if (nxtgs_p == (struct GRPSYL *) 0) {
			/* goes at end of list */
			break;
		}
		if (nxtgs_p->staffno > gs_p->staffno ||
				   (nxtgs_p->staffno == gs_p->staffno &&
				   nxtgs_p->vno > gs_p->vno)) {
			break;
		}
	}

	if (ins_p_p == (struct GRPSYL **) 0) {
		pfatal("couldn't find where to insert new grpsyl into chord");
	}

	/* insert it */
	gs_p->gs_p = *ins_p_p;
	*ins_p_p = gs_p;
}
\f

/* if user specifies the default guitar tab staff, then we want to transpose
 * everything down an octave, because a standard guitar sounds an octave
 * lower than it is written. */

void
guitar_transpose()

{
	struct MAINLL *mll_p;


	/* go through the main list looking for things to transpose */
	initstructs();
	for (mll_p = Mainllhc_p; mll_p != (struct MAINLL *) 0; mll_p = mll_p->next) {
		if (mll_p->str == S_STAFF) {
			/* if there is a staff below this and that staff is a
			 * guitar tab staff, then we need to transpose.
			 * Index into Staff by this staff's number, because
			 * staff numbers start at 1, but Staff index starts at 0
			 */
			if (mll_p->u.staff_p->staffno < Score.staffs &&
					Staff[mll_p->u.staff_p->staffno]
					.strinfo == Guitar) {
				guitar_grpsyl_transpose(mll_p->u.staff_p->groups_p[0]);
			}
		}
		else if (mll_p->str == S_SSV) {
			asgnssv(mll_p->u.ssv_p);
		}
	}
}
\f

/* given a group, transpose everything down by an octave */

static void
guitar_grpsyl_transpose(gs_p)

struct GRPSYL *gs_p;

{
	register int n;

	for(   ; gs_p != (struct GRPSYL *) 0; gs_p = gs_p->next) {
		for (n = 0; n < gs_p->nnotes; n++) {
			if (gs_p->notelist[n].octave > 0) {
				(gs_p->notelist[n].octave)--;
			}
			else {
				pfatal("guitar transposition results in note below octave 0");
			}
		}
	}
}
\f

/* If there is an accidental on a note on one voice, it should really apply
 * the other voice on that same staff too. So propogate these accidentals
 * to the other voice if necessary.
 */

void
other_voice_accidentals(staff_p)

struct STAFF *staff_p;

{
	struct GRPSYL *gs_p;
	int v;			/* voice */
	int n;			/* notelist index */
	RATIONAL begin_time, end_time;

	/* if there is only one voice on the staff, or if either
	 * voice is a measure space or rest or multirest, nothing to do. Since
	 * we're doing MIDI, we know a "measure" GRPSYL
	 * will be rest or space, not mrpt, so can just check that. */
	 if ( (staff_p->groups_p[0]->is_meas == YES) ||
			(staff_p->groups_p[1] == (struct GRPSYL *) 0) ||
			(staff_p->groups_p[1]->is_meas == YES) ) {
		return;
	}

	/* do each voice */
	for (v = 0; v < MAXVOICES; v++) {

		/* do each note of each chord */
		begin_time = Zero;
		for (gs_p = staff_p->groups_p[v]; gs_p != (struct GRPSYL *) 0;
							gs_p = gs_p->next) {

			for (n = 0; n < gs_p->nnotes; n++) {

				/* if this note doesn't have an accidental
				 * nothing more to do on it */
				if (gs_p->notelist[n].accidental == '\0') {
					continue;
				}

				/* This note does have an accidental.
				 * Go forward and see how long it lasts.
				 * It will last until there is another
				 * accidental on the same note letter/octave
				 * or until end of measure.
				 */
				end_time = find_acc_end_time(begin_time, gs_p, n);

				/* now check the other voice.
				 * If the same letter/octave note appears
				 * on that voice on or after the begin time but
				 * before the end time, and that note
				 * does not already have an accidental,
				 * give it the same accidental as
				 * was found on the other voice.
				 */
				propogate_accidental( &(gs_p->notelist[n]),
					begin_time, end_time,
					staff_p->groups_p[v == 0 ? 1 : 0]);
			}

			/* accumulate time so far in measure */
			begin_time = radd(begin_time, gs_p->fulltime);
		}
	}
}

/* Given an GRPSYL and a note n in its notelist, and a begin_time, return
 * the end_time which is either the end of the measure or the next instance
 * of the given note which has an accidental on it. */

static RATIONAL
find_acc_end_time(begin_time, gs_p, n)

RATIONAL begin_time;
struct GRPSYL *gs_p;
int n;

{
	RATIONAL end_time;
	struct GRPSYL *end_gs_p;
	int n2;


	end_time = begin_time;
	end_gs_p = gs_p;
	for ( ; ; ) {
		/* Add up time that accidental lasts */
		end_time = radd(end_time, end_gs_p->fulltime);

		if ((end_gs_p = end_gs_p->next) == (struct GRPSYL *) 0) {
			/* Hit end of measure */
			return(end_time);
		}

		/* See if this group has the same note as had the accidental,
		 * and if so, whether it has a new accidental. */
		for (n2 = 0; n2 < end_gs_p->nnotes; n2++) {
			if ((gs_p->notelist[n].letter
					== end_gs_p->notelist[n2].letter) &&	
					(gs_p->notelist[n].octave
					== end_gs_p->notelist[n2].octave)) {

				/* does have the same note. check accidental */
				if (end_gs_p->notelist[n2].accidental != '\0') {
					/* a new accidental, so this cancels
					 * the one we had */
					return(end_time);
				}
				break;
			}
		}
	}
}
\f

/* Check the groups in list pointed to by gs_p.
 * If the letter/octave of the given note_p appears on or after the begin time
 * but before the end time, and that note does not already have an accidental,
 * give it the same accidental as was found on note_p. */

static void
propogate_accidental(note_p, begin_time, end_time, gs_p)

struct NOTE *note_p;	/* look for note matching this one */
RATIONAL begin_time;	/* look between the begin_time and end_time */
RATIONAL end_time;
struct GRPSYL *gs_p;	/* look in this list and adjust if needed */

{
	RATIONAL accumulated_time;
	int n;


	for (accumulated_time = Zero;
				gs_p != (struct GRPSYL *) 0;
				accumulated_time = radd(accumulated_time,
				gs_p->fulltime), gs_p = gs_p->next) {

		if (LT(accumulated_time, begin_time)) {
			/* haven't gotten to begin yet */
			continue;
		}

		if (GE(accumulated_time, end_time)) {
			/* reached end time */
			return;
		}

		/* See if this group contains the note of interest */
		for (n = 0; n < gs_p->nnotes; n++) {
			if ( (gs_p->notelist[n].letter == note_p->letter) &&
					(gs_p->notelist[n].octave == note_p->octave) ) {
				/* if note already has an accidental,
				 * the one from the other voice doesn't
				 * count. Otherwise propogate the
				 * accidental from the other voice */
				if (gs_p->notelist[n].accidental == '\0') {
					gs_p->notelist[n].accidental
							= note_p->accidental;
				}

				/* Found the note and fixed it if needed,
				 * so our job here is done */
				return;
			}
		}
	}
}
\f

/* If doing MIDI with the -x option, we move all the midi STUFFs in the
 * skipped leading measures to the "extra" empty measure that exists for MIDI.
 * This ensure that any MIDI parameters, instruments, etc are correct
 * for the place in the song where we are actually starting.
 */

void
mv_midi_items(mll_p, topstaff_mll_p)

struct MAINLL *mll_p;	/* points to a STAFF that may have MIDI items to move */
struct MAINLL *topstaff_mll_p;	/* points to STAFF where "all" MIDI items will go */

{
	struct STUFF *stuff_p;	/* stuff currently being processed */
	struct STUFF *next;	/* we may move the current STUFF to another
				 * list, so need to save its "next" */
	char *key;		/* midi directive keyword */
	int leng;		/* length of key */
	char *arg;		/* arg after the = */
	int staffno;


	staffno = mll_p->u.staff_p->staffno;
	for (stuff_p = mll_p->u.staff_p->stuff_p; stuff_p != 0; stuff_p = next) {
		/* keep track of next, in case we delete the current */
		next = stuff_p->next;

		if (next == stuff_p) {
			pfatal("loop detected in MIDI list");
		}

		if (stuff_p->stuff_type == ST_MIDI) {
			if (getkeyword(stuff_p->string+2, &key, &leng, &arg)
								== NO) {
				/* invalid, so ignore it. */
				continue;
			}

			/* Some MIDI things, like cue point should just be
			 * ignored if we are skipping over the music,
			 * so just check for and move things we care about.
			 */
			if (matches(key, leng, "program") == YES ||
					matches(key, leng, "tempo") == YES ||
					matches(key, leng, "onvelocity") == YES ||
					matches(key, leng, "channel") == YES ||
					matches(key, leng, "parameter") == YES ||
					matches(key, leng, "offvelocity") == YES ||
					matches(key, leng, "name") == YES ||
					matches(key, leng, "instrument") == YES ||
					matches(key, leng, "hex") == YES ||
					matches(key, leng, "port") == YES ||
					matches(key, leng, "chanpressure") == YES) {
				/* Found something to move; move it */
				mv_skipped_midi(stuff_p, staffno, topstaff_mll_p);
			}
		}
	}
}
\f

/* With -x option and MIDI, this moves a MIDI STUFF from where it was in
 * a skipped measure to the special "empty" measure at the beginning of the
 * piece.  In general, for any given MIDI thing, only the last one matters,
 * so we only need to keep the last one.
 */

static void
mv_skipped_midi(stuff_p, staffno, topstaff_mll_p)

struct STUFF *stuff_p; 		/* Midi STUFF to be moved */
int staffno;			/* Which staff it is for */
struct MAINLL *topstaff_mll_p;	/* The STAFF where midi "all" STUFF go.
				 * Other STAFFs, if any, will surround it. */

{
	int leng;			/* length of MIDI keyword */
	char *oldtext;			/* text of STUFF that already
					 * exists in the list */
	char *newtext;			/* text of STUFF to be added */
	struct MAINLL *mll_p;		/* for finding STAFF to link to */
	struct STAFF *staff_p = 0;	/* the STAFF to link to */
	struct STUFF **stuff_p_p;	/* for finding where to add
					 * the new stuff_p into list */
	static char *alphabet = "abcdefghijklmnopqrstuvwxyz";

	/* Find the correct STAFF to attach to. We all passed a pointer
	 * to the STAFF for midi "all" items. For non-"all" items,
	 * we search in the main list for the correct STAFF. 
	 */
	if (stuff_p->all == YES || staffno == topstaff_mll_p->u.staff_p->staffno) {
		staff_p = topstaff_mll_p->u.staff_p;
	}
	else if (staffno < topstaff_mll_p->u.staff_p->staffno) {
		/* Search backward for correct staff from the "all" staff.
		 * This case probably won't happen often--only if some
		 * staffs at the top are currently invisible (so they are
		 * not the current "top visible staff").
		 */
		for (mll_p = topstaff_mll_p; mll_p->str == S_STAFF;
						mll_p = mll_p->prev) {
			if (mll_p->u.staff_p->staffno == staffno) {
				staff_p = mll_p->u.staff_p;
				break;
			}
		}
	}
	else {
		/* Search forwards for correct staff from the "all" staff. */
		for (mll_p = topstaff_mll_p; mll_p->str == S_STAFF;
						mll_p = mll_p->next) {
			if (mll_p->u.staff_p->staffno == staffno) {
				staff_p = mll_p->u.staff_p;
				break;
			}
		}
	}
	if (staff_p == 0) {
		/* User must have reduced the number of staffs during the
		 * skipped part, so this one is irrelevant. */
		return;
	}

	/* Add to end of list. When going through the list,
	 * see if there is already an item of that type (for param
	 * have to check the specific param matches too), and if so delete
	 * the earlier one, because this new one overrides it.
	 */
	newtext = stuff_p->string + 2;
	for (stuff_p_p = &(staff_p->stuff_p); *stuff_p_p != 0;
					stuff_p_p = &((*stuff_p_p)->next) ) {

		/* If for different place,
		 * this one doesn't count for matching */
		if ( (*stuff_p_p)->place != stuff_p->place) {
			continue;
		}

		oldtext = (*stuff_p_p)->string + 2;

		/* Since hex is arbitrary data, we always keep it */
		if (matches(oldtext, strlen(oldtext), "hex")) {
			continue;
		}

		/* Names can be abbreviated,
		 * so match up to whichever is shorter */
		leng = MIN(strspn(oldtext, alphabet), strspn(newtext, alphabet));
		if (matches(newtext, leng, oldtext)== YES) {
			/* If it's something other than param, we can get
			 * rid of the existing one */
			if (strncmp(newtext, "par", 3) != 0) {
				*stuff_p_p = (*stuff_p_p)->next;
			}
			else {
				/* Compare parameter numbers and if they match,
				 * delete the existing one.
				 */
				char *new_eq_p, *old_eq_p;	/* loc of '=' */
				int oldparm, oldval;
				int newparm, newval;

				new_eq_p = strchr(newtext, '=');
				old_eq_p = strchr(oldtext, '=');
				if (new_eq_p != 0 && old_eq_p != 0) {
					if (get_param(new_eq_p + 1,
							stuff_p->inputfile,
							stuff_p->inputlineno,
							&newparm, &newval)
							== YES &&
							get_param(old_eq_p + 1,
							(*stuff_p_p)->inputfile,
							(*stuff_p_p)->inputlineno,
							&oldparm, &oldval)
							== YES &&
							oldparm == newparm) {
						*stuff_p_p = (*stuff_p_p)->next;
					}
				}
			}

			if (*stuff_p_p == 0) {
				/* If deleted last item in the existing list,
				 * jump out, so we won't try to deference
				 * this null pointer. */
				break;
			}
		}
	}

	/* Just do everything at beat zero. The beat at which user specified
	 * might not even exist in the current time signature, and basically
	 * we just want to do everything ASAP anyway. We know there is never
	 * a 'til' on midi, so no need to deal with that. We could end up
	 * with a lot to do at count zero, potentially enough to overwhelm
	 * the limited MIDI bandwidth and delay the first actual note.
	 * But that potential is always there, and by discarding things
	 * that were overwritten later, which we did above, unless there
	 * are an awfully lot of parameters on every possible channel,
	 * it's probably only going to take less than 0.1 second,
	 * so it doesn't seem worth the bother to try to do something
	 * fancy to calculate how much time we need for this stuff
	 * and delay the actual music by that much. */
	stuff_p->start.count = 0.0;
	stuff_p->start.steps = 0.0;

	/* link onto end of list */
	*stuff_p_p = stuff_p;
	stuff_p->next = 0;
}
\f

/* Given the argument to a MIDI "parameter" command, extract and return
 * (via pointers) the two numbers (the parameter number and its value).
 * If successful, returns YES, else prints a warning and returns NO.
 * If NO is returned, the pointed to return values are not fill in.
 */

int
get_param(arg, inputfile, inputlineno, parmnum_p, parmval_p)

char *arg;		/* the argument part after "parameter=" */
char *inputfile;	/* for error messages */
int inputlineno;	/* for error messages */
int *parmnum_p;		/* parameter number is returned here */
int *parmval_p;		/* parameter value is returned here */

{
	int parmnum;	/* parameter number */
	int parmval;	/* parameter value */
	char *parm_p;	/* pointer to current place in string */


	/* extract first number */
	parmnum = strtol(arg, &parm_p, 10);
	if (parm_p == arg) {
		l_warning(inputfile, inputlineno,
			"parameter requires two values");
		return(NO);
	}
	/* skip white space, if any */
	while (*parm_p == ' ' || *parm_p == '\t') {
		parm_p++;
	}
	/* next we better have a comma */
	if (*parm_p != ','){
		l_warning(inputfile, inputlineno,
			"parameter is missing required comma");
		return(NO);
	}
	/* extract the second number */
	arg = parm_p + 1;
	parmval = strtol(arg, &parm_p, 10);
	if (parm_p == arg) {
		l_warning(inputfile, inputlineno,
			"parameter is missing second value");
		return(NO);
	}
	/* verify both numbers are within range */
	if ((l_rangecheck(parmnum, 0, 127, "parameter number",
			inputfile, inputlineno) == YES) &&
			(l_rangecheck(parmval, 0, 127, "parameter value",
			inputfile, inputlineno) == YES)) {
		*parmnum_p = parmnum;
		*parmval_p = parmval;
		return(YES);
	}
	return(NO);
}