/* record.c -- keyboard to adagio recorder
 * Copyright 1989 Carnegie Mellon University
 *
 * the interface consists of three routines:
 *      rec_init()      -- initialization
 *      rec_event(byte *data)   -- called to insert (record) midi data, 
 *                              -- returns FALSE if no more space
 *      rec_final()     -- called to finish up
 */

/*****************************************************************************
*       Change Log
*  Date | Change
*-----------+-----------------------------------------------------------------
* 27-Feb-86 | Created changelog
*           | Use pedal information when computing durations (code taken
*           |  from transcribe.c)
* 23-Mar-86 | Determine size of transcription when rec_init is called.
* 21-May-86 | Major rewrite to use continuous controls (code taken 
*           |  from transcribe.c)
*  1-Aug-87 | F.H. Changed rec_init() to new memory handling.
* 17-Oct-88 | JCD : portable version.
* 31-Jan-90 | GWL : cleaned up for LATTICE
* 30-Jun-90 | RBD : further changes
*  2-Apr-91 | JDW : further changes
* 28-Apr-03 | DM  : changed for portability; true->TRUE, false->FALSE
*****************************************************************************/

#include "switches.h"

#include <stdio.h>
#include <stdlib.h>

#include "cext.h"
#include "midifns.h"
#include "userio.h"
#include "midicode.h"
#include "record.h"
#include "cmdline.h"

extern long space;    /* how much space is left? */

int debug_rec = FALSE;    /* verbose debug flag for this module */

long max_notes = -1L;    /* -1 is flag that space must be allocated */

time_type previous_time;

/****************************************************************
* data structure notes: the midi stream is stored as an array 
* of 4-byte records, each of which is either a time or midi
* data.     Midi data always begins with a control byte (high
* order bit set), and it is assumed times are positive (high
* order bit clear), so the two are easy to distinguish
* IF THE COMPILER PUTS THESE BITS IN THE SAME PLACE.  It looks
* like the high order byte of the time lines up with the last
* byte of a 4 byte array, so we will always set the high order
* bit of the last array byte when the first 3 bytes are filled
* with MIDI data.  This is refered to as the "tag" bit.
* WARNING: Lattice C longs are UNSIGNED, therefore always
* positive.  Test the high order bit with a mask.
****************************************************************/

#define MIDI_CMD_BIT    0x80
#define HIGH_BIT        0x80000000
#define istime(note) (!(((note)->when) & HIGH_BIT))

typedef union note_struct {
    byte n[4];
    long when;
} 
*note_type, note_node;

private note_type event_buff;    /* pointer to allocated buffer */
private note_type next;    /* pointer to next entry in buffer */
private note_type last;    /* pointer to last entry in buffer */
private int pile_ups;    /* inner loop iteration count */
private int max_pile_up;    /* maximum of pile_ups */
private boolean fixed_octave;	/* used to avoid many error messages */

/****************************************************************************
*    Routines local to this module
****************************************************************************/
private void    bend_filter();
private void    byteorder();
private void    ctrl_filter();
private int    event_bend();
private void    filter();
private long    getdur();
private long    getnext();
private char    map_ctrl();
private void    output();

/****************************************************************************
*               bend_filter
* Inputs:
*    note_type note: the current note
*    note_type last: the last recorded event
*    long now: the current time
* Effect:
*    remove pitch bend events in same 0.01 sec time slot
* Implementation:
*    If the current event is a pitch bend that bends again
*    in the same time slot, make it a no-op by replacing it with
*    the time.
****************************************************************************/

private void bend_filter(note, last, now)
note_type note;    /* current note */
note_type last;    /* the last recorded event */
long now;       /* the current time */
{
    /* first see if there is another bend in this time
         * slot.
         */
    note_type note2 = note + 1;
    while (note2 < last) {
        if (istime(note2) && (note2->when > now)) {
            break; /* new time slot */
        } 
        else if (note->n[0] == note2->n[0]) {
            note->when = now;
            return; /* found another bend */
        }
        note2++;
    }
}

/****************************************************************************
*               byteorder
* Effect: 
*    check out assumptions about byte order and placement
****************************************************************************/

