// Allegro: music representation system, with//      extensible in-memory sequence structure//      upward compatible with MIDI//      implementations in C++ and Serpent//      external, text-based representation//      compatible with Aura#include "assert.h"#include "stdlib.h"#include "allegro.h"#include "string.h"//#include "memory.h"#include "trace.h"Atoms symbol_table;bool within(double d1, double d2, double epsilon){    d1 -= d2;    return d1 < epsilon && d1 > -epsilon;}void Events::expand(){    max = (max + 5); // extra growth for small sizes    max += (max >> 2); // add 25%    Allegro_event_ptr *new_events = new Allegro_event_ptr[max];    // now do copy    memcpy(new_events, events, len * sizeof(Allegro_event_ptr));    if (events) delete[] events;    events = new_events;}Events::~Events(){    if (events) {        delete[] events;    }}void Events::insert(Allegro_event_ptr event){    if (max <= len) {        expand();    }    events[len] = event;    len++;    // find insertion point:    for (int i = 0; i < len; i++) {        if (events[i]->time > event->time) {            // insert event at i            memmove(&events[i + 1], &events[i],                     sizeof(Allegro_event_ptr) * (len - i - 1));            events[i] = event;            return;        }    }}void Events::append(Allegro_event_ptr event){    if (max <= len) {        expand();    }    events[len++] = event;}void Atoms::expand(){    max = (max + 5); // extra growth for small sizes    max += (max >> 2); // add 25%    char **new_atoms = new Attribute[max];    // now do copy    memcpy(new_atoms, atoms, len * sizeof(Attribute));    if (atoms) delete[] atoms;    atoms = new_atoms;}char *heapify(char *s){    char *h = new char[strlen(s) + 1];    strcpy(h, s);    return h;}Attribute Atoms::insert_new(const char *name, char attr_type){    if (len == max) expand();    char *h = new char[strlen(name) + 2];    strcpy(h + 1, name);    *h = attr_type;    atoms[len++] = h;    return h;}Attribute Atoms::insert_attribute(Attribute attr){    for (int i = 0; i < len; i++) {        if (strcmp(attr, atoms[i]) == 0) {            return atoms[i];        }    }    return insert_new(attr + 1, attr[0]);}Attribute Atoms::insert_string(const char *name){    char attr_type = name[strlen(name) - 1];    for (int i = 0; i < len; i++) {        if (attr_type == atoms[i][0] &&            strcmp(name, atoms[i] + 1) == 0) {            return atoms[i];        }    }    return insert_new(name, attr_type);}void Parameters::insert_real(Parameters **list, char *name, double r){    Parameters_ptr a = new Parameters(*list);    *list = a;    a->parm.set_attr(symbol_table.insert_string(name));    a->parm.r = r;    assert(a->parm.attr_type() == 'r');}void Parameters::insert_string(Parameters **list, char *name, char *s){    Parameters_ptr a = new Parameters(*list);    *list = a;    a->parm.set_attr(symbol_table.insert_string(name));    // string is deleted when parameter is deleted    a->parm.s = heapify(s);    assert(a->parm.attr_type() == 's');}void Parameters::insert_integer(Parameters **list, char *name, long i){    Parameters_ptr a = new Parameters(*list);    *list = a;    a->parm.set_attr(symbol_table.insert_string(name));    a->parm.i = i;    assert(a->parm.attr_type() == 'i');}void Parameters::insert_logical(Parameters **list, char *name, bool l){    Parameters_ptr a = new Parameters(*list);    *list = a;    a->parm.set_attr(symbol_table.insert_string(name));    a->parm.l = l;    assert(a->parm.attr_type() == 'l');}void Parameters::insert_atom(Parameters **list, char *name, char *s){    Parameters_ptr a = new Parameters(*list);    *list = a;    a->parm.set_attr(symbol_table.insert_string(name));    a->parm.a = symbol_table.insert_string(s);    assert(a->parm.attr_type() == 'a');}Parameters *Parameters::remove_key(Parameters **list, char *name){    while (*list) {        if (strcmp((*list)->parm.attr_name(), name) == 0) {            Parameters_ptr p = *list;            *list = p->next;            p->next = NULL;            return p; // caller should free this pointer        }        *list = (*list)->next;    }    return NULL;}Parameter::~Parameter(){    if (attr_type() == 's' && s) delete[] s;}Allegro_note::~Allegro_note(){    while (parameters) {        Parameters_ptr to_delete = parameters;        parameters = parameters->next;        delete to_delete;    }}void Beats::expand(){    max = (max + 5); // extra growth for small sizes    max += (max >> 2); // add 25%    Beat_ptr new_beats = new Beat[max];    // now do copy    memcpy(new_beats, beats, len * sizeof(Beat));    if (beats) delete[] beats;    beats = new_beats;}void Beats::insert(long i, Beat_ptr beat){    assert(i >= 0 && i <= len);    if (max <= len) {        expand();    }    memmove(&beats[i], &beats[i + 1], sizeof(Beat) * (len - i));    memcpy(&beats[i], beat, sizeof(Beat));    len++;}long Time_map::locate_time(double time){    int i = 0;    while ((i < beats.len) && (time > beats[i].time)) {        i++;    }    return i;}long Time_map::locate_beat(double beat){    int i = 0;    while (( i < beats.len) && (beat > beats[i].beat)) {        i++;    }    return i;}double Time_map::beat_to_time(double beat){    Beat_ptr mbi;    Beat_ptr mbi1;    if (beat <= 0) {        return beat;    }    int i = locate_beat(beat);    if (i == beats.len) {        if (last_tempo_flag) {            return beats[i - 1].time +                    (beat - beats[i - 1].beat) / last_tempo;        } else if (i == 1) {            return beat * 0.6;        } else {            mbi = &beats[i - 2];            mbi1 = &beats[i - 1];        }    } else {        mbi = &beats[i - 1];        mbi1 = &beats[i];    }    // whether w extrapolate or interpolate, the math is the same    double time_dif = mbi1->time - mbi->time;    double beat_dif = mbi1->beat - mbi->beat;    return mbi->time + (beat - mbi->beat) * time_dif / beat_dif;}double Time_map::time_to_beat(double time){    Beat_ptr mbi;    Beat_ptr mbi1;    if (time <= 0.0) return time;    int i = locate_time(time);    if (i == beats.len) {        if (last_tempo_flag) {            return beats[i - 1].beat +                    (time - beats[i - 1].time) * last_tempo;        } else if (i == 1) {            return time / 0.6;        } else {            mbi = &beats[i - 2];            mbi1 = &beats[i - 1];        }    } else {        mbi = &beats[i - 1];        mbi1 = & beats[i];    }    double time_dif = mbi1->time - mbi->time;    double beat_dif = mbi1->beat - mbi->beat;    return mbi->beat + (time - mbi->time) * beat_dif / time_dif;}         void Time_sigs::expand(){    max = (max + 5); // extra growth for small sizes    max += (max >> 2); // add 25%    Time_sig_ptr new_time_sigs = new Time_sig[max];    // now do copy    memcpy(new_time_sigs, time_sigs, len * sizeof(Time_sig));    if (time_sigs) delete[] time_sigs;    time_sigs = new_time_sigs;}void Time_sigs::insert(double beat, double num, double den){    if (max <= len) {        expand();    }    time_sigs[len].beat = beat;    time_sigs[len].num = num;    time_sigs[len].den = den;    len++;    // find insertion point:    for (int i = 0; i < len; i++) {        if (time_sigs[i].beat > beat) {            // insert event at i            memmove(&time_sigs[i], &time_sigs[i + 1],                     sizeof(Time_sig) * (len - i));            time_sigs[i].beat = beat;            time_sigs[i].num = num;            time_sigs[i].den = den;        }        return;    }}Seq::~Seq(){    for (int i = 0; i < notes.len; i++)        delete notes.events[i];}long Seq::seek_time(double time)// find index of first score event after time{    long i;    for (i = 0; i < notes.len; i++) {        if (notes[i]->time > time) {            break;        }    }    return i;}void Seq::convert_to_beats()// modify all times and durations in notes to beats{    if (units_are_seconds) {        units_are_seconds = false;        for (long i = 0; i < notes.len; i++) {            Allegro_event_ptr e = notes[i];            double beat = map.time_to_beat(e->time);            if (e->type == 'n') {                Allegro_note_ptr n = (Allegro_note_ptr) e;                n->dur = map.time_to_beat(n->time + n->dur) - beat;                n->time = beat;            }        }    }}void Seq::convert_to_seconds()// modify all times and durations in notes to seconds{    if (!units_are_seconds) {        units_are_seconds = true;        for (long i = 0; i < notes.len; i++) {            Allegro_event_ptr e = notes[i];            double time = map.beat_to_time(e->time);            if (e->type == 'n') {                Allegro_note_ptr n = (Allegro_note_ptr) e;                n->dur = map.beat_to_time(n->time + n->dur) - time;                n->time = time;            }        }    }}bool Seq::insert_beat(double time, double beat)// insert a time,beat pair// return true or false (false indicates an error, no update)// it is an error to imply a negative tempo or to insert at// a negative time{    if (time < 0 || beat < 0) return false;    if (time == 0.0 && beat > 0)        time = 0.000001; // avoid infinite tempo, offset time by 1us    if (time == 0.0 && beat == 0.0)        return true; // (0,0) is already in the map!    convert_to_beats(); // beats are invariant when changing tempo    int i = map.locate_time(time); // i is insertion point    if (i < map.beats.len && within(map.beats[i].time, time, 0.000001)) {        // replace beat if time is already in the map        map.beats[i].beat = beat;    } else {        Beat point;        point.beat = beat;        point.time = time;        map.beats.insert(i, &point);    }    // beats[i] contains new beat    // make sure we didn't generate a zero tempo.    // if so, space beats by one microbeat as necessary    long j = i;    while (j < map.beats.len &&        map.beats[j - 1].beat + 0.000001 >= map.beats[j].beat) {        map.beats[j].beat = map.beats[j - 1].beat + 0.000001;        j++;    }    return true;}bool Seq::insert_tempo(double tempo, double beat){    tempo = tempo / 60.0; // convert to beats per second    // change the tempo at the given beat until the next beat event    if (beat < 0) return false;    convert_to_beats(); // beats are invariant when changing tempo    double time = map.beat_to_time(beat);    long i = map.locate_time(time);    if (i >= map.beats.len || !within(map.beats[i].time, time, 0.000001)) {        insert_beat(time, beat);    }    // now i is index of beat where tempo will change    if (i == map.beats.len - 1) {        map.last_tempo = tempo;        map.last_tempo_flag = true;    } else { // adjust all future beats        // compute the difference in beats        double diff = map.beats[i + 1].beat - map.beats[i].beat;        // convert beat difference to seconds at new tempo        diff = diff /tempo;        // figure out old time difference:        double old_diff = map.beats[i + 1].time - time;        // compute difference too        diff = diff - old_diff;        // apply new_diff to score and beats        while (i < map.beats.len) {            map.beats[i].time = map.beats[i].time + diff;            i++;        }    }    return true;}void Seq::add_event(Allegro_event_ptr event){    convert_to_seconds();    notes.insert(event);/*    if (event->type == 'n') {        Allegro_note_ptr n = (Allegro_note_ptr) event;        trace("note %d at %g for %g\n", n->key, n->time, n->dur);    } */}bool Seq::set_tempo(double tempo, double start_beat, double end_beat)// set tempo from start_beat to end_beat{    if (start_beat >= end_beat) return false;    convert_to_beats();    // algorithm: insert a beat event if necessary at start_beat    //    and at end_beat    // delete intervening map elements    // change the tempo    insert_beat(map.beat_to_time(start_beat), start_beat);    insert_beat(map.beat_to_time(end_beat), end_beat);    long start_x = map.locate_beat(start_beat) + 1;    long stop_x = map.locate_beat(end_beat) + 1;    while (stop_x < map.beats.len) {        map.beats[start_x] = map.beats[stop_x];        start_x++;        stop_x++;    }    map.beats.len = start_x; // truncate the map to new length    return insert_tempo(tempo, start_beat);}void Seq::set_time_sig(double beat, double num, double den){    time_sig.insert(beat, num, den);}void Seq::beat_to_measure(double beat, long *measure, double *m_beat,                          double *num, double *den){    // return [measure, beat, num, den]    double m = 0; // measure number    double bpm;    int tsx;    for (tsx = 0; tsx < time_sig.len; tsx++) {        bpm = 4;        // assume 4/4 if no time signature        double prev_beat = 0;        double prev_num = 4;        double prev_den = 4;        if (tsx > 0) {            bpm = time_sig[tsx].num * 4 / time_sig[tsx].den;            prev_beat = time_sig[tsx].beat;            prev_num = time_sig[tsx].num;            prev_den = time_sig[tsx].den;        }        if (time_sig[tsx].beat > beat) {            m = m + (beat - prev_beat) / bpm;            *measure = (long) m;            *m_beat = (m - *measure) * bpm * prev_den * 0.25;            *num = prev_num;            *den = prev_den;            return;        }        // round m up to an integer (but allow for a small        // numerical inaccuracy)        m = m + (long) (0.99 + (time_sig[tsx].beat - prev_beat) / bpm);    }    // if we didn't return yet, compute after last time signature    Time_sig initial(0, 4, 4);    Time_sig_ptr prev = &initial;    if (tsx > 0) { // use last time signature        prev = &time_sig[time_sig.len - 1];    }    bpm = prev->num * 4 / prev->den;    m = m + (beat - prev->beat) / bpm;    *measure = (long) m;    *m_beat = (m - *measure) * bpm * prev->den * 0.25;    *num = prev->num;    *den = prev->den;}void Seq::set_events(Allegro_event_ptr *events, long len, long max){    convert_to_seconds(); // because notes are in seconds    notes.set_events(events, len, max);}// sr_letter_to_type = {"i": 'Integer', "r": 'Real', "s": 'String',//                     "l": 'Logical', "a": 'Symbol'}