144typedef class Alg_parameters {
146 class Alg_parameters *next;
149 Alg_parameters(Alg_parameters *list) {
164 static void insert_real(Alg_parameters **list,
const char *name,
double r);
166 static void insert_string(Alg_parameters **list,
const char *name,
168 static void insert_integer(Alg_parameters **list,
const char *name,
long i);
169 static void insert_logical(Alg_parameters **list,
const char *name,
bool l);
170 static void insert_atom(Alg_parameters **list,
const char *name,
172 static Alg_parameters *remove_key(Alg_parameters **list,
const char *name);
174 Alg_parameter_ptr find(Alg_attribute attr);
175} *Alg_parameters_ptr;
322typedef class Alg_events {
328 Alg_event_ptr *events;
336 double last_note_off;
340 virtual int length() {
return len; }
341 Alg_event_ptr &operator[](
int i) {
342 assert(i >= 0 && i < len);
353 virtual ~Alg_events();
354 void set_events(Alg_event_ptr *e,
long l,
long m) {
358 events = e; len = l; maxlen = m;
361 void insert(Alg_event_ptr event);
362 void append(Alg_event_ptr event);
363 Alg_event_ptr uninsert(
long index);
368typedef class Alg_event_list :
public Alg_events {
371 static const char *last_error_message;
374 static int sequences;
400 virtual Alg_event_ptr &operator[](
int i);
401 Alg_event_list() { sequence_number = 0;
402 beat_dur = 0.0; real_dur = 0.0; events_owner =
nullptr; type =
'e'; }
405 char get_type() {
return type; }
406 Alg_track *get_owner() {
return events_owner; }
410 virtual ~Alg_event_list();
413 double get_beat_dur() {
return beat_dur; }
414 void set_beat_dur(
double d) { beat_dur = d; }
415 double get_real_dur() {
return real_dur; }
416 void set_real_dur(
double d) { real_dur = d; }
426 virtual void set_start_time(
Alg_event *event,
double);
428 const char *get_last_error_message() {
return last_error_message; }
437} *Alg_event_list_ptr, &Alg_event_list_ref;
627 void init_for_write() { ptr = buffer; }
629 void store_long(
long offset,
long value) {
630 assert(offset <= get_posn() - 4);
631 long *loc =
reinterpret_cast<long *
>(buffer + offset);
634 void check_buffer(
long needed);
635 void set_string(
const char *s) {
636 char *fence = buffer + len;
640 while ((*ptr++ = *s++)) {
646#pragma warning(disable: 4311 4312)
648 assert(
reinterpret_cast<char *
>(
reinterpret_cast<long>(ptr + 7) & ~7) <= fence);
650#pragma warning(default: 4311 4312)
654 void set_int32(
long v) {
655 *(
reinterpret_cast<long *
>(ptr)) = v;
658 void set_double(
double v) {
659 *(
reinterpret_cast<double *
>(ptr)) = v;
662 void set_float(
float v) {
663 *(
reinterpret_cast<float *
>(ptr)) = v;
666 void set_char(
char v) {
670#pragma warning(disable: 546)
671#pragma warning(disable: 4311)
674 while (
reinterpret_cast<long>(ptr) & 7) {
679#pragma warning(default: 4311 546)
681 void *to_heap(
long *len) {
683 char *newbuf =
new char[*len];
684 memcpy(newbuf, buffer, *len);
687} *Serial_write_buffer_ptr;
691typedef class Alg_track :
public Alg_event_list {
694 bool units_are_seconds;
695 char *get_string(
char **p,
long *b);
696 long get_int32(
char **p,
long *b);
697 double get_double(
char **p,
long *b);
698 float get_float(
char **p,
long *b);
704 void unserialize_parameter(Alg_parameter_ptr parm_ptr);
706 void serialize_track();
707 void unserialize_track();
708 virtual Alg_event_ptr &operator[](
int i) {
709 assert(i >= 0 && i < len);
712 Alg_track() { units_are_seconds =
false; time_map =
nullptr;
713 set_time_map(
nullptr); type =
't'; }
717 Alg_event_ptr copy_event(Alg_event_ptr event);
719 Alg_track(Alg_track &track);
721 Alg_track(Alg_event_list_ref event_list, Alg_time_map_ptr map,
722 bool units_are_seconds);
723 virtual ~Alg_track() {
725 time_map->dereference();
734 virtual void serialize(
void **buffer,
long *bytes);
738 static Alg_track *unserialize(
void *buffer,
long len);
742 Alg_seq_ptr to_alg_seq() {
743 return (get_type() ==
's' ? (Alg_seq_ptr)
this :
nullptr); }
746 bool get_units_are_seconds() {
return units_are_seconds; }
748 virtual void convert_to_beats();
749 virtual void convert_to_seconds();
750 void set_dur(
double dur);
751 double get_dur() {
return (units_are_seconds ? real_dur : beat_dur); }
768 Alg_note *create_note(
double time,
int channel,
int identifier,
769 float pitch,
float loudness,
double duration);
772 Alg_update *create_update(
double time,
int channel,
int identifier);
777 virtual void add(
Alg_event *event) { insert(event); }
797 virtual Alg_track *cut(
double t,
double len,
bool all);
806 virtual Alg_track *copy(
double t,
double len,
bool all);
818 void paste(
double t, Alg_event_list *seq);
830 virtual void merge(
double t, Alg_event_list_ptr seq);
839 virtual void clear(
double t,
double len,
bool all);
845 virtual void silence(
double t,
double len,
bool all);
852 virtual void insert_silence(
double t,
double len);
864 virtual Alg_event_list *find(
double t,
double len,
bool all,
865 long channel_mask,
long event_type_mask);
867 virtual void set_in_use(
bool flag) { in_use = flag; }
872} *Alg_track_ptr, &Alg_track_ref;
990typedef class Alg_iterator {
994 void expand_to(
int new_max);
999 Alg_events_ptr events_ptr;
1004 bool earlier(
int i,
int j);
1005 void insert(Alg_events_ptr events,
long index,
bool note_on,
1006 void *cookie,
double offset);
1008 bool remove_next(Alg_events_ptr &events,
long &index,
bool ¬e_on,
1009 void *&cookie,
double &offset,
double &time);
1013 long length() {
return len; }
1014 Alg_iterator(Alg_seq_ptr s,
bool note_off) {
1016 note_off_flag = note_off;
1018 pending_events =
nullptr;
1028 void begin_seq(Alg_seq_ptr s,
void *cookie =
nullptr,
double offset = 0.0);
1033 void begin(
void *cookie =
nullptr) { begin_seq(seq, cookie); }
1043 Alg_event_ptr next(
bool *note_on =
nullptr,
void **cookie_ptr =
nullptr,
1044 double *offset_ptr =
nullptr,
double end_time = 0);
1050 void request_note_off();
1058typedef class Alg_seq :
public Alg_track {
1060 Alg_iterator_ptr pending;
1061 void serialize_seq();
1064 Alg_event_ptr write_track_name(std::ostream &file,
int n,
1067 int channel_offset_per_track;
1071 void basic_initialization() {
1072 error = alg_no_error;
1073 units_are_seconds =
true; type =
's';
1074 channel_offset_per_track = 0;
1078 basic_initialization();
1082 Alg_seq(Alg_track_ref track) { seq_from_track(track); }
1083 Alg_seq(Alg_track_ptr track) { seq_from_track(*track); }
1084 void seq_from_track(Alg_track_ref tr);
1086 Alg_seq(std::istream &file,
bool smf,
double *offset_ptr =
nullptr);
1088 Alg_seq(
const char *filename,
bool smf,
double *offset_ptr =
nullptr);
1090 int get_read_error() {
return error; }
1091 void serialize(
void **buffer,
long *bytes);
1092 void copy_time_sigs_to(Alg_seq *dest);
1098 void unserialize_seq();
1101 void write(std::ostream &file,
bool in_secs,
double offset = 0.0);
1103 bool write(
const char *filename,
double offset = 0.0);
1104 void smf_write(std::ostream &file);
1105 bool smf_write(
const char *filename);
1111 void add_track(
int track_num) {
1112 track_list.add_track(track_num, get_time_map(), units_are_seconds);
1117 Alg_track_ptr track(
int);
1119 virtual Alg_event_ptr &operator[](
int i);
1121 virtual void convert_to_seconds();
1122 virtual void convert_to_beats();
1124 Alg_track_ptr cut_from_track(
int track_num,
double start,
double dur,
1126 Alg_seq *cut(
double t,
double len,
bool all);
1127 void insert_silence_in_track(
int track_num,
double t,
double len);
1128 void insert_silence(
double t,
double len);
1129 Alg_track_ptr copy_track(
int track_num,
double t,
double len,
bool all);
1130 Alg_seq *copy(
double start,
double len,
bool all);
1131 void paste(
double start, Alg_seq *seq);
1132 virtual void clear(
double t,
double len,
bool all);
1133 virtual void merge(
double t, Alg_event_list_ptr seq);
1134 virtual void silence(
double t,
double len,
bool all);
1135 void clear_track(
int track_num,
double start,
double len,
bool all);
1136 void silence_track(
int track_num,
double start,
double len,
bool all);
1137 Alg_event_list_ptr find_in_track(
int track_num,
double t,
double len,
1138 bool all,
long channel_mask,
1139 long event_type_mask);
1142 long seek_time(
double time,
int track_num);
1143 bool insert_beat(
double time,
double beat);
1150 double nearest_beat_time(
double time,
double *beat);
1152 bool insert_tempo(
double bpm,
double beat);
1155 bool stretch_region(
double b0,
double b1,
double dur);
1158 void add_event(Alg_event_ptr event,
int track_num);
1159 void add(Alg_event_ptr ) { assert(
false); }
1161 double get_tempo(
double beat);
1162 bool set_tempo(
double bpm,
double start_beat,
double end_beat);
1165 double get_bar_len(
double beat);
1166 void set_time_sig(
double beat,
double num,
double den);
1167 void beat_to_measure(
double beat,
long *measure,
double *m_beat,
1168 double *num,
double *den);
1170 void merge_tracks();
1171 void set_in_use(
bool flag);
1172} *Alg_seq_ptr, &Alg_seq_ref;