private void byteorder()
{
    note_node test_event;
    if ((sizeof(test_event) != 4) ||
        (sizeof(test_event.when) != 4) ||
        (sizeof(test_event.n[0]) != 1)) {
        gprintf(ERROR, "implementation error: size problem\n");
        EXIT(1);
    }
    test_event.n[0] = 0x12;
    test_event.n[1] = 0x34;
    test_event.n[2] = 0x56;
    test_event.n[3] = 0x78;
    if ((test_event.when != 0x78563412) &&
        (test_event.when != 0x12345678)) {
        gprintf(ERROR, "implementation error: layout problem\n");
        EXIT(1);
    }
}

/****************************************************************************
*               ctrl_filter
* Inputs:
*    note_type note: the current note
*    note_type last: the last recorded event
*    long now: the current time
* Effect:
*    remove ctrl change events in same 0.01 sec time slot
* Implementation:
*    If the current event is a control change that changes again
*    in the same time slot, make it a no-op by replacing it with
*    the time.
****************************************************************************/

private void ctrl_filter(note, last, now)
note_type note;    /* the current note */
note_type last;    /* the last recorded event */
long now;       /* the current time */
{
    /* see if there is another control change in this time
         * slot.
         */
    note_type note2 = note+1;
    while (note2 < last) {
        if (istime(note2) && (note2->when > now)) {
            break;    /* new time slot */
        } 
        else if ((note->n[0] == note2->n[0]) &&
            (note->n[1] == note2->n[1])) {
            note->when = now;
            return; /* found another change */
        }
        note2++;
    }
}

/****************************************************************************
*               event_bend
* Inputs:
*    note_type note: pointer to a pitch bend event
* Outputs:
*    returns int: an 8 bit pitch bend number
****************************************************************************/

private int event_bend(note)
note_type note;
{
    return((int) (((note->n[1]) >> 6) + ((note->n[2]) << 1)));
}

/****************************************************************************
*               filter
* Inputs:
*    note_type last: the last note recorded
* Effect: allow only one control change per time slot (0.01 sec)
* Implementation:
*    call ctrl_filter and bend_filter to overwrite control changes with
*    noop data (the current time is used as a noop)
****************************************************************************/

private void filter(last)
note_type last;
{
    note_type note;    /* loop control variable */
    long now=0;   /* last time seen */
    int command;    /* command pointed to by note */

    for (note = event_buff; note <= last; note++) {
        if (istime(note)) {
            now = note->when;
        } 
        else {
            command = note->n[0] & MIDI_CODE_MASK;

            if (command == MIDI_CTRL &&
                note->n[1] == SUSTAIN) {
                /* do nothing */;
            } 
            else if (command == MIDI_CTRL) {
                ctrl_filter(note, last, now);
            } 
            else if (command == MIDI_TOUCH) {
                bend_filter(note, last, now);    /* bend and touch use the */
            } 
            else if (command == MIDI_BEND) {    /*  same filter routines  */
                bend_filter(note, last, now);
            }
        }
    }
}


/****************************************************************************
*               getdur
* Inputs:
*    int i: index of the note
*    note_type last: pointer to the last event recorded
*    int ped: TRUE if pedal is down at event i
*    long now: the time at event i
* Outputs:
*    returns long: the duration of note i
* Assumes:
*    assumes i is a note
* Implementation:
*    This is tricky because of pedal messages.  The note is kept on by
*    either the key or the pedal.  Keep 2 flags, key and ped.  Key is
*    turned off when a key is released, ped goes off and on with pedal.
*    Note ends when (1) both key and ped are FALSE, (2) key is
*    pressed (this event will also start another note).
****************************************************************************/

