allegro.h

Go to the documentation of this file.

 
 
#ifndef ALLEGRO_H
#define ALLEGRO_H
#include <cassert>
#include <cstdint>
#include <cstring>
#include <iostream>
 
#define ALG_EPS 0.000001 
#define ALG_DEFAULT_BPM 100.0 

bool within(double d1, double d2, double epsilon);
 
char *heapify(const char *s); 

typedef const char *Alg_attribute;
#define alg_attr_name(a) ((a) + 1)
#define alg_attr_type(a) (*(a))

class Alg_atoms {
public:
    Alg_atoms() {
        maxlen = len = 0;
        atoms = nullptr;
    }

    virtual ~Alg_atoms() {
        for (int i = 0; i < len; i++) {
            delete atoms[i];
        }
        delete[] atoms;
    }

    Alg_attribute insert_attribute(Alg_attribute attr);
    Alg_attribute insert_string(const char *name);
private:
    long maxlen;
    long len;
    Alg_attribute *atoms;

    Alg_attribute insert_new(const char *name, char attr_type);
    void expand(); // make more space
};
 
#ifdef _WIN32
#define DLLEXPORT __declspec(dllexport)
#else
#define DLLEXPORT
#endif
 
extern DLLEXPORT Alg_atoms symbol_table;
 

class Alg_parameter {
public:
    Alg_attribute attr;
    union {
        double r;
        const char *s; 
        int32_t i;  
        bool l;  
        const char *a; 
    }; 

    Alg_parameter() { attr = "i"; }
    ~Alg_parameter();
    void copy(Alg_parameter *); 
    char attr_type() { return alg_attr_type(attr); }
    const char *attr_name() { return alg_attr_name(attr); }
    void set_attr(Alg_attribute a) { attr = a; }
    void show();
};
 

class Alg_parameters {
public:
    class Alg_parameters *next;
    Alg_parameter parm;
 
    Alg_parameters(Alg_parameters *list) {
        next = list;
    }
 
    //~Alg_parameters() { }

    static void insert_real(Alg_parameters **list, const char *name, double r);
    static void insert_string(Alg_parameters **list, const char *name,
                              const char *s);
    static void insert_integer(Alg_parameters **list, const char *name, int32_t i);
    static void insert_logical(Alg_parameters **list, const char *name, bool l);
    static void insert_atom(Alg_parameters **list, const char *name,
                            const char *s);
    static Alg_parameters *remove_key(Alg_parameters **list, const char *name);
    Alg_parameter *find(Alg_attribute attr);
};
 
 
// these are type codes associated with certain attributes
// see Alg_track::find() where these are bit positions in event_type_mask
#define ALG_NOTE 0 
#define ALG_GATE 1 
#define ALG_BEND 2 
#define ALG_CONTROL 3 
#define ALG_PROGRAM 4 
#define ALG_PRESSURE 5 
#define ALG_KEYSIG 6 
#define ALG_TIMESIG_NUM 7 
#define ALG_TIMESIG_DEN 8 
#define ALG_OTHER 9 

// NOTE: there is no Alg_event() constructor because Alg_event is an
// abstract class.
class Alg_event {
protected:
    bool selected;
    char type; 
    long key; 
    static const char* description; 
public:
    double time;
    long chan;
    virtual void show() = 0;

    bool is_note() { return (type == 'n'); }

    bool is_update() { return (type == 'u'); }

    char get_type() { return type; }

    int get_type_code();
 
    bool get_selected() { return selected; }
    void set_selected(bool b) { selected = b; }
 
    // Note: notes are identified by a (channel, identifier) pair.
    // For midi, the identifier is the key number (pitch). The identifier
    // does not have to represent pitch; it's main purpose is to identify
    // notes so that they can be named by subsequent update events.
    long get_identifier() { return key; } 
    void set_identifier(long i) { key = i; } 
    void set_parameter(Alg_parameter *new_parameter);
    void set_string_value(const char *attr, const char *value);
    void set_real_value(const char *attr, double value);
    void set_logical_value(const char *attr, bool value);
    void set_integer_value(const char *attr, int32_t value);
    void set_atom_value(const char *attr, const char *atom);
 
    // Some note methods. These fail (via assert()) if this is not a note:
    //
    float get_pitch();
    float get_loud(); 
    // times are in seconds or beats, depending upon the units_are_seconds
    // flag in the containing sequence
    double get_start_time(); 
    double get_end_time();   
    double get_duration();   
    void set_pitch(float);
    void set_loud(float);
    void set_duration(double);

