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);
}