private long getdur(i, last, ped, now)
int i;
note_type last;
int ped;
long now;
{
    int key = TRUE;    /* flag that says if note is on */
    long start = now;
    int chan = event_buff[i].n[0] & MIDI_CHN_MASK;
    int pitch = event_buff[i].n[1];
    note_type note = &(event_buff[i+1]);
    int noteon; /* TRUE if a noteon message received on chan */
    int keyon;    /* TRUE if noteon message had non-zero velocity */

    /* search from the next event (i+1) to the end of the buffer:
         */
    for (; note < last; note++) {
        if (istime(note)) {
            now = note->when;
        } 
        else {
            noteon = keyon = FALSE;
            if ((note->n[0] & MIDI_CHN_MASK) == chan) {
                noteon = ((note->n[0] & MIDI_CODE_MASK) == MIDI_ON_NOTE) &&
                    (note->n[1] == pitch);
                keyon = noteon && (note->n[2] != 0);
                if ((noteon && (note->n[2] == 0)) ||
                    (((note->n[0] & MIDI_CODE_MASK) == MIDI_OFF_NOTE) &&
                    (note->n[1] == pitch))) key = FALSE;
                if (((note->n[0] & MIDI_CODE_MASK) == MIDI_CTRL) &&
                    note->n[1] == SUSTAIN && note->n[2] == 127) ped = TRUE;
                if (((note->n[0] & MIDI_CODE_MASK) == MIDI_CTRL) &&
                    note->n[1] == SUSTAIN && note->n[2] == 0) ped = FALSE;

                if ((!key && !ped) || keyon)
                    return(now - start);
            }
        }
    }
    return(last->when - start);
}

/****************************************************************************
*               getnext
* Inputs:
*    int i: the index of the current note
*    note_type last: pointer to last valid data
*    long now: the current time
* Outputs:
*    returns long: the time of the next note, program, or control change
*       (returns time of last event if nothing else is found)
****************************************************************************/

private long getnext(i, last, now)
int i;    /* the index of the current note */
note_type last;    /* pointer to last valid data */
long now;    /* the current time */
{
    i++;    /* advance to next item */
    for (; event_buff + i < last; i++) {
        note_type note = &(event_buff[i]);
        int cmd = note->n[0] & MIDI_CODE_MASK;

        if (istime(note)) {
            now = note->when;
        } 
        else if (((cmd == MIDI_ON_NOTE) &&
            (note->n[2] != 0)) /* note on */ ||
            (cmd == MIDI_CH_PROGRAM) /* program change */ ||
            ((cmd == MIDI_CTRL) &&
            (note->n[1] != SUSTAIN) /* control change */ ) ||
            (cmd == MIDI_TOUCH) ||
            (cmd == MIDI_BEND)) {
            return(now);
        }
    }
    return(last->when);
}

/****************************************************************************
*               map_ctrl
* Inputs:
*    int control: a midi control number
* Outputs:
*    returns char: an adagio control change command letter, EOS if
*       control change is not one of PORTARATE, PORTASWITCH,
*       MODWHEEL, FOOT
****************************************************************************/

private char map_ctrl(control)
int control;
{
    switch (control) {
/* 'J' is no longer code for PORTARATE
      case PORTARATE:
        return 'J'; */
      case PORTASWITCH:
        return 'K';
      case MODWHEEL:
        return 'M';
      case VOLUME:
        return 'X';
      default:
        return EOS;
    }
#ifdef LATTICE322
    return EOS;    /* make Lattice C type checker happy */
#endif
}

/****************************************************************************
*               output
* Inputs:
*    FILE *fp: an opened file pointer
*    note_type last: the last data in the buffer
*    boolean absflag: set to TRUE if first line of the adagio score should
*       include the absolute time
* Effect: 
*    write adagio file using data in event_buff
* Implementation:
*    NOTE: put all program changes in rests
*    use N(ext) notation for all timing
*    output no more than one continuous parameter change per
*    clock tick for each continuous change parameter
****************************************************************************/