    bool has_attribute(const char *attr);

    char get_attribute_type(const char *attr);

    const char *get_string_value(const char *attr, const char *value = nullptr);

    double get_real_value(const char *attr, double value = 0.0);

    bool get_logical_value(const char *attr, bool value = false);

    long get_integer_value(const char *attr, int32_t value = 0);

    const char *get_atom_value(const char *attr, const char *value = nullptr);

    void delete_attribute(const char *attr);

    const char *get_attribute();    

    char get_update_type();

    const char *get_string_value();
 
    double get_real_value();  
    bool get_logical_value(); 
    int32_t get_integer_value(); 

    const char *get_atom_value();

    bool overlap(double t, double len, bool all);

    const char *GetDescription();
 
    Alg_event() { selected = false; }
    virtual ~Alg_event() = default;
};
 
 
class Alg_note : public Alg_event {
public:
    ~Alg_note() override;
    Alg_note(Alg_note *note); 
    float pitch; 
    float loud;  
    double dur;   
    Alg_parameters *parameters; 
    Alg_note() { type = 'n'; parameters = nullptr; }
    void show() override;
};
 
 
class Alg_update : public Alg_event {
public:
    ~Alg_update() override = default;
    Alg_update(Alg_update *update); 
    Alg_parameter parameter; 
 
 
    Alg_update() { type = 'u'; }
    void show() override;
};
 

class Alg_events {
private:
    long maxlen;
    void expand();
protected:
    long len;
    Alg_event **events; 
public:
    double last_note_off;
    bool in_use;
    virtual int length() { return len; }
    Alg_event *&operator[](int i) {
        assert(i >= 0 && i < len);
        return events[i];
    }
    Alg_events() {
        maxlen = len = 0;
        events = nullptr;
        last_note_off = 0;
        in_use = false;
    }

    virtual ~Alg_events();
    void set_events(Alg_event **e, long l, long m) {
        delete[] events;
        events = e; len = l; maxlen = m;
    }

    void insert(Alg_event *event);
    void append(Alg_event *event);
    Alg_event *uninsert(long index);
};
 
class Alg_track;
 
class Alg_event_list : public Alg_events {
protected:
    char type; 
    static const char *last_error_message;

    Alg_track *events_owner;
 
    static int sequences;  

    int sequence_number;

    double beat_dur;
    double real_dur;
public:
    virtual Alg_event *&operator[](int i);
    Alg_event_list() { sequence_number = 0;
        beat_dur = 0.0; real_dur = 0.0; events_owner = nullptr; type = 'e'; }
    Alg_event_list(Alg_track *owner);
 
    char get_type() { return type; }
    Alg_track *get_owner() { return events_owner; }

    // note that the events contained in the list are not destroyed
    ~Alg_event_list() override = default;

    double get_beat_dur() { return beat_dur; }
    void set_beat_dur(double d) { beat_dur = d; }
    double get_real_dur() { return real_dur; }
    void set_real_dur(double d) { real_dur = d; }

    virtual void set_start_time(Alg_event *event, double);
    const char *get_last_error_message() { return last_error_message; }
};
 

class Alg_beat {
public:
    Alg_beat(double t, double b) {
        time = t; beat = b; }
    Alg_beat() = default;
    double time;
    double beat;
};
 

class Alg_beats {
private:
    long maxlen;
    void expand();
public:
    long len;
    Alg_beat *beats;
    Alg_beat &operator[](int i) {
        assert(i >= 0 && i < len);
        return beats[i];
    }
    Alg_beats() {
        maxlen = len = 0;
        beats = nullptr;
        expand();
        beats[0].time = 0;
        beats[0].beat = 0;
        len = 1;
    }
    ~Alg_beats() { delete[] beats; }
    void insert(long i, Alg_beat *beat);
};
 
 
class Alg_time_map {
private:
    int refcount;
public:
    Alg_beats beats; 
    double last_tempo;
    bool last_tempo_flag;
    Alg_time_map() {
        last_tempo = ALG_DEFAULT_BPM / 60.0;
        last_tempo_flag = true;
        refcount = 0;
    }
    Alg_time_map(Alg_time_map *map); 
    long length() { return beats.len; }
    void show();
    long locate_time(double time);
    long locate_beat(double beat);
    double beat_to_time(double beat);
    double time_to_beat(double time);
    void insert_beat(double time, double beat);   
    bool insert_tempo(double tempo, double beat); 
    double get_tempo(double beat);
    bool set_tempo(double tempo, double start_beat, double end_beat);
    bool stretch_region(double b0, double b1, double dur);
    void cut(double start, double len, bool units_are_seconds);
    void trim(double start, double end, bool units_are_seconds);
    void paste(double start, Alg_track *tr);
    void insert_time(double start, double len);
    void insert_beats(double start, double len);
    void dereference() {
        --refcount;
        if (refcount <= 0) {
            delete this;
        }
    }
    void reference() {
        refcount++;
    }
};
 