private void output(fp, last, absflag)
FILE *fp;
note_type last;
boolean absflag;
{
    int i;                      /* loop counter */
    int command;                /* the current command */
    int voice;			/* the midi channel of the current event */
    int last_velocity = -1;	/* used to filter repeated Lnn attributes */
    int last_voice = 0; 	/* the default adagio channel (1) */
    int ped = FALSE;            /* flag maintains state of pedal */
    int how_many = last - event_buff;
    long now=0;                 /* the time of the next event */

    if (fp == NULL) {
        gprintf(ERROR, "internal error: output called with NULL file.\n");
        EXIT(1);
    }

    if (debug_rec)
        gprintf(GDEBUG,"hint: if file is not being closed, decrease MAXSPACE\n");


    fprintf(fp, "!MSEC\n");     /* times will be in milliseconds */
    /* set the initial absolute time, all other times are relative */

    if (absflag) {
        now = event_buff[0].when;
        if (now < 0) {
            fprintf(fp, "* First event took place at Adagio time %d,\n",
                    (int)now);
            fprintf(fp, "*  but Adagio cannot represent negative times,\n");
            fprintf(fp, "*  so this entire score will be %d ms late\n",
                    (int)-now);
            gprintf(TRANS, "First event took place at Adagio time %d!\n",
                    (int)now);
            gprintf(TRANS, "All events times will be %d ms late\n",
                    (int)-now);
            now = 0L;
        }
        fprintf(fp, "T%ld ", now);
    }

    for (i = 0; i < how_many; i++) {
        if (debug_rec) {
            gprintf(GDEBUG,"ev %d: %x %x %x (%ld)\n", i, event_buff[i].n[0],
            event_buff[i].n[1], event_buff[i].n[2], event_buff[i].when);
        }

        if (istime(event_buff+i)) {
            now = event_buff[i].when;
            if (debug_rec) gprintf(GDEBUG,"i = %d, now = %ld\n", i, now);
        } else {
            boolean needs_voice = TRUE;
            command = event_buff[i].n[0] & MIDI_CODE_MASK;
            voice = event_buff[i].n[0] & MIDI_CHN_MASK;

            if (command == MIDI_ON_NOTE && event_buff[i].n[2] != 0) {
                int velocity =	event_buff[i].n[2];
                write_pitch(fp, event_buff[i].n[1]);
                fprintf(fp, " U%ld", getdur(i, last, ped, now));
                if (last_velocity != velocity) {
                    fprintf(fp, " L%d", velocity);
                    last_velocity = velocity;
                }
            } else if (command == MIDI_CH_PROGRAM) {
                fprintf(fp, "Z%d", event_buff[i].n[1] + 1);
            } else if (command == MIDI_CTRL &&
                event_buff[i].n[1] == SUSTAIN) {
                ped = (event_buff[i].n[2] != 0);
                needs_voice = FALSE;
            } else if (command == MIDI_CTRL) {
                char c = map_ctrl(event_buff[i].n[1]);
                if (c != EOS) fprintf(fp, "%c%d", c, event_buff[i].n[2]);
                else fprintf(fp, "~%d(%d)", event_buff[i].n[1], event_buff[i].n[2]);
            } else if (command == MIDI_TOUCH) {
                fprintf(fp, "O%d", event_buff[i].n[1]);
            } else if (command == MIDI_BEND) {
                fprintf(fp, "Y%d", event_bend(&event_buff[i]));
            } else if (command == MIDI_ON_NOTE || command == MIDI_OFF_NOTE) {
                needs_voice = FALSE; /* ignore note-offs */
            } else {
                gprintf(ERROR, "Command 0x%x ignored\n", command);
                needs_voice = FALSE;
            }
            if (needs_voice) {
                if (last_voice != voice) {
                    fprintf(fp, " V%d", voice + 1);
                    last_voice = voice;
                }
                fprintf(fp, " N%d", (int)(getnext(i, last, now) - now));
                fprintf(fp, "\n");
            }
        }
    }
}


/****************************************************************************
*               write_pitch
* Inputs:
*    FILE *fp: an open file
*    int p: a pitch number
* Effect: write out the pitch name for a given number
****************************************************************************/

void write_pitch(FILE *fp, int p)
{
    static char *ptos[] = {
        "C", "CS", "D", "EF", "E", "F", "FS", "G",
        "GS", "A", "BF", "B"	};
    /* avoid negative numbers: adagio can't express lowest octave: */
    while (p < 12) {
        if (!fixed_octave) {
            gprintf(ERROR, "%s%s%s",
                    "A low note was transposed up an octave\n",
                    "(Adagio cannot express the lowest MIDI octave).\n",
                    "This message will appear only once.\n");
            fixed_octave = TRUE;
        }
        p += 12;
    }
    fprintf(fp, "%s%d", ptos[p % 12], (p / 12) - 1);
}

/**********************************************************************
*           rec_final
* Inputs:
*    boolean absflag: output absolute time of first note if TRUE
* Effect:
*    Write recorded data to a file
**********************************************************************/

void rec_final(FILE *fp, boolean absflag)
{
    next->when = gettime();
    last = next;
    if (debug_rec) gprintf(GDEBUG,"max_pile_up = %d, ", max_pile_up);
    gprintf(TRANS,"%ld times and events recorded.\n", 
                  (long) (last - event_buff));
    filter(last);
    output(fp, last, absflag);
    fclose(fp);
    FREE(event_buff);
    max_notes = -1;
}

/****************************************************************************
*               rec_init
* Inputs:
*    char *file:  pointer to file name from command line (if any)
*    boolean bender: TRUE if pitch bend should be enabled
* Outputs:
*    return TRUE if initialization succeeds
* Effect:
*    prepares module to record midi input
****************************************************************************/

/* ENOUGH_ROOM says if we have room for 10000 events + 10000 timestamps =
 * 20000 note_struct's, then that's "enough room" for recording a sequence.
 * If more ram is available, it won't be used.  If less is available, we'll
 * use as much as we can get, minus "SPACE_FOR_PLAY", which leaves a little
 * bit of spare ram in case Moxc or stdio need to allocate some space.
 *      For DOS, we limit recording space to 64K.
 */
#ifdef DOS
#define ENOUGH_ROOM 64000L
#else
#define ENOUGH_ROOM (20000L * sizeof(union note_struct))
#endif


boolean rec_init(boolean bender)
{
    size_t biggestChunk, spaceForRecord;

    debug_rec = cl_switch("debug");
    byteorder();
    pile_ups = 0;
    max_pile_up = 0;
    previous_time = (unsigned) -1L; /* this will force putting in initial timestamp */
    fixed_octave = FALSE;

    if (max_notes == -1) {    /* allocate space 1st time rec_init called */
        biggestChunk = AVAILMEM;
        if (biggestChunk <= SPACE_FOR_PLAY) {
            /* not enough memory; give up */
            return(FALSE);
        } 
        else {
            spaceForRecord =
                MIN((biggestChunk - SPACE_FOR_PLAY), ENOUGH_ROOM);
            /* leave SPACE_FOR_PLAY contiguous bytes of memory */
        }
        max_notes = spaceForRecord / sizeof(note_node);
        /*    gprintf(GDEBUG,"max_notes = %d\n", max_notes);*/
        event_buff = (note_type) MALLOC(spaceForRecord);
        if (event_buff == NULL) {
            /* should never happen */
            gprintf(FATAL, "Implementation error (record.c): getting memory.");
            return FALSE;
        }
    }
    next = event_buff;
    last = event_buff + max_notes - 2; /* it is critical that last not point
                                        * to the very last storage loc */
    midi_cont(bender);
    return((boolean)(max_notes > 10));
    /* it would be silly to record with only room enough for 10 notes! */
}


/****************************************************************************
*               rec_event
* Inputs:
*    long time: the current time
*    long data: midi data to record
* Outputs:
*    returns FALSE if there is no more memory
* Effect: reads and stores any input
* Implementation:
*    time stamps and midi events share the same buffer of 4-byte events
*    save time at most once per call to rec_poll
*    save time only if it changes
****************************************************************************/

boolean rec_event(long *data, time_type time)
{
    /* can't allow negative time because sign bit distinguishes 
     * data from time: */
    if (time < 0) time = 0;

    if (previous_time != time) {
        next++->when = previous_time = time;
        if (next >= last) goto overflow;
    }

    next->when = *data;
    next++->n[3] = MIDI_CMD_BIT;        /* set tag bit */
    if (next >= last) goto overflow;
    return TRUE;

overflow:
    next = last; /* last doesn't really point to last storage */
    gprintf(ERROR, "No more memory.\n");
    return FALSE;
}