class Serial_buffer {
  protected:
    char *buffer;
    char *ptr;
    long len;
  public:
    Serial_buffer() {
        buffer = nullptr;
        ptr = nullptr;
        len = 0;
    }
    virtual ~Serial_buffer() = default;
 
    long get_posn() { return static_cast<long>(ptr - buffer); }
    long get_len() { return len; }
};
 
 
class Serial_read_buffer : public Serial_buffer {
public:
    ~Serial_read_buffer() override = default;
    void get_pad() {
        while (reinterpret_cast<uintptr_t>(ptr) & 7) { ptr++; }
    }

    void init_for_read(void *buf, long n) {
        buffer = static_cast<char *>(buf);
        ptr = static_cast<char *>(buf);
        len = n;
    }
    char get_char() { return *ptr++; }
    void unget_chars(int n) { ptr -= n; } // undo n get_char() calls
    int32_t get_int32() {
        const int32_t i = *(reinterpret_cast<int32_t *>(ptr));
        ptr += sizeof(int32_t);
        return i;
    }
    float get_float() {
        const float f = *(reinterpret_cast<float *>(ptr));
        ptr += sizeof(float);
        return f;
    }
    double get_double() {
        const double d = *(reinterpret_cast<double *>(ptr));
        ptr += sizeof(double);
        return d;
    }
    const char *get_string() {
        char *s = ptr;
        [[maybe_unused]] char *fence = buffer + len;
        assert(ptr < fence);
        while (*ptr++) { assert(ptr < fence); }
        get_pad();
        return s;
    }
    void check_input_buffer(long needed) {
        assert(get_posn() + needed <= len);
    }
};
 
 
class Serial_write_buffer: public Serial_buffer {
  public:
    ~Serial_write_buffer() override { delete[] buffer; }
    void init_for_write() { ptr = buffer; }
    void store_int32(long offset, int32_t value) {
        assert(offset <= static_cast<long>(get_posn() - sizeof(int32_t)));
        *reinterpret_cast<int32_t *>(buffer + offset) = value;
    }
    [[deprecated("Use store_int32() instead")]]
    void store_long(long offset, long value) { store_int32(offset, static_cast<int32_t>(value)); }
    void check_buffer(long needed);
    void set_string(const char *s) {
        [[maybe_unused]] char *fence = buffer + len;
        assert(ptr < fence);
        // two brackets surpress a g++ warning, because this is an
        // assignment operator inside a test.
        while ((*ptr++ = *s++)) { assert(ptr < fence); }
        assert(reinterpret_cast<char *>(reinterpret_cast<uintptr_t>(ptr + 7) & ~7) <= fence);
        pad();
    }
    void set_int32(int32_t v) {
        *(reinterpret_cast<long *>(ptr)) = v;
        ptr += sizeof(int32_t);
    }
    void set_double(double v) {
        *(reinterpret_cast<double *>(ptr)) = v;
        ptr += sizeof(double);
    }
    void set_float(float v) {
        *(reinterpret_cast<float *>(ptr)) = v;
        ptr += sizeof(float);
    }
    void set_char(char v) { *ptr++ = v; }
    void pad() {
        while (reinterpret_cast<uintptr_t>(ptr) & 7) { set_char(0); }
    }
    void *to_heap(long *len) {
        *len = get_posn();
        char *newbuf = new char[*len];
        memcpy(newbuf, buffer, *len);
        return newbuf;
    }
};
 
class Alg_seq;
 
class Alg_track : public Alg_event_list {
protected:
    Alg_time_map *time_map;
    bool units_are_seconds;
    char *get_string(char **p, long *b);
    long get_int32(char **p, long *b);
    double get_double(char **p, long *b);
    float get_float(char **p, long *b);
    static Serial_read_buffer ser_read_buf;
    static Serial_write_buffer ser_write_buf;
    void serialize_parameter(Alg_parameter *parm);
    void unserialize_parameter(Alg_parameter *parm_ptr);
public:
    void serialize_track();
    void unserialize_track();
    Alg_event *&operator[](int i) override {
        assert(i >= 0 && i < len);
        return events[i];
    }
    Alg_track() { units_are_seconds = false; time_map = nullptr;
                  set_time_map(nullptr); type = 't'; }

    Alg_track(Alg_time_map *map, bool seconds);
 
    Alg_event *copy_event(Alg_event *event); 
 
    Alg_track(Alg_track &track);  
    Alg_track(Alg_event_list &event_list, Alg_time_map *map,
              bool units_are_seconds);
    ~Alg_track() override { 
        if (time_map) {
            time_map->dereference();
        }
        time_map = nullptr;
    }

    virtual void serialize(void **buffer, long *bytes);

    static Alg_track *unserialize(void *buffer, long len);

    Alg_seq *to_alg_seq() {
        return (get_type() == 's' ? (Alg_seq*) this : nullptr); }

    bool get_units_are_seconds() { return units_are_seconds; }
    virtual void convert_to_beats();
    virtual void convert_to_seconds();
    void set_dur(double dur);
    double get_dur() { return (units_are_seconds ? real_dur : beat_dur); }

    virtual void set_time_map(Alg_time_map *map);
    Alg_time_map *get_time_map() { return time_map; }

    Alg_note *create_note(double time, int channel, int identifier,
                           float pitch, float loudness, double duration);
    Alg_update *create_update(double time, int channel, int identifier);
    virtual void add(Alg_event *event) { insert(event); }
 
    //
    // Editing regions
    //

    virtual Alg_track *cut(double t, double len, bool all);

    virtual Alg_track *copy(double t, double len, bool all);

    void paste(double t, Alg_event_list *seq); // Shifts notes

    virtual void merge(double t, Alg_event_list *seq);

    virtual void clear(double t, double len, bool all);

    virtual void silence(double t, double len, bool all);

    virtual void insert_silence(double t, double len);
 
    //
    // Accessing for screen display
    //

    virtual Alg_event_list *find(double t, double len, bool all,
                                 long channel_mask, long event_type_mask);
 
    virtual void set_in_use(bool flag) { in_use = flag; }
    //
    // MIDI playback
    //
    // See Alg_iterator
};
 

class Alg_time_sig {
public:
    double beat; 
    double num;  
    double den;  
    Alg_time_sig(double b, double n, double d) {
        beat = b; num = n; den = d;
    }
    Alg_time_sig() {
        beat = 0; num = 0; den = 0;
    }
    void beat_to_measure(double beat, double *measure, double *m_beat,
                         double *num, double *den);
 
};
 

class Alg_time_sigs {
private:
    long maxlen;
    void expand(); 
    long len;
    Alg_time_sig *time_sigs;
public:
    Alg_time_sigs() {
        maxlen = len = 0;
        time_sigs = nullptr;
    }
    Alg_time_sig &operator[](int i) { 
        assert(i >= 0 && i < len);
        return time_sigs[i];
    }
    ~Alg_time_sigs() { delete[] time_sigs; }
    void show();
    long length() { return len; }
    int find_beat(double beat);
    double get_bar_len(double beat);
    void insert(double beat, double num, double den, bool force = false);
    void cut(double start, double end, double dur); 
    void trim(double start, double end); 
    void paste(double start, Alg_seq *seq);
    void insert_beats(double beat, double len); 
    double nearest_beat(double beat);
};
 

class Alg_tracks {
private:
    long maxlen;
    void expand();
    void expand_to(int new_max);
    long len;
public:
    Alg_track **tracks; 
    Alg_track &operator[](int i) {
        assert(i >= 0 && i < len);
        return *tracks[i];
    }
    long length() { return len; }
    Alg_tracks() {
        maxlen = len = 0;
        tracks = nullptr;
    }
    ~Alg_tracks();
    void append(Alg_track *track);
    void add_track(int track_num, Alg_time_map *time_map, bool seconds);
    void reset();
    void set_in_use(bool flag); 
};
 
 
typedef enum {
    alg_no_error = 0,      
    alg_error_open = -800, 
    alg_error_syntax
} Alg_error;
 
 
struct Alg_pending_event {
    void *cookie; 
    Alg_events *events; 
    long index; 
    bool note_on; 
    double offset; 
    double time; 
};
 
 
class Alg_iterator {
private:
    long maxlen;
    void expand();
    void expand_to(int new_max);
    long len;
    Alg_seq *seq;
    Alg_pending_event *pending_events;
    Alg_events *events_ptr; 
    long index; 
    void *cookie; 
    double offset;
    void show();
    bool earlier(int i, int j);
    void insert(Alg_events *events, long index, bool note_on,
                void *cookie, double offset);
    bool remove_next(Alg_events *&events, long &index, bool &note_on,
                     void *&cookie, double &offset, double &time);
public:
    ~Alg_iterator() { delete[] pending_events; }
    bool note_off_flag;
    long length() { return len; }
    Alg_iterator(Alg_seq *s, bool note_off) {
        seq = s;
        note_off_flag = note_off;
        maxlen = len = 0;
        pending_events = nullptr;
    }

    void begin_seq(Alg_seq *s, void *cookie = nullptr, double offset = 0.0);

    void begin(void *cookie = nullptr) { begin_seq(seq, cookie); }
    Alg_event *next(bool *note_on = nullptr, void **cookie_ptr = nullptr,
                       double *offset_ptr = nullptr, double end_time = 0);
    void request_note_off();
    void end();   
};
 

class Alg_seq : public Alg_track {
protected:
    Alg_iterator *pending; 
    void serialize_seq();
    Alg_error error; 
    Alg_event *write_track_name(std::ostream &file, int n,
                                   Alg_events &events);
public:
    int channel_offset_per_track; 
    Alg_tracks track_list;       
    Alg_time_sigs time_sig;
    int beat_x;
    void basic_initialization() {
        error = alg_no_error;
        units_are_seconds = true; type = 's';
        channel_offset_per_track = 0;
        add_track(0); // default is one empty track
    }
    Alg_seq() {
        basic_initialization();
    }

    Alg_seq(Alg_track &track) { seq_from_track(track); }
    Alg_seq(Alg_track *track) { seq_from_track(*track); }
    void seq_from_track(Alg_track &tr);
    Alg_seq(std::istream &file, bool smf, double *offset_ptr = nullptr);
    Alg_seq(const char *filename, bool smf, double *offset_ptr = nullptr);
    ~Alg_seq() override;
    int get_read_error() { return error; }
    void serialize(void **buffer, long *bytes) override;
    void copy_time_sigs_to(Alg_seq *dest); 
    void set_time_map(Alg_time_map *map) override;

    void unserialize_seq();

    void write(std::ostream &file, bool in_secs, double offset = 0.0);
    bool write(const char *filename, double offset = 0.0);
    void smf_write(std::ostream &file);
    bool smf_write(const char *filename);

    int tracks();

    void add_track(int track_num) {
        track_list.add_track(track_num, get_time_map(), units_are_seconds);
    }

    Alg_track *track(int);
 
    Alg_event *&operator[](int i) override;
 
    void convert_to_seconds() override;
    void convert_to_beats() override;
 
    Alg_track *cut_from_track(int track_num, double start, double dur,
                                 bool all);
    Alg_seq *cut(double t, double len, bool all) override;
    void insert_silence_in_track(int track_num, double t, double len);
    void insert_silence(double t, double len) override;
    Alg_track *copy_track(int track_num, double t, double len, bool all);
    Alg_seq *copy(double start, double len, bool all) override;
    void paste(double start, Alg_seq *seq);
    void clear(double t, double len, bool all) override;
    void merge(double t, Alg_event_list *seq) override;
    void silence(double t, double len, bool all) override;
    void clear_track(int track_num, double start, double len, bool all);
    void silence_track(int track_num, double start, double len, bool all);
    Alg_event_list *find_in_track(int track_num, double t, double len,
                                     bool all, long channel_mask,
                                     long event_type_mask);

    long seek_time(double time, int track_num);
    bool insert_beat(double time, double beat);
    double nearest_beat_time(double time, double *beat);
    bool insert_tempo(double bpm, double beat);
    bool stretch_region(double b0, double b1, double dur);
    void add_event(Alg_event *event, int track_num);
    void add(Alg_event */*event*/) override { assert(false); } 
    double get_tempo(double beat);
    bool set_tempo(double bpm, double start_beat, double end_beat);

    double get_bar_len(double beat);
    void set_time_sig(double beat, double num, double den);
    void beat_to_measure(double beat, long *measure, double *m_beat,
                         double *num, double *den);
    void merge_tracks();    
    void set_in_use(bool flag) override; 
};
 

#endif